ציור על אובייקטים לתמונות על קנבס

מעבדת קוד זו היא חלק מהקורס המתקדם של Android בקורס Kotlin. כדי להפיק את המקסימום מהקורס הזה, אם עובדים על מעבדות הקוד ברצף, לא חובה לעשות זאת. כל שיעורי הקוד של הקורסים מופיעים בדף הנחיתה המתקדם של Android ב-Kotlin codelabs.

מבוא

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

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

סוגי הפעולות שניתן לבצע על קנבס כוללים:

  • ממלאים את כל הקנבס בצבע.
  • יש לשרטט צורות, כמו מלבנים, קשתות ונתיבים בסגנון המוגדר באובייקט Paint. האובייקט Paint מכיל את פרטי הסגנון והצבע לגבי ציור גיאומטריות (כגון קו, מלבן, אליפסה ושבילים) או, לדוגמה, על גוף הטקסט.
  • אפשר להחיל טרנספורמציות, כמו תרגום, שינוי גודל או טרנספורמציות בהתאמה אישית.
  • קליפ. כלומר, אפשר להחיל צורה או נתיב על קנבס כדי להגדיר את החלקים הגלויים שלו.

איך אפשר לחשוב על ציור ב-Android (פשוט מאוד!)

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

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

  1. נדרשת תצוגה כדי להציג את מה שאתה מצייר. ייתכן שזו אחת מהתצוגות שסופקו על ידי מערכת Android. לחלופין, במעבד הקוד הזה, תיצרו תצוגה מותאמת אישית שתשמש כתצוגת התוכן של האפליקציה (MyCanvasView).
  2. כמו כל התצוגות האלה, היא מגיעה עם אזור עריכה משלה (canvas).
  3. הדרך הבסיסית ביותר לציור על קנבס של תצוגה, מבטלת את השיטה onDraw() שלה ומשרטטת על קנבס.
  4. כשיוצרים שרטוט, צריך לשמור את מה ששרטטתם לפני כן. יש כמה דרכים לשמור את הנתונים במטמון, שאחד מהם הוא מפת סיביות (extraBitmap). דרך אחרת היא לשמור היסטוריה של מה ששרטטת כקואורדינטות והוראות.
  5. כדי לצייר את מפת סיביות לשמירה במטמון (extraBitmap) באמצעות ממשק ה-API של שרטוט לוח הציור, עליך ליצור לוח זמנים לשמירה במטמון (extraCanvas) למפת המטמון.
  6. לאחר מכן מציירים את לוח הציור שנמצא במטמון (extraCanvas), שמושך את עצמו למפת המטמון (extraBitmap).
  7. כדי להציג את כל מה שצייר על המסך, אמרתם להדפסות על קנבס (canvas) כדי לשרטט את מפת סיביות לשמירה במטמון (extraBitmap).

דברים שחשוב לדעת

  • איך ליצור אפליקציה עם פעילות, פריסה בסיסית ולהריץ אותה באמצעות Android Studio.
  • איך לשייך רכיבי handler של אירועים לתצוגות מפורטות.
  • כיצד ליצור תצוגה מפורטת מותאמת אישית.

מה תלמדו

  • איך ליצור Canvas ולצייר עליו בתגובה מגע של המשתמש.

הפעולות שתבצעו:

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

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

שלב 1. יצירה של פרויקט MiniPaint

  1. יוצרים פרויקט Kotlin חדש בשם MiniPaint שמשתמש בתבנית ריק של פעילות.
  2. פותחים את הקובץ app/res/values/colors.xml ומוסיפים את שני הצבעים הבאים.
<color name="colorBackground">#FFFF5500</color>
<color name="colorPaint">#FFFFEB3B</color>
  1. פתיחה של styles.xml
  2. בהורה של הסגנון AppTheme הנתון, יש להחליף את DarkActionBar ב-NoActionBar. הפעולה הזו מסירה את סרגל הפעולות כדי שניתן יהיה לשרטט מסך מלא.
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">

שלב 2. יצירת סיווג MyCanvasView

בשלב זה יוצרים תצוגה בהתאמה אישית, MyCanvasView, לשרטוט.

  1. בחבילה app/java/com.example.android.minipaint, יוצרים חדש > קובץ Kotlin/Class בשם MyCanvasView.
  2. יש להפוך את הכיתה ל-MyCanvasView להרחיב את הכיתה View ולעבור בין context: Context. מאשרים את ההצעות לייבוא.
import android.content.Context
import android.view.View

class MyCanvasView(context: Context) : View(context) {
}

שלב 3. הגדרת MyCanvasView כתצוגת התוכן

כדי להציג את מה ששרטטת בMyCanvasView, יש להגדיר אותו כתצוגת התוכן של MainActivity.

  1. פותחים את strings.xml ומגדירים מחרוזת לשימוש בתיאור התוכן של התצוגה המפורטת.
<string name="canvasContentDescription">Mini Paint is a simple line drawing app.
   Drag your fingers to draw. Rotate the phone to clear.</string>
  1. פתיחה של MainActivity.kt
  2. בonCreate(), יש למחוק את setContentView(R.layout.activity_main).
  3. יצירת מכונה של MyCanvasView. 
val myCanvasView = MyCanvasView(this)
  1. למטה, מבקשים את המסך המלא לפריסה של myCanvasView. ניתן לעשות זאת על ידי הגדרת הדגל SYSTEM_UI_FLAG_FULLSCREEN בתאריך myCanvasView. כך התצוגה תמלא את כל המסך.
myCanvasView.systemUiVisibility = SYSTEM_UI_FLAG_FULLSCREEN
  1. מוסיפים תיאור תוכן. 
myCanvasView.contentDescription = getString(R.string.canvasContentDescription)
  1. למטה, מגדירים את תצוגת התוכן ל-myCanvasView. 
setContentView(myCanvasView)
  1. מריצים את האפליקציה. יוצג מסך לבן לחלוטין, כי גודל הקנבס עדיין לא שרטטו ועדיין לא שרטטתם אותו.

שלב 1. שינוי ב-SizeChanged()

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

  1. ב-MyCanvasView, ברמת הכיתה, מגדירים משתנים עבור לוח הציור ומפת סיביות. צריך להתקשר למספר extraCanvas ול-extraBitmap. אלו מפת סיביות ולוח הציור שלך למטמון מה שכבר הוצג.
private lateinit var extraCanvas: Canvas
private lateinit var extraBitmap: Bitmap
  1. מגדירים משתנה ברמת הכיתה backgroundColor לצבע הרקע של אזור העריכה ומאפסים אותו ל-colorBackground שהגדרתם קודם לכן.
private val backgroundColor = ResourcesCompat.getColor(resources, R.color.colorBackground, null)
  1. בMyCanvasView, יש לשנות את השיטה onSizeChanged(). שיטת הקריאה החוזרת הזו מופעלת על ידי מערכת Android עם מאפייני המסך ששונו, כלומר, עם רוחב וגובה חדשים (לשינוי) והרוחב והגובה הישנים (לשינוי מהם).
override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
   super.onSizeChanged(width, height, oldWidth, oldHeight)
}
  1. בתוך onSizeChanged(), יוצרים מופע של Bitmap עם הרוחב והגובה החדשים, שהם גודל המסך ומקצים אותו ל-extraBitmap. הארגומנט השלישי הוא הגדרת צבע המפת. ב-ARGB_8888 נשמרות כל הצבעים ב-4 בייטים ומומלץ.
extraBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
  1. יש ליצור מופע של Canvas מ-extraBitmap ולהקצות אותו ל-extraCanvas. 
 extraCanvas = Canvas(extraBitmap)
  1. יש לציין את צבע הרקע שבו יש למלא את extraCanvas. 
extraCanvas.drawColor(backgroundColor)
  1. כשמביטים ב-onSizeChanged(), מפת סיביות חדשה ולוח שיתופי נוצרים בכל פעם שהפונקציה מופעלת. אתם צריכים מפת סיביות חדשה, כי הגודל השתנה. עם זאת, זוהי דליפת זיכרון המשאירה מפות מפה ישנות. כדי לתקן את הבעיה, יש לעשות שימוש חוזר ב-extraBitmap לפני יצירת הקוד הבא. כדי להוסיף את הקוד הזה אחרי השיחה אל super,
if (::extraBitmap.isInitialized) extraBitmap.recycle()

שלב 2. ביטול OnDraw()

כל עבודות השרטוט עבור MyCanvasView מתבצעות ב-onDraw().

כדי להתחיל, יש להציג את הקנבס, למלא את המסך בצבע הרקע שהוגדר ב-onSizeChanged().

  1. יש לשנות את onDraw() ולשרטט את התוכן של extraBitmap השמור במטמון באזור העריכה המשויך לתצוגה המפורטת. השיטה drawBitmap() Canvas מגיעה בכמה גרסאות. בקוד הזה, עליכם לספק את מפת הביט, קואורדינטות ה-x וה-y (בפיקסלים) שבפינה השמאלית העליונה, וגם null ל-Paint, כפי שתגדירו מאוחר יותר.
override fun onDraw(canvas: Canvas) {
   super.onDraw(canvas)
canvas.drawBitmap(extraBitmap, 0f, 0f, null)
}


לתשומת ליבך, אזור העריכה שמועבר אל onDraw() ומשמש במערכת להצגת מפת הביטים שונה מהמפה שיצרת בשיטה onSizeChanged(), ומשמשת לשרטוט במפת הביטים.

  1. הפעילו את האפליקציה. אתם אמורים לראות את כל המסך עם צבע הרקע שצוין.

כדי לצייר, צריך אובייקט Paint שמציין מה הסגנון של שרטוט, ואובייקט Path שמציין מה משרטט.

שלב 1. אתחול של אובייקט צבע

  1. ב-MyCanvasView.kt, מגדירים קובץ קבוע עבור רוחב הקו. 
private const val STROKE_WIDTH = 12f // has to be float
  1. ברמת הכיתה ב-MyCanvasView, צריך להגדיר משתנה drawColor לצורך השהיית הצבע שיש לשרטט, ולהפעיל אותו באמצעות המשאב colorPaint כפי שהגדרתם קודם לכן. 
private val drawColor = ResourcesCompat.getColor(resources, R.color.colorPaint, null)
  1. ברמת הכיתה, מוסיפים משתנה paint לאובייקט Paint ומפעילים אותו באופן הבא.
// Set up the paint with which to draw.
private val paint = Paint().apply {
   color = drawColor
   // Smooths out edges of what is drawn without affecting shape.
   isAntiAlias = true
   // Dithering affects how colors with higher-precision than the device are down-sampled.
   isDither = true
   style = Paint.Style.STROKE // default: FILL
   strokeJoin = Paint.Join.ROUND // default: MITER
   strokeCap = Paint.Cap.ROUND // default: BUTT
   strokeWidth = STROKE_WIDTH // default: Hairline-width (really thin)
}
  • הcolor מתוך paint הוא הdrawColor שהגדרת קודם.
  • המדיניות isAntiAlias קובעת אם להחיל החלקה בקצה. אם מגדירים את isAntiAlias כ-true, יותאם לקצוות של מה שצייר בלי להשפיע על הצורה.
  • isDither, כאשר true, משפיע על האופן שבו צבעים ברמת דיוק גבוהה יותר מהמכשיר נלקחים בדגימה. לדוגמה, דהייה היא האמצעי הנפוץ ביותר להפחתת טווח הצבעים של התמונות ל-256 (או פחות).
  • style מגדיר את סוג השרטוט לביצוע לסימון קווים, שהוא למעשה קו. Paint.Style מציין אם המקור הציורי מלא, מופרע או את שניהם (באותו צבע). ברירת המחדל היא למלא את האובייקט שעליו הוחל הצבע. ("Fill" צובע את חלקו הפנימי של הצורה, בעוד &"משיכת" עוקב אחר קווי המתאר שלו.)
  • strokeJoin מתוך Paint.Join מציין איך קווים ופלחי עקומה מתחברים לאורך המסלול שנקטע. ערך ברירת המחדל הוא MITER.
  • strokeCap מגדיר את הצורה של סוף הקו כמכסה. Paint.Cap מציין כיצד ההתחלה והסיום של הקווים והנתיבים שנחתכו. ערך ברירת המחדל הוא BUTT.
  • strokeWidth מציין את רוחב הקווים בפיקסלים. ברירת המחדל היא רוחב קו השיער, שהוא דק מאוד, כך שהוא מוגדר לקבוע STROKE_WIDTH שהגדרתם קודם לכן.

שלב 2. אתחול של אובייקט נתיב

הPath הוא הנתיב של מה שהמשתמש מצייר.

  1. ב-MyCanvasView, מוסיפים משתנה path ומאתחלים אותו עם אובייקט Path כדי לאחסן את הנתיב שיש לשרטט כשנוגעים במסך של המשתמש. יבוא android.graphics.Path של Path. 
private var path = Path()

שלב 1. תגובה לתנועה במסך

השיטה onTouchEvent() בתצוגה מפורטת מופעלת בכל פעם שהמשתמש נוגע במסך.

  1. ב-MyCanvasView, צריך לעקוף את השיטה onTouchEvent() כדי לשמור את הקואורדינטות של x ו-y במטמון של event. לאחר מכן, משתמשים בביטוי when כדי לטפל באירועי תנועה כדי לגעת למטה במסך, לנוע במסך ולשחרר את המגע במסך. אלו הם האירועים שמעניינים אותם מבחינת ציור קו על המסך. עבור כל סוג אירוע, יש לקרוא לשיטת שירות כפי שמוצג בקוד הבא. רשימה מלאה של אירועי מגע זמינה בתיעוד של הכיתה MotionEvent.
override fun onTouchEvent(event: MotionEvent): Boolean {
   motionTouchEventX = event.x
   motionTouchEventY = event.y

   when (event.action) {
       MotionEvent.ACTION_DOWN -> touchStart()
       MotionEvent.ACTION_MOVE -> touchMove()
       MotionEvent.ACTION_UP -> touchUp()
   }
   return true
}
  1. ברמת הכיתה, מוסיפים את המשתנים motionTouchEventX ו-motionTouchEventY לשמירה במטמון של ה-x וה-y של אירוע המגע הנוכחי (MotionEvent הקואורדינטות). יש להפעיל אותם מחדש כדי 0f.
private var motionTouchEventX = 0f
private var motionTouchEventY = 0f
  1. אפשר ליצור סבכות לשלוש הפונקציות: touchStart(), touchMove() ו-touchUp().
private fun touchStart() {}

private fun touchMove() {}

private fun touchUp() {}
  1. הקוד צריך לבנות ולהפעיל, אבל עדיין לא תראו שום דבר שונה מהרקע הצבעוני.

שלב 2. הטמעת touchStart()

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

  1. ברמת הכיתה, מוסיפים משתנים כדי לשמור את הערכים האחרונים של x ו-y. אחרי שהמשתמש מפסיק לזוז ומרים את המגע, זו נקודת ההתחלה של הנתיב הבא (הקטע הבא של הקו).
private var currentX = 0f
private var currentY = 0f
  1. מטמיעים את השיטה touchStart() באופן הבא. יש לאפס את path, לעבור לקואורדינטות ה-x של אירוע המגע (motionTouchEventX ו-motionTouchEventY), ולהקצות את currentX ואת currentY לערך הזה.
private fun touchStart() {
   path.reset()
   path.moveTo(motionTouchEventX, motionTouchEventY)
   currentX = motionTouchEventX
   currentY = motionTouchEventY
}

שלב 3. הטמעה של touchMove()

  1. ברמת הכיתה, מוסיפים משתנה touchTolerance ומגדירים אותו ל-ViewConfiguration.get(context).scaledTouchSlop.
private val touchTolerance = ViewConfiguration.get(context).scaledTouchSlop

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

  • אם האצבע כמעט לא זזה, אין צורך לצייר.
  • אם האצבע זזה פחות ממרחק של touchTolerance, אין לשרטט.
  • scaledTouchSlop מחזיר את המרחק בפיקסלים שניתן לנוע בהם לפני שהמערכת סבורה שהמשתמש גולל.
  1. עליך להגדיר את השיטה touchMove(). אפשר לחשב את המרחק שעברתם (dx, dy), ליצור עקומה בין שתי הנקודות ולשמור אותן ב-path, לעדכן את ספירת הריצה currentX ו-currentY ולשרטט את path. לאחר מכן, צריך להתקשר ל-invalidate() כדי לאלץ שרטוט מחדש של המסך עם הגרסה המעודכנת של path.
private fun touchMove() {
   val dx = Math.abs(motionTouchEventX - currentX)
   val dy = Math.abs(motionTouchEventY - currentY)
   if (dx >= touchTolerance || dy >= touchTolerance) {
       // QuadTo() adds a quadratic bezier from the last point,
       // approaching control point (x1,y1), and ending at (x2,y2).
       path.quadTo(currentX, currentY, (motionTouchEventX + currentX) / 2, (motionTouchEventY + currentY) / 2)
       currentX = motionTouchEventX
       currentY = motionTouchEventY
       // Draw the path in the extra bitmap to cache it.
       extraCanvas.drawPath(path, paint)
   }
   invalidate()
}

שיטה זו בפירוט רב יותר:

  1. חישוב המרחק שעבר (dx, dy).
  2. אם התנועה הייתה מעבר לסובלנות המגע, מוסיפים פלח לנתיב.
  3. מגדירים את נקודת ההתחלה של הפלח הבא בנקודת הקצה של הפלח הזה.
  4. שימוש ב-quadTo() במקום ב-lineTo() יאפשר לך לשרטט קו בצורה חלקה וללא פינות. תוכלו לעיין בעקומות עזים.
  5. התקשרו אל invalidate() כדי להתקשר בסופו של דבר אל onDraw() כדי לכוון את התצוגה שוב.

שלב 4: הטמעת TouchUp()

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

  1. הטמעה של השיטה touchUp(). 
private fun touchUp() {
   // Reset the path so it doesn't get drawn again.
   path.reset()
}
  1. מריצים את הקוד ומשתמשים באצבע על המסך כדי לצייר. לתשומת ליבכם, אם מסובבים את המכשיר, המסך נמחק כי מצב הציור לא נשמר. אפליקציה לדוגמה זו תוכננה כדי לספק למשתמש דרך פשוטה לנקות את המסך.

שלב 5: ציור מסגרת מסביב לשרטוט

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

בשלב זה, משרטטים מסגרת מסביב לקצה התמונה.

  1. במערכת ההפעלה MyCanvasView צריך להוסיף משתנה בשם frame שכולל אובייקט Rect.
private lateinit var frame: Rect
  1. בסוף onSizeChanged() יש להגדיר היפוך, ולאחר מכן להוסיף קוד ליצירת Rect שישמש עבור המסגרת, באמצעות המאפיינים החדשים והמאפיין
    .
// Calculate a rectangular frame around the picture.
val inset = 40
frame = Rect(inset, inset, width - inset, height - inset)
  1. בonDraw(), אחרי ציור מפת סיביות, יש לשרטט מלבן.
// Draw a frame around the canvas.
canvas.drawRect(frame, paint)
  1. מפעילים את האפליקציה. שימו לב למסגרת.

משימה (אופציונלי): אחסון נתונים בנתיב

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

  1. ב-MyCanvasView, יש להסיר את כל הקוד של extraCanvas ושל extraBitmap.
  2. מוסיפים משתנים לנתיב עד עכשיו, ואת הנתיב שמוצג כרגע.
// Path representing the drawing so far
private val drawing = Path()

// Path representing what's currently being drawn
private val curPath = Path()
  1. ב-onDraw(), במקום לשרטט את מפת הביטים, יש לשרטט את המסלולים השמורים והנוכחיים. 
// Draw the drawing so far
canvas.drawPath(drawing, paint)
// Draw any current squiggle
canvas.drawPath(curPath, paint)
// Draw a frame around the canvas
canvas.drawRect(frame, paint)
  1. ב-touchUp(), מוסיפים את הנתיב הנוכחי לנתיב הקודם ומאפסים את הנתיב הנוכחי.
// Add the current path to the drawing so far
drawing.addPath(curPath)
// Rewind the current path for the next touch
curPath.reset()
  1. מפעילים את האפליקציה. כן, לא אמור להיות שום שינוי.

צריך להוריד את הקוד של מעבדת הקוד שהסתיימה.

$  git clone https://github.com/googlecodelabs/android-kotlin-drawing-canvas


לחלופין, אפשר להוריד את המאגר כקובץ ZIP, לפתוח אותו ב-Android Studio ולפתוח אותו.

להורדת קובץ Zip
  • Canvas הוא משטח ציור דו-ממדי עם שיטות לשרטוט.
  • ניתן לשייך את Canvas למופע של View שמוצג בו.
  • האובייקט Paint מכיל את פרטי הסגנון והצבע לגבי ציור גיאומטרים (כגון קו, מלבן, אליפסה ונתיבים) וטקסט.
  • דוגמה נפוצה לעבודה עם לוח הציור היא ליצור תצוגה בהתאמה אישית ולעקוף את השיטות onDraw() ו-onSizeChanged().
  • אפשר לעקוף את השיטה onTouchEvent() כדי למשוך מגע של משתמשים ולהגיב להם על ידי שרטוט דברים.
  • אתם יכולים להשתמש במפת סיביות נוספת כדי לשמור מידע במטמון עבור שרטוטים שמשתנים עם הזמן. לחלופין, אפשר לאחסן צורות או נתיב.

קורס אוניברסיטה:

התיעוד של מפתח Android:

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

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

המורים יכולים להשתמש בהצעות האלה כמה שפחות, ומומלץ להקצות להן כל שיעורי בית שדעתם מתאימה להם.

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

מענה על השאלות האלה

שאלה 1

אילו מהרכיבים הבאים נדרשים לצורך עבודה עם Canvas? יש לבחור בכל האפשרויות הרלוונטיות.

▬ Bitmap

▬ Paint

▬ Path

▬ View

שאלה 2

מה עושה קריאה ל-invalidate() (באופן כללי)?

▦ מתקן את האפליקציה ומפעיל אותה מחדש.

▬ למחוק את הציור ממפת הביטים.

הוספה מציין שהקוד הקודם לא צריך לפעול.

הוספה של הודעה מהמערכת על כך שהיא צריכה לשרטט מחדש את המסך.

שאלה 3

מהי הפונקציה של האובייקטים Canvas, Bitmap ו-Paint?

הוספה של משטח ציור דו-ממדי, מפת סיביות שמופיעה במסך, פרטי סגנון לשרטוט.

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

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

הוספה במטמון של פרטי שרטוט, מפת סיביות של שרטוט, עיצוב סגנון לשרטוט.

קישורים למעבדות אחרות של הקוד בקורס הזה זמינים בדף הנחיתה של מכשירי Android מתקדמים בדף Kotlin codelabs.