משאבים שניתנים לשרטוט

משאב ניתן לשרטוט הוא קונספט כללי לגרפיקה שניתן לצייר למסך ו אפשר לאחזר באמצעות ממשקי API כמו getDrawable(int), או להחיל למשאב XML אחר עם מאפיינים כמו android:drawable ו-android:icon. יש כמה סוגים של פריטים גרפיים:

קובץ מפת סיביות (Bitmap)
קובץ גרפי של מפת סיביות (PNG , WEBP , JPG או GIF). ייווצר BitmapDrawable.
קובץ תשעה תיקונים
קובץ PNG עם אזורים שאפשר למתוח, שמאפשר לשנות גודל של תמונות על סמך התוכן (.9.png). הפונקציה יוצרת NinePatchDrawable.
רשימת שכבות
מכשיר שניתן להזזה שמנהל מערך של פריטים שניתן להזזה. הם משורטטים לפי סדר מערך, כך עם האינדקס הגדול ביותר מצויר למעלה. ייווצר LayerDrawable.
רשימת מדינות
קובץ XML שמפנה לגרפיקה שונה של מפת סיביות (bitmap) למצבים שונים - לדוגמה, להשתמש בתמונה שונה כשמקישים על לחצן. ייווצר StateListDrawable.
רשימת רמות
קובץ XML שמגדיר פריט שניתן להזזה שמנהל מספר פריטים ניתנים להזזה, כל אחד מהם לפרמטר הוקצה ערך מספרי מקסימלי. ייווצר LevelListDrawable.
כלי מעבר שניתן להזזה
קובץ XML שמגדיר פריט גרפי שניתן להזזה עם אפשרות עמעום הדרגתי בין שני משאבים שניתנים להזזה. ייווצר TransitionDrawable.
פריט שניתן להזזה
קובץ XML שמגדיר פריט גרפי שניתן להזזה שמציב פריט אחר שניתן להזזה לפי מרחק שצוין. האפשרות הזו שימושית כשצריך להשתמש בתמונה שניתן להזזה לרקע הקטן מהרקע של התצוגה גבולות.
ניתן לצייר עם תופסן
קובץ XML שמגדיר פריט גרפי שניתן להזזה שמדביק פריט אחר שניתן להזזה על סמך ערך הרמה הנוכחית. ייווצר ClipDrawable.
שינוי קנה מידה של פריט גרפי
קובץ XML שמגדיר פריט גרפי שניתן להזזה שמשנה את הגודל של פריט גרפי אחר להזזה על סמך ערך הרמה הנוכחית. יצירת ScaleDrawable
צורה שניתן לצייר.
קובץ XML שמגדיר צורה גיאומטרית, כולל צבעים ומעברים הדרגתיים. ייווצר GradientDrawable.

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

הערה: אפשר גם להגדיר משאב צבע משמש כרכיב שניתן לשרטוט ב-XML. לדוגמה, כשיוצרים רשימת מדינות שניתן להזזה, אפשר להפנות למשאב צבעים עבור המאפיין android:drawable (android:drawable="@color/green").

מפת סיביות (bitmap)

תמונה של מפת סיביות (bitmap). Android תומך בקובצי מפת סיביות (bitmap) בפורמטים הבאים: PNG (מועדף), WEBP (מועדף, נדרש API ברמה 17 ומעלה), JPG (קביל), GIF (לא מומלץ).

אתם יכולים להפנות ישירות לקובץ מפת סיביות (bitmap) ולהשתמש בשם הקובץ כמזהה המשאב, או ליצור מזהה משאב חלופי ב-XML.

הערה: קובצי מפת סיביות (Bitmap) עשויים לעבור אופטימיזציה באופן אוטומטי ללא אובדן מידע דחיסת תמונות על ידי הכלי aapt במהלך תהליך ה-build. עבור לדוגמה, קובץ PNG בצבע אמיתי שלא דורש יותר מ-256 צבעים עשוי להיות מומר ל-8 ביט קובץ PNG עם לוח צבעים. התוצאה היא תמונה באיכות זהה שדורשת פחות זיכרון.

לכן, חשוב לשים לב שהקבצים הבינאריים של התמונות המוצבים בספרייה הזו עשויים להשתנות במהלך ה-build. אם המיקום אתם מתכננים לקרוא תמונה בתור זרם קצר כדי להמיר אותה למפת סיביות (bitmap), במקום זאת, את התיקייה res/raw/, שבה לא בוצעה אופטימיזציה שלהן.

קובץ מפת סיביות (bitmap)

קובץ מפת סיביות (bitmap) הוא קובץ PNG, WEBP, JPG או GIF. מערכת Android יוצרת Drawable עבור כל אחד מהקבצים האלה כששומרים אותם בספרייה res/drawable/.

מיקום הקובץ:
res/drawable/filename.png (.png, .webp, .jpg או .gif)
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לBitmapDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
דוגמא:
עם תמונה ששמורה ב-res/drawable/myimage.png, הפריסה הזו של XML חלה את התמונה לתצוגה:
<ImageView
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:src="@drawable/myimage" />

קוד האפליקציה הבא מאחזר את התמונה בתור Drawable:

Kotlin

val drawable: Drawable? = ResourcesCompat.getDrawable(resources, R.drawable.myimage, null)

Java

Resources res = getResources();
Drawable drawable = ResourcesCompat.getDrawable(res, R.drawable.myimage, null);
למידע נוסף:

מפת סיביות (bitmap) של XML

מפת סיביות של XML היא משאב שמוגדר ב-XML שמפנה לקובץ מפת סיביות (bitmap). האפקט הוא כינוי של קובץ RAW של מפת סיביות (bitmap). ה-XML יכול לציין מאפיינים נוספים למפת הסיביות, כמו שילוב צבעים ואריחים.

הערה: אפשר להשתמש ברכיב <bitmap> כצאצא של רכיב <item>. עבור לדוגמה, כשיוצרים רשימת מצבים או רשימת שכבות, אפשר להחריג את android:drawable מרכיב <item> ומציבים בתוכו <bitmap> שמגדיר את הפריט שניתן להזזה.

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לBitmapDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<bitmap
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@[package:]drawable/drawable_resource"
    android:antialias=["true" | "false"]
    android:dither=["true" | "false"]
    android:filter=["true" | "false"]
    android:gravity=["top" | "bottom" | "left" | "right" | "center_vertical" |
                      "fill_vertical" | "center_horizontal" | "fill_horizontal" |
                      "center" | "fill" | "clip_vertical" | "clip_horizontal"]
    android:mipMap=["true" | "false"]
    android:tileMode=["disabled" | "clamp" | "repeat" | "mirror"] />
רכיבים:
<bitmap>
חובה. הגדרת המקור של מפת הסיביות והתכונות שלו.

מאפיינים:

xmlns:android
מחרוזת. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android" צריך לעשות זאת רק אם <bitmap> הוא הרכיב הבסיסי (root). אין בו צורך כאשר <bitmap> נמצא בתוך <item>.
android:src
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה משאב.
android:antialias
בוליאני. המתג מפעיל או משבית את פעולת הנטרול.
android:dither
בוליאני. המתג מפעיל או משבית את שיתוף הנתונים של מפת הסיביות אם להגדיר את אותה תצורת פיקסלים כמו במסך, למשל מפת סיביות של ARGB 8888 ב-RGB 565 מסך.
android:filter
בוליאני. המדיניות מפעילה או משביתה סינון לפי מפת סיביות (bitmap). המערכת משתמשת בסינון כאשר מפת סיביות תכווץ או נמתח כדי להחליק את המראה שלה.
android:gravity
מילת מפתח. מגדיר את כוח המשיכה עבור מפת הסיביות. כוח הכבידה מציין לאן ממקמים את הפריט הגרפי בקונטיינר אם מפת הסיביות קטנה יותר מהקונטיינר.

חייב להיות לפחות אחד מהערכים הקבועים הבאים, ולהפריד ביניהם באמצעות |:

ערךתיאור
top ממקמים את האובייקט בחלק העליון של הקונטיינר, בלי לשנות את הגודל שלו.
bottom ממקמים את האובייקט בתחתית הקונטיינר, ולא משנים את גודלו.
left ממקמים את האובייקט בקצה השמאלי של הקונטיינר, בלי לשנות את גודלו.
right ממקמים את האובייקט בקצה הימני של הקונטיינר, בלי לשנות את גודלו.
center_vertical ממקמים את העצם במרכז האנכי של הקונטיינר, בלי לשנות את גודלו.
fill_vertical במקרה הצורך, מגדילים את הגודל האנכי של העצם כך שהוא ימלא את המכל במלואו.
center_horizontal צריך למקם את האובייקט במרכז האופקי של הקונטיינר שלו, בלי לשנות את הגודל שלו.
fill_horizontal במקרה הצורך, מגדילים את הגודל האופקי של האובייקט כך שימלא את הקונטיינר שלו במלואו.
center צריך למקם את האובייקט במרכז הקונטיינר שלו גם בציר האנכי וגם בציר האופקי, ולא משנה את גודלו.
fill במקרה הצורך, מגדילים את הגודל האופקי והאנכי של האובייקט כך שהוא ימלא את כל החלקים שלו. מאגר תגים. (זוהי ברירת המחדל)
clip_vertical אפשרות נוספת שאפשר להגדיר לחיתוך של הקצה העליון או התחתון של הילד או הילדה את גבולות הקונטיינר שלו. הקליפ מבוסס על הכוח האנכי: הקצה התחתון, כוח הכבידה התחתון מצמיד את הקצה העליון, ואף אחד מהקצוות לא מצמיד את שניהם.
clip_horizontal אפשרות נוספת שאפשר להגדיר לחיתוך של הקצה השמאלי או הימני של הילד או הילדה את גבולות הקונטיינר שלו. הקליפ מבוסס על כוח הכבידה האופקי: קליפים שצולמו בכוח הכבידה השמאלי הקצה הימני, כוח הכבידה הימני מצמיד את הקצה השמאלי, ואף אחד מהקצוות לא מקצר.
android:mipMap
בוליאני. המתג מפעיל או משבית את הרמז ל-mipmap. מידע נוסף זמין בכתובת setHasMipMap(). ערך ברירת המחדל הוא False.
android:tileMode
מילת מפתח. מגדיר את מצב המשבצת. כשמצב משבצת מופעל, מפת הסיביות מופעלת שחוזרת על עצמה. המערכת מתעלמת מכוח המשיכה כשמצב המשבצת מופעל.

חייב להיות אחד מהערכים הקבועים הבאים:

ערךתיאור
disabled אל תשתפו את מפת הסיביות. זהו ערך ברירת המחדל.
clamp משכפלים את צבע הקצה אם כלי ההצללה חוצה את הגבולות המקוריים
repeat חוזרים על התמונה של הצללית לרוחב ומאונך.
mirror חזרה על תמונת הצללה באופן אופקי ואנכי, על תמונות מראה מתחלפות כך תמונות סמוכות תמיד יכולות לתפור.
דוגמא:
<?xml version="1.0" encoding="utf-8"?>
<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@drawable/icon"
    android:tileMode="repeat" />
למידע נוסף:

תשעה תיקונים

NinePatch הוא תמונה בפורמט PNG שבה אפשר להגדיר אזורים שאפשר להרחיב ש-Android מדרג את הגודל כשהתוכן בתצוגה חורג מגבולות התמונה הרגילים. שלך בדרך כלל מקצים את סוג התמונה הזה כרקע של תצוגה שיש בה לפחות קבוצת מאפיינים אחת אל "wrap_content".

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

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

לדיון מלא על יצירת קובץ תשעה תיקונים עם אזורים שאפשר למתוח, כדאי לעיין במאמר בנושא יצירת מפות סיביות (bitmaps) שניתן לשנות את הגודל שלהן (קובצי 9-patch).

קובץ תשעה תיקונים

מיקום הקובץ:

res/drawable/filename.9.pngבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לNinePatchDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
דוגמא:
באמצעות תמונה שנשמרה ב-res/drawable/myninepatch.9.png, הפריסה הזו בפורמט XML מחיל את תשעה התיקונים על תצוגה מפורטת:
<Button
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:background="@drawable/myninepatch" />
למידע נוסף:

תשעה תיקונים בפורמט XML

תיקון XML תשעה הוא משאב שמוגדר ב-XML שמצביע אל קובץ תשעה תיקונים. קובץ ה-XML יכול הגדרת המיזוג של התמונה.

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לNinePatchDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<nine-patch
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@[package:]drawable/drawable_resource"
    android:dither=["true" | "false"] />
רכיבים:
<nine-patch>
חובה. מגדיר את המקור של תשעה התיקונים ואת המאפיינים שלו.

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
android:src
משאב שניתן לשרטוט. חובה. הפניה לתשעה תיקונים חדש.
android:dither
בוליאני. המתג מפעיל או משבית את שיתוף הנתונים של מפת הסיביות אם להגדיר את אותה תצורת פיקסלים כמו במסך, למשל מפת סיביות של ARGB 8888 ב-RGB 565 מסך.
דוגמא:
<?xml version="1.0" encoding="utf-8"?>
<nine-patch xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@drawable/myninepatch"
    android:dither="false" />

רשימת שכבות

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

כל פריט גרפי שניתן להזזה מיוצג על ידי רכיב <item> בתוך רכיב <layer-list> יחיד.

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לLayerDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<layer-list
    xmlns:android="http://schemas.android.com/apk/res/android" >
    <item
        android:drawable="@[package:]drawable/drawable_resource"
        android:id="@[+][package:]id/resource_name"
        android:top="dimension"
        android:right="dimension"
        android:bottom="dimension"
        android:left="dimension" />
</layer-list>
רכיבים:
<layer-list>
חובה. הוא חייב להיות הרכיב הבסיסי (root). מכיל רכיב <item> או יותר.

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
<item>
מגדירה פריט שניתן להזזה להצבה בשכבה שניתנת להזזה, במיקום שמוגדר על ידי המאפיינים שלה. חייב להיות צאצא של רכיב <layer-list>. מקבלים <bitmap> צאצאים רכיבים.

מאפיינים:

android:drawable
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה משאב.
android:id
מזהה משאב מזהה משאב ייחודי לגרפיקה הזו. כדי ליצור משאב חדש מזהה של פריט זה, יש להשתמש בטופס: "@+id/name" סמל הפלוס מציין שמחרוזת הזו נוצרה ID. אפשר להשתמש במזהה הזה כדי מאחזרים ומשנים את הפריט הניתן להזזה באמצעות View.findViewById() או Activity.findViewById().
android:top
מאפיין. ההיסט העליון, כערך מאפיין או משאב מאפיין.
android:right
מאפיין. ההיסט הנכון, כערך מאפיין או משאב מאפיין.
android:bottom
מאפיין. ההיסט התחתון, כערך מאפיין או משאב מאפיין.
android:left
מאפיין. ההיסט השמאלי, כערך מאפיין או כמשאב מאפיין.

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

כדי להימנע יש להשתמש ברכיב <bitmap> בתוך הרכיב <item> כדי לציין את הפריט שניתן להזזה ולהגדיר את כוח המשיכה למשהו שלא קנה מידה גדול, כמו "center". לדוגמה, המאפיין <item> הבא מגדיר פריט שגודלו משתנה כדי להתאים לתצוגת הקונטיינר שלו:

<item android:drawable="@drawable/image" />

כדי להימנע משינוי קנה מידה, בדוגמה הבאה נעשה שימוש ברכיב <bitmap> עם מרכז כוח הכבידה:

<item>
  <bitmap android:src="@drawable/image"
          android:gravity="center" />
</item>
דוגמא:
קובץ XML נשמר ב-res/drawable/layers.xml:
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item>
      <bitmap android:src="@drawable/android_red"
        android:gravity="center" />
    </item>
    <item android:top="10dp" android:left="10dp">
      <bitmap android:src="@drawable/android_green"
        android:gravity="center" />
    </item>
    <item android:top="20dp" android:left="20dp">
      <bitmap android:src="@drawable/android_blue"
        android:gravity="center" />
    </item>
</layer-list>

בדוגמה הזו נעשה שימוש ברכיב <bitmap> בתוך רכיב כדי להגדיר את פריט הגרפיקה לכל פריט עם כוח המשיכה "center". כך אפשר לוודא שאף אחת מהתמונות לא תשתנה להתאים לגודל המכל, בגלל שינוי הגודל שנגרם על ידי תמונות ההיסט.

קובץ ה-XML של הפריסה מחיל את הפריט הניתן להזזה על תצוגה:

<ImageView
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:src="@drawable/layers" />

התוצאה היא מקבץ של תמונות שההיסט שלו הולך וגדל:

למידע נוסף:

רשימת מדינות

StateListDrawable הוא אובייקט שניתן לשרטוט ומוגדר ב-XML. שמשתמש בכמה תמונות כדי לייצג את אותה גרפיקה, בהתאם למצב של האובייקט. לדוגמה, ניתן להקיש על המצב של הווידג'ט Button, להתמקד בו, או אף אחד מהם; באמצעות רשימת מצבים שניתן לצייר, אפשר לספק תמונת רקע שונה לכל אחד מהם .

עליכם לתאר את רשימת המצבים בקובץ XML. כל פריט גרפיקה מיוצג על ידי רכיב <item> בתוך רכיב <selector> יחיד. בכל <item> משתמשת במאפיינים שונים כדי לתאר את המצב שבו היא משמשת בתור הגרפיקה של פריט גרפי שניתן להזזה.

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

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לStateListDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android"
    android:constantSize=["true" | "false"]
    android:dither=["true" | "false"]
    android:variablePadding=["true" | "false"] >
    <item
        android:drawable="@[package:]drawable/drawable_resource"
        android:state_pressed=["true" | "false"]
        android:state_focused=["true" | "false"]
        android:state_hovered=["true" | "false"]
        android:state_selected=["true" | "false"]
        android:state_checkable=["true" | "false"]
        android:state_checked=["true" | "false"]
        android:state_enabled=["true" | "false"]
        android:state_activated=["true" | "false"]
        android:state_window_focused=["true" | "false"] />
</selector>
רכיבים:
<selector>
חובה. הוא חייב להיות הרכיב הבסיסי (root). מכיל רכיב <item> או יותר.

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
android:constantSize
בוליאני. הערך הוא True אם הגודל הפנימי שדווח של פריט הגרפיקה נשאר קבוע כמצב שינויים (הגודל הוא המספר המרבי של כל המדינות); false אם הגודל משתנה בהתאם את המצב הנוכחי. ערך ברירת המחדל הוא False.
android:dither
בוליאני. הערך הוא True כדי לאפשר מיזוג של מפת הסיביות אם למפת הביטים אין אותו פיקסל תצורה כמו המסך, למשל מפת סיביות של ARGB 8888 במסך RGB 565. FALSE עד השבתת שיתוף המסך. ברירת המחדל היא True.
android:variablePadding
בוליאני. הערך הוא True אם המרווח הפנימי של פריט הגרפיקה משתנה בהתאם ל המצב שנבחר, FALSE אם המרווח הפנימי חייב להישאר ללא שינוי, על סמך הערך המקסימלי המרווח הפנימי של כל המדינות. כדי להפעיל את התכונה הזו עליך לטפל ביצוע פריסה כשהמצב משתנה, שלרוב לא נתמך. ערך ברירת המחדל הוא False.
<item>
הגדרת פריט גרפי שניתן להזזה לשימוש במצבים מסוימים, כפי שמתואר על ידי המאפיינים שלו. חייב להיות צאצא של רכיב <selector>.

מאפיינים:

android:drawable
משאב שניתן לשרטוט. חובה. הפניה למשאב שניתן להזזה.
android:state_pressed
בוליאני. הערך הוא True אם משתמשים בפריט הזה כשמקישים על האובייקט, למשל כשלחצן נוגעת. false אם משתמשים בפריט הזה במצב ברירת מחדל (ללא הקשה).
android:state_focused
בוליאני. True אם משתמשים בפריט הזה כשיש מיקוד בקלט על האובייקט, למשל, כשהמשתמש בוחר קלט טקסט. false אם משתמשים בפריט הזה כברירת מחדל, ולא ממוקד.
android:state_hovered
בוליאני. True אם משתמשים בפריט הזה כשמעבירים את העכבר מעל האובייקט; FALSE אם משתמשים בפריט הזה במצב ברירת המחדל, ללא העברת העכבר. לעיתים קרובות, פריט גרפי שניתן להזזה יכול להיות אותו פריט להזזה שבו משתמשים .

התכונה הופעלה ברמת API 14.

android:state_selected
בוליאני. True אם משתמשים בפריט הזה כשהאובייקט הוא בחירת המשתמש במהלך ניווט עם פקד כיווני, למשל במהלך ניווט ברשימה עם לחצני החיצים (D-pad), FALSE אם משתמשים בפריט הזה כשלא בוחרים את האובייקט.

המצב שנבחר נמצא בשימוש אם android:state_focused לא מספיק, למשל, כשהמיקוד הוא בתצוגת הרשימה ופריט בתוכו נבחר באמצעות לחצני החיצים (D-pad).

android:state_checkable
בוליאני. True אם משתמשים בפריט הזה כשהאובייקט ניתן לבחירה. FALSE אם נעשה שימוש בפריט כשהוא לא ניתן לבחירה. שימושי רק אם האובייקט יכול מעבר בין ווידג'ט שניתן לבחירה לווידג'ט שלא ניתן לבחירה.
android:state_checked
בוליאני. True אם משתמשים בפריט הזה בזמן בחירת האובייקט; לא נכון אם משמש כשמבטלים בחירה של האובייקט.
android:state_enabled
בוליאני. True אם משתמשים בפריט הזה כשהאובייקט מופעל, כלומר יכול לקבל אירועי מגע או לחיצה; FALSE אם משתמשים בו כשהאובייקט מושבת.
android:state_activated
בוליאני. True אם נעשה שימוש בפריט הזה כשהאובייקט מופעל בתור את הבחירה הקבועה, כמו "להדגיש" הפריט שנבחר בעבר ברשימה תצוגת ניווט; FALSE אם משתמשים בו כשהאובייקט לא מופעל.

התכונה הופעלה ברמת API 11.

android:state_window_focused
בוליאני. הערך הוא True אם משתמשים בפריט הזה כשהמיקוד הוא על חלון האפליקציה, כלומר האפליקציה בחזית. FALSE אם משתמשים בפריט הזה בזמן שהאפליקציה אין מיקוד בחלון, לדוגמה, אם לוח ההתראות מושך למטה או אם מופיעה תיבת דו-שיח.

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

דוגמא:
קובץ XML נשמר ב-res/drawable/button.xml:
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true"
          android:drawable="@drawable/button_pressed" /> <!-- pressed -->
    <item android:state_focused="true"
          android:drawable="@drawable/button_focused" /> <!-- focused -->
    <item android:state_hovered="true"
          android:drawable="@drawable/button_focused" /> <!-- hovered -->
    <item android:drawable="@drawable/button_normal" /> <!-- default -->
</selector>

קובץ ה-XML של הפריסה מחיל את רשימת המצבים שניתן לצייר על לחצן:

<Button
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:background="@drawable/button" />
למידע נוסף:

רשימת רמות

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

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לLevelListDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<level-list
    xmlns:android="http://schemas.android.com/apk/res/android" >
    <item
        android:drawable="@drawable/drawable_resource"
        android:maxLevel="integer"
        android:minLevel="integer" />
</level-list>
רכיבים:
<level-list>
חובה. הוא חייב להיות הרכיב הבסיסי (root). מכיל רכיב <item> או יותר.

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
<item>
מגדיר פריט גרפי שניתן להזזה לשימוש ברמה מסוימת.

מאפיינים:

android:drawable
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה שצריך להגדיר.
android:maxLevel
מספר שלם. הרמה המקסימלית המותרת לפריט זה.
android:minLevel
מספר שלם. הרמה המינימלית המותרת לפריט זה.
דוגמא:
<?xml version="1.0" encoding="utf-8"?>
<level-list xmlns:android="http://schemas.android.com/apk/res/android" >
    <item
        android:drawable="@drawable/status_off"
        android:maxLevel="0" />
    <item
        android:drawable="@drawable/status_on"
        android:maxLevel="1" />
</level-list>

אחרי החלת ההגדרה הזו על View, אפשר לשנות את הרמה באמצעות setLevel() או setImageLevel().

למידע נוסף:

ניתן להזזה עם מעבר

TransitionDrawable הוא אובייקט שניתן להזזה שיכולה להפוך לשקוף בהדרגה בין שני משאבים ניתנים להזזה אחרים.

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

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לTransitionDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<transition
xmlns:android="http://schemas.android.com/apk/res/android" >
    <item
        android:drawable="@[package:]drawable/drawable_resource"
        android:id="@[+][package:]id/resource_name"
        android:top="dimension"
        android:right="dimension"
        android:bottom="dimension"
        android:left="dimension" />
</transition>
רכיבים:
<transition>
חובה. הוא חייב להיות הרכיב הבסיסי (root). מכיל רכיב <item> או יותר.

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
<item>
מגדירה פריט גרפי שניתן להזזה לשימוש כחלק מהמעבר שניתן להזזה. חייב להיות צאצא של רכיב <transition>. מקבלים <bitmap> צאצאים רכיבים.

מאפיינים:

android:drawable
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה משאב.
android:id
מזהה משאב מזהה משאב ייחודי לגרפיקה הזו. כדי ליצור משאב חדש מזהה של פריט זה, יש להשתמש בטופס: "@+id/name" סמל הפלוס מציין שמחרוזת הזו נוצרה ID. אפשר להשתמש במזהה הזה כדי מאחזרים ומשנים את הפריט הניתן להזזה באמצעות View.findViewById() או Activity.findViewById().
android:top
מספר שלם. ההיסט העליון בפיקסלים.
android:right
מספר שלם. ההיסט הנכון בפיקסלים.
android:bottom
מספר שלם. ההיסט התחתון בפיקסלים.
android:left
מספר שלם. ההיסט השמאלי בפיקסלים.
דוגמא:
קובץ XML נשמר ב-res/drawable/transition.xml:
<?xml version="1.0" encoding="utf-8"?>
<transition xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/on" />
    <item android:drawable="@drawable/off" />
</transition>

קובץ ה-XML של הפריסה מחיל את הפריט הניתן להזזה על תצוגה:

<ImageButton
    android:id="@+id/button"
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:src="@drawable/transition" />

והקוד הבא מבצע מעבר של 500 אלפיות השנייה מהפריט הראשון לפריט השני:

Kotlin

val button: ImageButton = findViewById(R.id.button)
val drawable: Drawable = button.drawable
if (drawable is TransitionDrawable) {
    drawable.startTransition(500)
}

Java

ImageButton button = (ImageButton) findViewById(R.id.button);
Drawable drawable = button.getDrawable();
if (drawable instanceof TransitionDrawable) {
    ((TransitionDrawable) drawable).startTransition(500);
}
למידע נוסף:

ניתנת להזזה עם קיבוע

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

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לInsetDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<inset
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/drawable_resource"
    android:insetTop="dimension"
    android:insetRight="dimension"
    android:insetBottom="dimension"
    android:insetLeft="dimension" />
רכיבים:
<inset>
חובה. מגדיר את הרכיבים שניתנים להזזה. הוא חייב להיות הרכיב הבסיסי (root).

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
android:drawable
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה שצריך להגדיר.
android:insetTop
מאפיין. השילוב העליון, כערך מאפיין או משאב מאפיין.
android:insetRight
מאפיין. השילוב הנכון, כערך מאפיין או משאב מאפיין.
android:insetBottom
מאפיין. הפנימי התחתון, כערך מאפיין או משאב מאפיין.
android:insetLeft
מאפיין. הרכיב המוטמע השמאלי, כערך מאפיין או כמשאב מאפיין.
דוגמא:
<?xml version="1.0" encoding="utf-8"?>
<inset xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/background"
    android:insetTop="10dp"
    android:insetLeft="10dp" />
למידע נוסף:

ניתן להזזה עם תופס

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

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לClipDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<clip
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/drawable_resource"
    android:clipOrientation=["horizontal" | "vertical"]
    android:gravity=["top" | "bottom" | "left" | "right" | "center_vertical" |
                     "fill_vertical" | "center_horizontal" | "fill_horizontal" |
                     "center" | "fill" | "clip_vertical" | "clip_horizontal"] />
רכיבים:
<clip>
חובה. מגדיר את הקליפ שניתן להזזה. הוא חייב להיות הרכיב הבסיסי (root).

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
android:drawable
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה לחיתוך של המשאב.
android:clipOrientation
מילת מפתח. הכיוון של הקליפ.

חייב להיות אחד מהערכים הקבועים הבאים:

ערךתיאור
horizontal מהדקים את הפריט להזזה לרוחב.
vertical מהדקים את הפריט להזזה במאונך.
android:gravity
מילת מפתח. המדיניות הזו מציינת את המיקום לחיתוך בתוך פריט הגרפיקה.

חייב להיות לפחות אחד מהערכים הקבועים הבאים, ולהפריד ביניהם באמצעות |:

ערךתיאור
top ממקמים את האובייקט בחלק העליון של הקונטיינר, בלי לשנות את הגודל שלו. כשהערך של clipOrientation הוא "vertical", מתבצעת חיתוך בחלק התחתון של פריט הגרפיקה.
bottom ממקמים את האובייקט בתחתית הקונטיינר, ולא משנים את גודלו. כשהערך של clipOrientation הוא "vertical", מתבצעת חיתוך בחלק העליון של פריט הגרפיקה.
left ממקמים את האובייקט בקצה השמאלי של הקונטיינר, בלי לשנות את גודלו. כאן כברירת מחדל. כשהערך בשדה clipOrientation הוא "horizontal", חיתוך מתבצע בצד שמאל של פריט הגרפיקה.
right ממקמים את האובייקט בקצה הימני של הקונטיינר, בלי לשנות את גודלו. כשהערך בשדה clipOrientation הוא "horizontal", מתבצעת חיתוך בצד שמאל של פריט הגרפיקה.
center_vertical ממקמים את העצם במרכז האנכי של הקונטיינר, בלי לשנות את גודלו. אופן הפעולה של הקליפ פועל בדיוק כמו כשכוח הכבידה הוא "center".
fill_vertical במקרה הצורך, מגדילים את הגודל האנכי של העצם כך שהוא ימלא את המכל במלואו. כשהערך של clipOrientation הוא "vertical", לא מתבצע חיתוך כי פריט הגרפיקה ממלא את רווח אנכי (אלא אם הרמה שניתן להזזה היא 0, ובמקרה הזה היא לא גלויה).
center_horizontal צריך למקם את האובייקט במרכז האופקי של הקונטיינר שלו, בלי לשנות את גודלו. פעולת הקליפ מתנהגת באותו אופן שבו כוח הכבידה הוא "center".
fill_horizontal במקרה הצורך, מגדילים את הגודל האופקי של האובייקט כך שימלא את הקונטיינר שלו במלואו. מתי הערך של clipOrientation הוא "horizontal", לא מתבצע חיתוך כי פריט הגרפיקה ממלא את רווח אופקי (אלא אם הרמה שניתן להזזה היא 0, ובמקרה כזה היא לא גלויה).
center צריך למקם את האובייקט במרכז המכל שלו גם בציר האנכי וגם בציר האופקי, ולא משנה את גודלו. כשהערך בשדה clipOrientation הוא "horizontal", חיתוך מתבצע בצד שמאל ובצד ימין. כשהערך של clipOrientation הוא "vertical", חיתוך מתבצע בחלק העליון והתחתון.
fill במקרה הצורך, מגדילים את הגודל האופקי והאנכי של האובייקט כך שהוא ימלא את כל החלקים שלו. מאגר תגים. לא מתבצע חיתוך מפני שהגרפיקה ממלאת את רווח אופקי ואנכי (אלא אם הרמה שניתן להזזה היא 0. במקרה כזה היא לא גלוי).
clip_vertical אפשרות נוספת שאפשר להגדיר לחיתוך של הקצה העליון או התחתון של הילד או הילדה את גבולות הקונטיינר שלו. הקליפ מבוסס על הכוח האנכי: הקצה התחתון, כוח הכבידה התחתון מצמיד את הקצה העליון, ואף אחד מהקצוות לא מצמיד את שניהם.
clip_horizontal אפשרות נוספת שאפשר להגדיר לחיתוך של הקצה השמאלי או הימני של הילד או הילדה את גבולות הקונטיינר שלו. הקליפ מבוסס על כוח הכבידה האופקי: קליפים שצולמו בכוח הכבידה השמאלי הקצה הימני, כוח הכבידה הימני מצמיד את הקצה השמאלי, ואף אחד מהקצוות לא מקצר.
דוגמא:
קובץ XML נשמר ב-res/drawable/clip.xml:
<?xml version="1.0" encoding="utf-8"?>
<clip xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/android"
    android:clipOrientation="horizontal"
    android:gravity="left" />

קוד ה-XML של הפריסה הבא מחיל את הקליפ שניתן להזזה על תצוגה:

<ImageView
    android:id="@+id/image"
    android:src="@drawable/clip"
    android:layout_height="wrap_content"
    android:layout_width="wrap_content" />

הקוד הבא מקבל את הפריט שניתן להזזה ומגדיל את כמות החיתוך לחשוף את התמונה בהדרגה:

Kotlin

val imageview: ImageView = findViewById(R.id.image)
val drawable: Drawable = imageview.background
if (drawable is ClipDrawable) {
    drawable.level = drawable.level + 1000
}

Java

ImageView imageview = (ImageView) findViewById(R.id.image);
Drawable drawable = imageview.getBackground();
if (drawable instanceof ClipDrawable) {
    ((ClipDrawable)drawable).setLevel(drawable.getLevel() + 1000);
}

הגדלת הרמה מפחיתה את כמות החיתוך וחושפת את התמונה לאט. כאן זה ברמה של 7000:

הערה: רמת ברירת המחדל היא 0, והיא נחתכה במלואה כך שהתמונה לא גלוי. כשהרמה היא 10,000, התמונה לא נחתכה וניתן לראות אותה במלואה.

למידע נוסף:

התאמה לעומס (scaling)

פריט גרפי שניתן להזזה שמוגדר ב-XML שמשנה את הגודל של פריט גרפי אחר שניתן להזזה על סמך הגודל הנוכחי שלו ברמה.

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לScaleDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<scale
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/drawable_resource"
    android:scaleGravity=["top" | "bottom" | "left" | "right" | "center_vertical" |
                          "fill_vertical" | "center_horizontal" | "fill_horizontal" |
                          "center" | "fill" | "clip_vertical" | "clip_horizontal"]
    android:scaleHeight="percentage"
    android:scaleWidth="percentage" />
רכיבים:
<scale>
חובה. מגדיר את קנה המידה שניתן להזזה. הוא חייב להיות הרכיב הבסיסי (root).

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
android:drawable
משאב שניתן לשרטוט. חובה. הפניה למכשיר שניתן להזזה משאב.
android:scaleGravity
מילת מפתח. מציין את מיקום הכבידה לאחר התאמה לעומס.

חייב להיות לפחות אחד מהערכים הקבועים הבאים, ולהפריד ביניהם באמצעות |:

ערךתיאור
top ממקמים את האובייקט בחלק העליון של הקונטיינר, בלי לשנות את הגודל שלו.
bottom ממקמים את האובייקט בתחתית הקונטיינר, ולא משנים את גודלו.
left ממקמים את האובייקט בקצה השמאלי של הקונטיינר, בלי לשנות את גודלו. כאן כברירת מחדל.
right ממקמים את האובייקט בקצה הימני של הקונטיינר, בלי לשנות את גודלו.
center_vertical ממקמים את העצם במרכז האנכי של הקונטיינר, בלי לשנות את גודלו.
fill_vertical במקרה הצורך, מגדילים את הגודל האנכי של העצם כך שהוא ימלא את המכל במלואו.
center_horizontal צריך למקם את האובייקט במרכז האופקי של הקונטיינר שלו, בלי לשנות את גודלו.
fill_horizontal במקרה הצורך, מגדילים את הגודל האופקי של האובייקט כך שימלא את הקונטיינר שלו במלואו.
center צריך למקם את האובייקט במרכז הקונטיינר שלו גם בציר האנכי וגם בציר האופקי, ולא משנה את גודלו.
fill במקרה הצורך, מגדילים את הגודל האופקי והאנכי של האובייקט כך שהוא ימלא את כל החלקים שלו. מאגר תגים.
clip_vertical אפשרות נוספת שאפשר להגדיר לחיתוך של הקצה העליון או התחתון של הילד או הילדה את גבולות הקונטיינר שלו. הקליפ מבוסס על הכוח האנכי: הקצה התחתון, כוח הכבידה התחתון מצמיד את הקצה העליון, ואף אחד מהקצוות לא מצמיד את שניהם.
clip_horizontal אפשרות נוספת שאפשר להגדיר לחיתוך של הקצה השמאלי או הימני של הילד או הילדה את גבולות הקונטיינר שלו. הקליפ מבוסס על כוח הכבידה האופקי: קליפים שצולמו בכוח הכבידה השמאלי הקצה הימני, כוח הכבידה הימני מצמיד את הקצה השמאלי, ואף אחד מהקצוות לא מקצר.
android:scaleHeight
אחוז. גובה קנה המידה, מבוטא כאחוז עובר. הפורמט של הערך הוא XX%, למשל 100% או 12.5%.
android:scaleWidth
אחוז. רוחב קנה המידה, מבוטא כאחוז מתוך עובר. הפורמט של הערך הוא XX%, למשל 100% או 12.5%.
דוגמא:
<?xml version="1.0" encoding="utf-8"?>
<scale xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/logo"
    android:scaleGravity="center_vertical|center_horizontal"
    android:scaleHeight="80%"
    android:scaleWidth="80%" />
למידע נוסף:

צורה שניתן לצייר

זוהי צורה גנרית שמוגדרת ב-XML.

מיקום הקובץ:

res/drawable/filename.xmlבצבע
שם הקובץ הוא מזהה המשאב
סוג נתונים של משאב מקומפל:
מצביע משאב לGradientDrawable
הפניה למשאבים:
ב-Java: R.drawable.filename
ב-XML: @[package:]drawable/filename
תחביר:
<?xml version="1.0" encoding="utf-8"?>
<shape
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape=["rectangle" | "oval" | "line" | "ring"] >
    <corners
        android:radius="integer"
        android:topLeftRadius="integer"
        android:topRightRadius="integer"
        android:bottomLeftRadius="integer"
        android:bottomRightRadius="integer" />
    <gradient
        android:angle="integer"
        android:centerX="float"
        android:centerY="float"
        android:centerColor="integer"
        android:endColor="color"
        android:gradientRadius="integer"
        android:startColor="color"
        android:type=["linear" | "radial" | "sweep"]
        android:useLevel=["true" | "false"] />
    <padding
        android:left="integer"
        android:top="integer"
        android:right="integer"
        android:bottom="integer" />
    <size
        android:width="integer"
        android:height="integer" />
    <solid
        android:color="color" />
    <stroke
        android:width="integer"
        android:color="color"
        android:dashWidth="integer"
        android:dashGap="integer" />
</shape>
רכיבים:
<shape>
חובה. הצורה שניתן לצייר. הוא חייב להיות הרכיב הבסיסי (root).

מאפיינים:

xmlns:android
מחרוזת. חובה. מגדיר את מרחב השמות של XML, שחייב להיות "http://schemas.android.com/apk/res/android"
android:shape
מילת מפתח. מגדיר את סוג הצורה. הערכים החוקיים כוללים:
ערךתיאור
"rectangle" מלבן שממלא את התצוגה המפורטת. זוהי צורת ברירת המחדל.
"oval" צורה אליפסה שתואמת למידות של התצוגה הכלולה.
"line" קו אופקי שמשתרע על הרוחב של התצוגה המפורטת. הזה לצורה הזו נדרש הרכיב <stroke> כדי להגדיר את הרוחב השורה הזו.
"ring" צורה של טבעת.

המאפיינים הבאים משמשים רק כאשר android:shape="ring":

android:innerRadius
מאפיין. הרדיוס של החלק הפנימי של הטבעת (החור שבאמצע), כערך מאפיין או כמשאב מאפיין.
android:innerRadiusRatio
ציפה. הרדיוס של השדה הפנימי חלק מהטבעת, מבוטא כיחס לרוחב הטבעת. למשל, אם android:innerRadiusRatio="5", הרדיוס הפנימי שווה לרוחב הטבעת חלקי 5. הזה הערך בוטל על ידי android:innerRadius. ערך ברירת המחדל הוא 9.
android:thickness
מאפיין. העובי של החלק טבעת, כערך מאפיין או כמשאב מאפיין.
android:thicknessRatio
ציפה. עובי הטבעת מבוטאת כיחס מרוחב הטבעת. לדוגמה, אם android:thicknessRatio="2", אז העובי שווה לרוחב הטבעת חלקי 2. הערך הזה בוטל על ידי android:innerRadius. ערך ברירת המחדל הוא 3.
android:useLevel
בוליאני. True אם משמש LevelListDrawable. בדרך כלל זה לא נכון, אחרת ייתכן שהצורה שלך לא תופיע.
<corners>
יוצרות פינות מעוגלות לצורה. חל רק כשהצורה היא מלבן.

מאפיינים:

android:radius
מאפיין. הרדיוס של כל הפינות, כערך מאפיין או כמשאב מאפיין. הערך הזה מוחלף בכל לפי המאפיינים הבאים.
android:topLeftRadius
מאפיין. הרדיוס של הפינה הימנית העליונה, כערך מאפיין או כמשאב של מאפיין.
android:topRightRadius
מאפיין. הרדיוס של הפינה השמאלית העליונה, כערך המאפיין או כמשאב המאפיין.
android:bottomLeftRadius
מאפיין. הרדיוס של הפינה הימנית התחתונה, כערך מאפיין או כמשאב של מאפיין.
android:bottomRightRadius
מאפיין. הרדיוס של הפינה השמאלית התחתונה, כערך המאפיין או כמשאב המאפיין.

הערה:בהתחלה צריך להוסיף לכל פינה פינה שהרדיוס שלהן גדול מ-1, אחרת אין מעוגלות של הפינות. אם רוצים ליצור פינות ספציפיות ללא להיות מעוגלות, פתרון זמני הוא להשתמש ב-android:radius כדי להגדיר פינת ברירת מחדל עם רדיוס גדול מ-1, ולאחר מכן לשנות כל פינה בערכים שרוצים, מציינים 0 ("0dp") כשלא רוצים ליצור פינות מעוגלות.

<gradient>
קביעת צבע הדרגתי של הצורה.

מאפיינים:

android:angle
מספר שלם. הזווית של ההדרגתיות, במעלות. 0 הוא משמאל לימין, 90 הוא מלמטה למעלה. חייב להיות כפולה של 45. ערך ברירת המחדל הוא 0.
android:centerX
ציפה. מיקום ה-X היחסי של מרכז ההדרגתיות (0 - 1.0).
android:centerY
ציפה. מיקום ה-Y היחסי של מרכז ההדרגתיות (0 - 1.0).
android:centerColor
צבע. צבע אופציונלי שנמצא בין צבע ההתחלה לצבע הסיום, ערך הקסדצימלי או משאב צבע.
android:endColor
צבע. צבע הסיום, בפורמט הקסדצימלי או משאב צבע.
android:gradientRadius
ציפה. הרדיוס של ההדרגתיות. מוחל רק כאשר android:type="radial".
android:startColor
צבע. צבע ההתחלה, בפורמט הקסדצימלי או משאב צבע.
android:type
מילת מפתח. סוג התבנית ההדרגתית שצריך להחיל. הערכים החוקיים כוללים:
ערךתיאור
"linear" הדרגתי לינארי. (זוהי ברירת המחדל)
"radial" הדרגתי רדיאלי. צבע ההתחלה הוא צבע המרכז.
"sweep" הדרגתיות של קווים סוחפים.
android:useLevel
בוליאני. True אם הוא משמש כ-LevelListDrawable.
<padding>
המרווח שיש להחיל על רכיב התצוגה המפורטת שמכיל אותו. פעולה זו משפרת את מיקום התצוגה התוכן, לא הצורה.

מאפיינים:

android:left
מאפיין. מרווח פנימי שמאלי, כערך מאפיין או כמשאב מאפיין.
android:top
מאפיין. מרווח פנימי עליון, כערך מאפיין או כמשאב מאפיין.
android:right
מאפיין. מרווח פנימי ימני, כערך מאפיין או כמשאב מאפיין.
android:bottom
מאפיין. מרווח פנימי תחתון, כערך מאפיין או כמשאב מאפיין.
<size>
גודל הצורה.

מאפיינים:

android:height
מאפיין. גובה הצורה, כערך מאפיין או כמשאב מאפיין.
android:width
מאפיין. רוחב הצורה, כערך מאפיין או כמשאב מאפיין.

הערה: כברירת מחדל, הצורה משתנה בהתאם לגודל המכל בתצוגה פרופורציונלית למאפיינים שמוגדרים כאן. כשמשתמשים בצורה בתוך ImageView, אפשר להגביל את שינוי קנה המידה על ידי הגדרת הפרמטר android:scaleType ל-"center".

<solid>
צבע אחיד למילוי הצורה.

מאפיינים:

android:color
צבע. הצבע שיש להחיל על הצורה, בפורמט הקסדצימלי או משאב צבע.
<stroke>
קו קו לצורה.

מאפיינים:

android:width
מאפיין. עובי הקו, כערך מאפיין או כמשאב מאפיין.
android:color
צבע. צבע הקו, ערך הקסדצימלי או משאב צבע.
android:dashGap
מאפיין. המרחק בין מקפים, כערך מאפיין או כמשאב מאפיין. תקף רק אם המדיניות android:dashWidth מוגדרת.
android:dashWidth
מאפיין. הגודל של כל קו מקף, כערך מאפיין או כמשאב מאפיין. תקף רק אם המדיניות android:dashGap מוגדרת.
דוגמא:
קובץ XML נשמר ב-res/drawable/gradient_box.xml:
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">
    <gradient
        android:startColor="#FFFF0000"
        android:endColor="#80FF00FF"
        android:angle="45"/>
    <padding android:left="7dp"
        android:top="7dp"
        android:right="7dp"
        android:bottom="7dp" />
    <corners android:radius="8dp" />
</shape>

קובץ ה-XML של הפריסה מחיל את הצורה הניתנת להזזה על תצוגה:

<TextView
    android:background="@drawable/gradient_box"
    android:layout_height="wrap_content"
    android:layout_width="wrap_content" />

קוד האפליקציה הזה מקבל את הצורה שניתן לצייר ומחיל אותה על תצוגה:

Kotlin

val shape: Drawable? = getDrawable(resources, R.drawable.gradient_box, getTheme())

val tv: TextView = findViewById(R.id.textview)
tv.background = shape

Java

Resources res = getResources();
Drawable shape = ResourcesCompat.getDrawable(res, R.drawable.gradient_box, getTheme());

TextView tv = (TextView)findViewById(R.id.textview);
tv.setBackground(shape);
למידע נוסף: