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

משאב ניתן לשרטוט הוא קונספט כללי לגרפיקה שניתן לצייר למסך ו אפשר לאחזר באמצעות ממשקי 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);

למידע נוסף:

• סקירה כללית של פריטי גרפיקה
• BitmapDrawable

מפת סיביות (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" />

למידע נוסף:

• BitmapDrawable
• יצירה מקורות מידע חלופיים

תשעה תיקונים

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" />

למידע נוסף:

• יצירת מפות ביטים שניתן לשנות את הגודל שלהן (קובצי 9 תיקונים)
• NinePatchDrawable

תשעה תיקונים בפורמט 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" />

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

למידע נוסף:

• LayerDrawable

רשימת מדינות

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" />

למידע נוסף:

• StateListDrawable

רשימת רמות

פריט גרפי שניתן להזזה שמנהל כמה פריטים גרפיים חלופיים, שלכל אחד מהם מוקצה ערך מספרי מקסימלי עם ערך מסוים. הגדרת ערך הרמה של הפריט הניתן להזזה באמצעות 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().

למידע נוסף:

• LevelListDrawable

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

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);
}

למידע נוסף:

• TransitionDrawable

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

פריט גרפי שניתן להזזה שמוגדר ב-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" />

למידע נוסף:

• InsetDrawable

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

פריט גרפי שניתן להזזה שמוגדר ב-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, התמונה לא נחתכה וניתן לראות אותה במלואה.

למידע נוסף:

• ClipDrawable

התאמה לעומס (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%" />

למידע נוסף:

• ScaleDrawable

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

זוהי צורה גנרית שמוגדרת ב-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);

למידע נוסף:

• ShapeDrawable