PracticU

אובייקט Canvas באנדרואיד

בלי כתוביותעם כתוביות
PracticU › קורס פיתוח אפליקציות - לאנדרואיד - Android - ב-JAVA › אובייקט Canvas באנדרואיד
מילון מושגים:
רכיב - יחידת בניין עצמאית וניתנת לשימוש חוזר בתוך מערכת או ממשק משתמש, שאחראית על חלק מוגדר מהתפקוד.
תמונה - קובץ גרפי המוצג על המסך. בהקשר של וירטואליזציה או Docker, תבנית מוכנה שממנה יוצרים מכונה או קונטיינר.
Java - שפת תכנות עילית ומונחית עצמים, הרצה על מכונה וירטואלית (JVM) ומשמשת לפיתוח מגוון יישומים.
View - רכיב שאחראי על הצגת המידע למשתמש (התצוגה) בדפוס MVC. גם טבלה וירטואלית מבוססת שאילתה במסד נתונים.
בנאי - מתודה מיוחדת שמופעלת אוטומטית בעת יצירת אובייקט ממחלקה, ומאתחלת את ערכיו ההתחלתיים.
לייאאוט - ארגון וסידור הרכיבים החזותיים על המסך או בדף, כמו מיקום כפתורים, טקסט ותמונות.
חבילה - אוסף ארוז של קוד, ספריות או קבצים המופץ כיחידה אחת ומותקן בעזרת מנהל חבילות.
אמולטור - תוכנה שמחקה מכשיר או סביבה אחרת, למשל כדי להריץ ולבדוק אפליקציית מובייל על המחשב.

אובייקט Canvas באנדרואיד
התחלה של גרפיקה באנדרואיד: בונים רכיב ויזואלי משלנו שמצייר על עצמו צורות, טקסט ותמונה בעזרת האובייקט Canvas.
רעיון הבסיס
לכל רכיב ויזואלי יש פונקציה onDraw שמקבלת אובייקט Canvas, בד הציור. מה שמצוירים עליו נראה ברכיב שמכיל את הפונקציה. כאן הרכיב פשוט מצייר את עצמו, ובהרצאה הבאה נותנים גם למשתמש לצייר.
השלבים העיקריים
1. מחלקה חדשה: יוצרים מחלקת Java בשם CanvasView שיורשת מ-View. ה-constructor מקבל Context ו-AttributeSet ומעביר אותם ל-super.
2. דריסת onDraw: מוחקים את הקריאה ל-super, כי הרכיב מצייר הכול בעצמו.
3. עיגול: drawCircle מקבלת מרכז (cx ו-cy), רדיוס ואובייקט Paint. ה-Paint הוא המברשת. מגדירים לו סגנון STROKE (קו מסביב לצורה) או FILL, עובי קו וצבע, כאן ירוק עם עובי 10. הערכים בהדגמה: 150, 100 ורדיוס 50.
4. הצבה ב-layout: כותבים ב-layout את CanvasView עם שם ה-package המלא, ו-match_parent.
5. פונקציה לכל ציור: כדי להפריד, כל ציור עובר לפונקציה נפרדת שמקבלת את ה-Canvas: drawCircle, drawRectangle, drawLine, drawPath, drawText ו-drawImage.
6. מלבן: drawRect מקבלת left, top, right ו-bottom, כלומר המרחקים של צידי המלבן מהצד השמאלי ומהצד העליון של המסך, ו-Paint עם FILL וצבע כחול. בהדגמה 250, 200, 450 ועוד ערך תחתון.
7. קו: drawLine מקבלת נקודת התחלה ונקודת סיום ו-Paint עם STROKE, עובי 5 וצבע אדום.
8. נתיב: אובייקט Path מתאר סדרת נקודות. moveTo רק מתחיל מנקודה בלי לצייר, ו-lineTo מושך קו אליה. בהדגמה מ-(150,200) ל-(200,300) ואז ל-(100,300), וסוגרים עם close למשולש. מציירים עם drawPath ושולחים את ה-Path וה-Paint.
9. טקסט: Paint עם צבע cyan וגודל טקסט 50, ו-drawText עם המחרוזת Welcome ומיקום x ו-y.
10. תמונה: יוצרים Bitmap עם BitmapFactory.decodeResource מתוך משאב drawable של סמיילי, ומציירים עם drawBitmap בנקודה נתונה ועם Paint.
שימו לב
הערכים בהדגמה הם פיקסלים קבועים בקוד, ולכן הציור נראה בגדלים שונים באמולטור ובמכשיר האמיתי. כדי שייראה אותו דבר בכל המכשירים צריך לחשב לפי ה-density, אבל בהרצאה זה נשאר פשוט בכוונה.
גרפיקה סטטית כזו מתאימה כשהציור הוא חלק מהרכיב שבונים. בהרצאה הבאה משתמשים באותו Canvas כדי שהמשתמש יצייר בעצמו.
השיעור הבא בקורס: שליחת מאפיינים לרכיב

פרקי ההרצאה: אובייקט Canvas באנדרואיד

  1. 00:00

    הפונקציה onDraw ואובייקט Canvas

  2. 00:57

    יצירת מחלקה שיורשת מ-View

  3. 02:37

    דריסת onDraw וציור עיגול

  4. 03:32

    הגדרת מברשת עם אובייקט Paint

  5. 04:58

    הצבת הרכיב ב-Layout והרצה

  6. 05:54

    מידות קבועות מול Density

  7. 06:30

    פונקציות ציור נפרדות ומלבן

תמלול ההרצאה: אובייקט Canvas באנדרואיד

הטקסט המלא של הדקות הראשונות בהרצאה «אובייקט Canvas באנדרואיד» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:02

    אנחנו מגיעים לנושא הגרפיקה, כלומר איך אנחנו יכולים לצייר על המסך. לציור הזה זה יכול להיות צורות סטטיות רגילות שאנחנו יכולים להציב, וזה יכול להיות לאפשר ליוזר לצייר בעצמו.

  2. 00:17

    לכל רכיב שאנחנו יכולים להשתמש בו או להציב אותו על אקטיביטי קיימת פונקציה בשם onDraw שמקבלת אובייקט מטיפוס שנקרא Canvas. Canvas זה בד ציור שמשמש ציירים. אובייקט הקנבאס מכיל כל מיני פונקציות שמאפשרות לצייר על עצמו.

  3. 00:38

    אם אנחנו מציירים על אובייקט הקנבאס, אז רואים את הציור הזה על הרכיב הוויזואלי שמכיל את הפונקציה onDraw, ואז כמובן היוזר רואה את הציורים. בסרטון הזה אנחנו הולכים לראות איך לעבוד עם אובייקט הקנבאס, ומהם היכולות שלו בעצם.

  4. 00:57

    בסרטונים הבאים נראה איך אנחנו יכולים לאפשר גם למשתמש לבצע ציור על המסך, כמובן על ידי שימוש באובייקט הקנבאס. אז מה שאנחנו רוצים לעשות זה לבנות רכיב ויזואלי חדש שפשוט מצייר על עצמו כמה דברים.

  5. 01:14

    זה יכול להתבצע על ידי מחלקה חדשה שאנחנו בונים שיורשת איזשהו רכיב ויזואלי קיים או שיורשת את הרכיב הבסיסי של כל הרכיבים הוויזואליים, כלומר את ה-view, וזה בדיוק מה שאנחנו הולכים לעשות.

  6. 01:29

    אנחנו הולכים ליצור מחלקה חדשה לגמרי שיורשת את view ולכן גם המחלקה מה שאנחנו בונים היא view וניתן להציב אותה על אקטיביטי. אז בואו נעשה את זה, פה נצרף מחלקה חדשה, יש לנו פה new Java class ונקרא לה סתם canvas view.

  7. 01:52

    אנחנו רוצים to extend view ואנחנו רוצים constructor canvas view ובגלל שאנחנו רכיב ויזואלי שהולך להיות מוצב על אקטיביטי, אם אתם זוכרים אנחנו צריכים לקבל קונטקסט ואנחנו צריכים לקבל אטריביוט סט שזה בעצם האטריביוט שמוגדרים בלייאוט עבור הרכיב שאנחנו בונים כרגע כשאנחנו מציבים אותו על הלייאוט אנחנו צריכים להעביר לסופר את הקונטקסט ואת

  8. 02:29

    האטריביוט סט ומכאן כל מה שאנחנו בונים זה הרכיב החדש שלנו אז אנחנו רוצים לדרוס את הפונקציה onDraw שדיברנו עליה ושימו לב שהיא מקבלת הנה דרסנו אותה.

  9. 02:46

    ניפטר רגע מהסופר הזה, אנחנו לא צריכים אותו כי אנחנו מציירים הכל בעצמנו. ובתוך הפונקציה אנחנו פשוט מבצעים את הציור על ידי שימוש באובייקט הקנבאס שקיבלנו. אז בואו נראה את זה.

  10. 03:00

    יש לנו כאן קנבאס נקודה ואנחנו רואים שיש פה כל מיני פונקציות שמאפשרות לצייר. לדוגמה draw circle. בואו נצייר משהו פשוט בתור התחלה, פשוט מאוד עיגול אנחנו רואים שאנחנו מקבלים x cx זה אומר ה-center של ה-x cy center y שזה בעצם המרחק מציר x והמרחק מציר y מההתחלה וזה בעצם המרחק מהנקודה השמאלית העליונה לאחר מכן רדיוס בואו

  11. 03:34

    רגע נראה מה עוד הפונקציה רוצה מאיתנו ואחרי הרדיוס אנחנו צריכים להעביר אובייקט pain ויש כל מיני אובייקטים שתומכים בגרפיקה ומאפשרים לצייר.

  12. 03:47

    לדוגמה, Paint מתאר פשוט מברשת. אז בואו נראה איך אנחנו יכולים לעשות את זה. נבנה איזשהו אובייקט Paint שווה New Paint. הנה יש לנו פה אובייקט חדש. נגדיר Set Style.

  13. 04:07

    Set Style זה Paint.Style. ויש לנו פה לדוגמה פיל אם אנחנו רוצים שזה יהיה מברשת מלאה, סטרוק אם אנחנו רוצים שזה יהיה קו שעוטף את הצורה בואו נבחר סטרוק יש לנו פיינט נקודה סט סטרוק וויד מה האורך של הקו בואו ניתן לו 10 בתור התחלה ובואו ניקח את סט קולור וניתן לו קולור גרין הנה יש לנו כאן כבר צבע ירוק ואנחנו כבר יכולים לבוא לדרו סרקל ולהגדיר

  14. 04:49

    שבוא נניח הx שלנו זה 150 מהקצה השמאלי של המסך, ה-Y שלנו זה 100 מהחלק העליון של המסך, הרדיוס זה 50, והנה הפיינט שלנו, וכבר כאן אנחנו יכולים לראות את העיגול הזה על המסך.

  15. 05:10

    אז קודם כל אנחנו רוצים לקחת את האובייקט החדש שבנינו ולהציב אותו על ה-Layout. אם אנחנו מסתכלים על ה-Layout אז אין בו כלום. איך אנחנו מציבים אותו? פשוט רושמים כאן ויוס שזה האובייקט, ואנחנו רואים פה את כל ה-package שמתחיל אותו, ובואו ניקח match parent וכבר עכשיו אנחנו יכולים לבצע בדיקה.

  16. 05:36

    אז בואו נריץ, והנה אנחנו רואים שהתוכנית רצה על המכשיר האמיתי, והנה היא רצה על האמולטור ואנחנו ממש רואים את הציור שציירנו.

  17. 05:47

    הרכיב תופס את כל השטח ואנחנו רואים את העיגול שציירנו על גבי ה-canvas. שימו לב שהממדים הם שונים, השתמשנו במספרים Fixed כאלה, Hard Coded, וכמובן אם היינו רוצים שהדבר הזה ייראה אותו הדבר בכל המכשירים, אז היינו צריכים לבצע כאן חישוב של ה-DPI או ה-Density של המכשיר, ולפי זה לקבוע את הממדים שאנחנו רוצים.

  18. 06:19

    אבל לצורך הבנה של איך לעבוד עם ה-Canvas, אנחנו רוצים לשמור על פשטות כרגע בדוגמה, ולכן פשוט נכתוב כאן מספרים hardcoded בקוד, כך שיהיה מאוד מאוד סימפל להבין את זה. אז בואו נראה עוד כל מיני יכולות שקיימות ברכיב ה-canvas.

  19. 06:39

    אז לצורך כך, מה שנעשה זה לבצע הפרדה בין הציורים השונים על ידי בניית פונקציות שמציירות כל פעם משהו אחר. הפונקציה הראשונה הצעירה היא גול, אז בואו נקרא לה draw circle, ומקבלת את אובייקט ה-canvas ומבצעת את הציור כפי שעשינו כאן.

  20. 07:00

    נעתיק את כל הקוד הזה לפה ופשוט נקרא מכאן לפונקציה drawCircle ונשלח לה את אובייקט ה-canvas. הפונקציה הבאה שאנחנו רוצים לעשות, בואו פשוט נעתיק כל הפונקציה הזאת, נדביק ונקרא לה בשם drawRickTangle והיא בעצם תצייר לנו מלבן.

  21. 07:30

    נשלח לה את אובייקט הקנבאס, מה אנחנו רוצים לשנות בה? אנחנו רוצים אובייקט פיינט כמובן, שמאפשר להגדיר את האט לציור. בואו ניקח עכשיו סטייל אחר, בואו ניקח פיל, יש לנו פה נקודה פסיק רק שצריך להגדיר.

  22. 07:49

    אין לנו סטרוק ווי בגלל שאנחנו לא סטרוק, אז בואו נוריד את זה ונגדיר כאן צבע אחר לדוגמה בלו וניתן לו מימדים אחרים. אנחנו גם כמובן רוצים להפעיל את דרו-ריקטנגל שזה דרו-רקט וניתן לה כזה דבר.

  23. 08:12

    אנחנו רואים שקודם כל אנחנו צריכים לתת left ובואו ניתן כאן 250 שיהיה בממדים אחרים שלא יעלה לנו על העיגול היפה שציירנו מקודם.

  24. 08:24

    הדבר הבא זה top זה יהיה נניח 200. לאחר מכן right, כלומר המרחק מצד ימין של המסך, זה יהיה 450 והמרחק מהחלק התחתון של המסך זה יהיה בוטום.

  25. 08:43

    למעשה זה היה טעות שלי, זה לא המרחק מצד ימין או שמאל של המסך, זה בעצם הצד השמאלי של המסך, אם אנחנו מסתכלים אנחנו רואים שזה לפט, זה בוודאות צד שמאל, זה בוודאות מרחק מהחלק העליון של המסך, הטופ.

  26. 09:04

    רייט זה הצד הימני של המלבן, המרחק שלו מהצד השמאלי של המסך ויש לנו פה את הבוטום שזה החלק התחתון של המלבן מה המרחק שלו מהחלק העליון של

לקורס המלא: קורס פיתוח אפליקציות לאנדרואיד

ההרצאה הקודמת: זיהוי מובנה של Gesture Detectors

ההרצאה הבאה: שליחת מאפיינים לרכיב

הרצאות קשורות מקורסים אחרים

  • אובייקט Screen
  • פרוקסי באנדרואיד עם Burp
  • שפת JavaScript - אובייקט
  • החזרת אובייקט ב-JSON

קורסים נוספים במסלול

  • קורס יסודות התכנות - שפת JAVA - קורס ג'אווה למתחילים
  • קורס פיתוח אפליקציות - לאייפון iPhone iOS - ב-Swift-Xcode
  • קורס פלאטר - Flutter - שפת DART של גוגל למובייל - פיתוח אפליקציות לאנדרואיד ואייפון
  • קורס PhoneGap - פיתוח אפליקציות לאנדרואיד ואייפון