Risorse disegnabili

Una risorsa disegnabile è un concetto generale per un'immagine che può essere disegnata sullo schermo e che che puoi recuperare con API come getDrawable(int) o applicare a un'altra risorsa XML con attributi come android:drawable e android:icon. Esistono diversi tipi di drawable:

File bitmap
Un file grafico bitmap (PNG, WEBP, JPG o GIF). Crea un BitmapDrawable.
File a nove patch
Un file PNG con aree estensibili per consentire il ridimensionamento delle immagini in base ai contenuti (.9.png). Crea un NinePatchDrawable.
Elenco dei livelli
Un drawable che gestisce un array di altri drawable. Questi sono tracciati in ordine di matrice, quindi l'elemento con l'indice più grande è disegnato sopra. Crea un LayerDrawable.
Elenco stati
Un file XML che fa riferimento a diverse grafiche bitmap a seconda dello stato, ad esempio per utilizzare un'immagine diversa quando viene toccato un pulsante. Crea un StateListDrawable.
Elenco dei livelli
Un file XML che definisce un drawable che gestisce una serie di drawable alternativi, ciascuno assegnato un valore numerico massimo. Crea un LevelListDrawable.
Transizione selezionabile
Un file XML che definisce un drawable che può eseguire una dissolvenza incrociata tra due risorse drawable. Crea un TransitionDrawable.
Inserto disegnabile
Un file XML che definisce un drawable che ne inserisce un altro in base a una distanza specificata. Questo è utile quando una vista necessita di un elemento drawable sullo sfondo che sia più piccolo del valore effettivo della vista limiti.
Clip estraibile
Un file XML che definisce un drawable che blocca un altro drawable in base al valore del livello corrente. Crea un ClipDrawable.
Risorsa disegnabile in scala
Un file XML che definisce un elemento drawable che modifica le dimensioni di un altro drawable in base al relativo valore del livello corrente. Crea un ScaleDrawable
Disegna Forma.
Un file XML che definisce una forma geometrica, inclusi colori e sfumature. Crea un GradientDrawable.

Per informazioni su come crea un AnimationDrawable, consulta il documento Risorse animazione.

Nota: una risorsa colore può anche essere utilizzata come drawable in XML. Ad esempio, quando crei un elenco di stati drawable, puoi fare riferimento a una risorsa colore per l'attributo android:drawable (android:drawable="@color/green").

Bitmap

Un'immagine bitmap. Android supporta i file bitmap nei seguenti formati: PNG (opzione preferita), WEBP (opzione preferita, richiede API livello 17 o superiore), JPG (accettabile), GIF (sconsigliato).

Puoi fare riferimento direttamente a un file bitmap utilizzando il nome file come ID risorsa, oppure creare un l'ID risorsa alias in XML.

Nota: i file bitmap potrebbero essere ottimizzati automaticamente con senza perdita di dati. compressione delle immagini da parte dello strumento aapt durante il processo di creazione. Per Ad esempio, un'immagine PNG a colori reali che non richiede più di 256 colori potrebbe essere convertita PNG con una tavolozza dei colori. Ciò si traduce in un'immagine di pari qualità che richiede meno la memoria.

Tieni presente che i file binari delle immagini inseriti in questa directory possono cambiare durante la creazione. Se intendi leggere un'immagine come un flusso di bit per convertirla in bitmap, inserisci le immagini la cartella res/raw/, dove non sono ottimizzate.

File bitmap

Un file bitmap è un file PNG, WEBP, JPG o GIF. Android crea un Drawable risorsa per uno qualsiasi di questi file quando li salvi nella directory res/drawable/.

percorso del file:
res/drawable/filename.png (.png, .webp, .jpg o .gif)
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a BitmapDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
esempio:
Con un'immagine salvata nel percorso res/drawable/myimage.png, viene applicato questo XML di layout l'immagine in una vista:
<ImageView
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:src="@drawable/myimage" />

Il seguente codice dell'applicazione recupera l'immagine come 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);
vedi anche:

Bitmap XML

Una bitmap XML è una risorsa definita in XML che punta a un file bitmap. L'effetto è l'alias di un non elaborato del file bitmap. Il file XML può specificare ulteriori proprietà per la bitmap, come il dithering e il tiling.

Nota: puoi utilizzare un elemento <bitmap> come elemento secondario di un elemento <item>. Per ad esempio, quando crei un elenco di stati o un elenco di livelli, puoi escludere android:drawable da un elemento <item> e nidificare un <bitmap> al suo interno che definisce l'elemento disegnabile.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a BitmapDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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"] />
elementi:
<bitmap>
Obbligatorio. Definisce l'origine bitmap e le sue proprietà.

Attributi:

xmlns:android
Stringa. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android". Questa operazione è necessaria solo se <bitmap> è l'elemento principale. Non è necessario se <bitmap> è nidificato all'interno di un elemento <item>.
android:src
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable risorsa.
android:antialias
Booleano. Attiva o disattiva l'antialiasing.
android:dither
Booleano. Attiva o disattiva il dithering della bitmap in caso contrario. Avere la stessa configurazione pixel dello schermo, ad esempio una bitmap ARGB 8888 su un RGB 565 schermo.
android:filter
Booleano. Attiva o disattiva il filtro bitmap. Il filtro viene utilizzato quando la bitmap viene ridotta o ampliata per uniformarne l'aspetto.
android:gravity
Parola chiave. Definisce la gravità per la bitmap. La gravità indica dove posiziona l'elemento drawable nel container se la bitmap è più piccola del container.

Deve essere uno o più dei seguenti valori costanti, separati da |:

ValoreDescrizione
top Posiziona l'oggetto nella parte superiore del contenitore senza cambiarne le dimensioni.
bottom Posiziona l'oggetto nella parte inferiore del contenitore, senza cambiarne le dimensioni.
left Posiziona l'oggetto sul bordo sinistro del contenitore, senza modificarne le dimensioni.
right Posiziona l'oggetto sul bordo destro del contenitore, senza cambiarne le dimensioni.
center_vertical Posiziona l'oggetto al centro verticale del contenitore, senza cambiarne le dimensioni.
fill_vertical Se necessario, aumenta le dimensioni verticali dell'oggetto in modo che riempia completamente il suo contenitore.
center_horizontal Posiziona l'oggetto al centro orizzontale del container senza cambiarne le dimensioni.
fill_horizontal Aumenta la dimensione orizzontale dell'oggetto, se necessario, in modo che riempia completamente il suo contenitore.
center Posiziona l'oggetto al centro del contenitore, sia sull'asse verticale che su quello orizzontale, non cambiandone le dimensioni.
fill Aumenta la dimensione orizzontale e verticale dell'oggetto, se necessario, in modo che riempia completamente la sua containerizzato. Questa è l'impostazione predefinita.
clip_vertical Opzione aggiuntiva che può essere impostata in modo da ritagliare i bordi superiore e/o inferiore del riquadro secondario limiti del rispettivo container. Il clip si basa sulla gravità verticale: una gravità superiore collega la il bordo inferiore, una gravità inferiore blocca il bordo superiore e nessuna delle due clip viene agganciata a entrambi i bordi.
clip_horizontal Opzione aggiuntiva che può essere impostata in modo da ritagliare i bordi sinistro e/o destro del riquadro secondario limiti del rispettivo container. Il clip si basa sulla gravità orizzontale, ovvero clip sulla gravità sinistra il bordo destro, una gravità destra intercala il bordo sinistro e nessuno dei due blocca entrambi i bordi.
android:mipMap
Booleano. Attiva o disattiva il suggerimento mipmap. Consulta la pagina setHasMipMap() per saperne di più. Il valore predefinito è false.
android:tileMode
Parola chiave. Definisce la modalità riquadro. Quando la modalità Tile è attivata, la bitmap viene ripetuto. La gravità viene ignorata quando è attiva la modalità riquadro.

Deve essere uno dei seguenti valori costanti:

ValoreDescrizione
disabled Non affiancare la bitmap. Questo è il valore predefinito.
clamp Replica il colore del bordo se lo shaker disegna al di fuori dei confini originali
repeat Ripeti l'immagine dello streamr sia orizzontalmente che verticalmente.
mirror Ripeti l'immagine dello streamer orizzontalmente e verticalmente, alternando le immagini speculari in modo che le immagini adiacenti vengono sempre cucite.
esempio:
<?xml version="1.0" encoding="utf-8"?>
<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@drawable/icon"
    android:tileMode="repeat" />
vedi anche:

Nove patch

Un'NinePatch è un'immagine PNG in cui puoi definire regioni estensibili che Android ridimensiona quando i contenuti nella visualizzazione superano i normali limiti dell'immagine. Tu in genere assegna questo tipo di immagine come sfondo di una visualizzazione per cui è impostata almeno una dimensione a "wrap_content".

Quando la visualizzazione aumenta per adattarsi ai contenuti, l'immagine con nove patch viene anche ridimensionato in base alle dimensioni della vista. Un esempio di utilizzo di un'immagine con nove patch è la utilizzato dal widget Button standard di Android, che deve estendersi per inserire il testo (o l'immagine) all'interno del pulsante.

Come con una normale bitmap, puoi fare riferimento direttamente a un file a nove patch o da una risorsa definita da XML.

Per una discussione completa su come creare un file a nove patch con regioni estensibili, consulta Creare bitmap ridimensionabili (file con 9 patch).

File con nove patch

percorso del file:

res/drawable/filename.9.png
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a NinePatchDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
esempio:
Con un'immagine salvata nella cartella res/drawable/myninepatch.9.png, questo XML di layout applica le nove patch a una vista:
<Button
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:background="@drawable/myninepatch" />
vedi anche:

Nove patch XML

Una 9-patch XML è una risorsa definita in XML che punta a un file a 9 patch. Il file XML può specificare il dithering per l'immagine.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a NinePatchDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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"] />
elementi:
<nine-patch>
Obbligatorio. Definisce l'origine con nove patch e le relative proprietà.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
android:src
Risorsa disegnabile. Obbligatorio. Riferimento a nove patch .
android:dither
Booleano. Attiva o disattiva il dithering della bitmap in caso contrario. Avere la stessa configurazione pixel dello schermo, ad esempio una bitmap ARGB 8888 su un RGB 565 schermo.
esempio:
<?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" />

Elenco dei livelli

Un LayerDrawable è un oggetto disegnabile che gestisce un array di altri drawable. Ogni disegno di disegno nell'elenco viene disegnato nell'ordine del dall'elenco di lettura. L'ultimo elemento disegnabile nell'elenco viene disegnato in alto.

Ogni elemento disegnabile è rappresentato da un elemento <item> all'interno di un singolo elemento <layer-list>.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a LayerDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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>
elementi:
<layer-list>
Obbligatorio. Deve essere l'elemento principale. Contiene uno o più elementi <item>.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
<item>
Definisce un elemento disegnabile da posizionare nel livello tracciabile, in una posizione definita dai suoi attributi. Deve essere un elemento secondario di un elemento <layer-list>. Accetta il publisher secondario <bitmap> elementi.

Attributi:

android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable risorsa.
android:id
ID risorsa. Un ID risorsa univoco per questo drawable. Per creare una nuova risorsa per questo articolo, utilizza il modulo: "@+id/name". Il simbolo più indica che viene creato come nuovo ID. Puoi utilizzare questo identificatore per recupera e modifica il drawable con View.findViewById() o Activity.findViewById().
android:top
Dimensione. L'offset superiore, come valore di dimensione o risorsa dimensione.
android:right
Dimensione. L'offset destro, come valore di dimensione o risorsa dimensione.
android:bottom
Dimensione. L'offset inferiore, come valore di dimensione o risorsa dimensione.
android:left
Dimensione. L'offset sinistro, come valore di dimensione o risorsa dimensione.

Per impostazione predefinita, tutti gli elementi disegnabili vengono ridimensionati per adattarsi alle dimensioni della vista contenitore. Pertanto, Se posizioni le immagini in un elenco di livelli in posizioni diverse, potresti aumentare le dimensioni della visualizzazione. alcune immagini vengono ridimensionate in base alle esigenze.

Da evitare ridimensionando elementi nell'elenco, usa un elemento <bitmap> all'interno dell'elemento <item> per specificare l'elemento drawable e definire la gravità su un elemento che non su larga scala, ad esempio "center". Ad esempio, il seguente <item> definisce un elemento che si adatta alla vista container:

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

Per evitare il ridimensionamento, l'esempio seguente utilizza un elemento <bitmap> con posizione centrata gravità:

<item>
  <bitmap android:src="@drawable/image"
          android:gravity="center" />
</item>
esempio:
File XML salvato alle ore 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>

In questo esempio viene utilizzato un elemento <bitmap> nidificato per definire l'elemento drawable risorsa per ogni oggetto con una gravità di "center". In questo modo ti assicuri che nessuna delle immagini venga ridimensionata a adattarsi alle dimensioni del container a causa del ridimensionamento causato dalle immagini offset.

Questo file XML di layout applica l'elemento drawable a una visualizzazione:

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

Il risultato è uno stack di immagini sempre più sfalsate:

vedi anche:

Elenco stati

Un StateListDrawable è un oggetto disegnabile definito in XML che utilizza più immagini per rappresentare lo stesso elemento grafico, a seconda dello stato dell'oggetto. Ad esempio, è possibile toccare, impostare lo stato attivo di un widget Button o nessuno dei due; utilizzando un elenco di stati drawable, puoi fornire un'immagine di sfondo diversa per ogni stato.

Descrivi l'elenco di stati in un file XML. Ogni grafica è rappresentata da un elemento <item> all'interno di un singolo elemento <selector>. Ogni <item> utilizza vari attributi per descrivere lo stato in cui viene utilizzato come grafico per il disegnabile.

Durante ogni cambio di stato, l'elenco di stato viene spostato dall'alto verso il basso e il primo elemento corrisponde allo stato corrente. La selezione non si basa sulla "migliore" corrispondono" ma piuttosto il primo elemento che soddisfa i criteri minimi dello stato.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a StateListDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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>
elementi:
<selector>
Obbligatorio. Deve essere l'elemento principale. Contiene uno o più elementi <item>.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
android:constantSize
Booleano. True se la dimensione interna segnalata del drawable rimane costante come stato modifiche (la dimensione è il massimo tra tutti gli stati); false se la dimensione varia in base lo stato attuale. Il valore predefinito è false.
android:dither
Booleano. True per abilitare il dithering della bitmap se quest'ultima non ha lo stesso pixel configurazione come lo schermo, ad esempio una bitmap ARGB 8888 su uno schermo RGB 565; da false a disattiva il dithering. Il valore predefinito è true.
android:variablePadding
Booleano. True se la spaziatura interna del drawable cambia in base al valore attuale lo stato selezionato. false se la spaziatura interna deve rimanere invariata, in base al valore massimo di tutti gli stati. L'attivazione di questa funzione richiede quando lo stato cambia, aspetto che spesso non è supportato. Il valore predefinito è false.
<item>
Definisce un elemento disegnabile da utilizzare in determinati stati, come descritto dai suoi attributi. Deve essere un secondario di un elemento <selector>.

Attributi:

android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a una risorsa disegnabile.
android:state_pressed
Booleano. True se questo elemento viene utilizzato quando si tocca l'oggetto, ad esempio quando viene toccato un pulsante è toccato, false se questo elemento viene utilizzato nello stato predefinito non toccato.
android:state_focused
Booleano. True se questo elemento viene utilizzato quando l'oggetto è impostato sullo stato attivo per l'input, ad esempio quando l'utente seleziona un input di testo; false se questo elemento viene utilizzato per impostazione predefinita, in uno stato non incentrato.
android:state_hovered
Booleano. True se l'elemento viene utilizzato al passaggio del cursore sull'oggetto; false se l'elemento viene utilizzato nello stato predefinito non selezionato. Spesso, questo Il campo drawable può essere lo stesso drawable utilizzato per " contatti " stato.

Introdotto nel livello API 14.

android:state_selected
Booleano. True se questo elemento viene utilizzato quando l'oggetto è l'oggetto corrente Selezione dell'utente durante la navigazione con un controllo direzionale, ad esempio durante la navigazione in un elenco con un D-pad; false se questo elemento viene utilizzato quando l'oggetto non è selezionato.

Lo stato selezionato viene utilizzato quando android:state_focused non è sufficiente. ad esempio quando la visualizzazione elenco è attiva e un elemento al suo interno viene selezionato con un D-pad.

android:state_checkable
Booleano. True se questo elemento viene utilizzato quando l'oggetto è selezionabile; false se questo viene utilizzato quando l'oggetto non è selezionabile. Utile solo se l'oggetto può la transizione tra widget selezionabili e non selezionabili.
android:state_checked
Booleano. True se questo elemento viene utilizzato quando l'oggetto viene selezionato. false se viene utilizzato quando l'oggetto non è selezionato.
android:state_enabled
Booleano. True se questo elemento viene utilizzato quando l'oggetto è abilitato, ovvero in grado di ricevere eventi di tocco o di clic; false se viene utilizzato quando l'oggetto disattivata.
android:state_activated
Booleano. True se questo elemento viene utilizzato quando l'oggetto viene attivato come la selezione permanente, ad esempio per "evidenziare" l'elemento dell'elenco selezionato in precedenza in un visualizzazione di navigazione; false se viene utilizzato quando l'oggetto non è attivato.

Introdotto nel livello API 11.

android:state_window_focused
Booleano. True se questo elemento viene utilizzato quando la finestra dell'applicazione è attiva, il che significa che l'applicazione è in primo piano; false se questo elemento viene utilizzato quando l'applicazione finestra non ha lo stato attivo, ad esempio se l'area notifiche è visualizzata in basso o viene visualizzata una finestra di dialogo.

Nota: Android applica il primo elemento nell'elenco di stati che corrisponde allo stato attuale dell'oggetto. Quindi, se il primo elemento dell'elenco contiene nessuno degli attributi di stato precedenti, viene applicato ogni volta. Ecco perché vuoi che il valore predefinito sia sempre l'ultimo, come mostrato nell'esempio seguente.

esempio:
File XML salvato alle ore 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>

Questo file XML di layout applica l'elenco di stati trascinabile a un pulsante:

<Button
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:background="@drawable/button" />
vedi anche:

Elenco dei livelli

Un drawable che gestisce un certo numero di drawable alternativi, ognuno dei quali ha assegnato un numero massimo valore. L'impostazione del valore del livello del drawable con setLevel() carica la risorsa drawable nel elenco di livelli con un valore android:maxLevel maggiore o uguale al valore passati al metodo.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a LevelListDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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>
elementi:
<level-list>
Obbligatorio. Deve essere l'elemento principale. Contiene uno o più elementi <item>.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
<item>
Definisce un elemento disegnabile da utilizzare a un determinato livello.

Attributi:

android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable la risorsa da inserire.
android:maxLevel
Numero intero. Il livello massimo consentito per questo elemento.
android:minLevel
Numero intero. Il livello minimo consentito per questo elemento.
esempio:
<?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>

Dopo aver applicato questa impostazione a View, puoi modificare il livello con setLevel() o setImageLevel().

vedi anche:

Transizione selezionabile

Un TransitionDrawable è un oggetto disegnabile che possono dissolversi in dissolvenza incrociata tra altre due risorse drawable.

Ogni elemento disegnabile è rappresentato da un elemento <item> all'interno di un singolo elemento <transition>. Non sono supportati più di due elementi. Per eseguire la transizione in avanti, chiama startTransition(). A transizione a ritroso, richiama reverseTransition().

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a TransitionDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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>
elementi:
<transition>
Obbligatorio. Deve essere l'elemento principale. Contiene uno o più elementi <item>.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
<item>
Definisce un elemento drawable da utilizzare come parte della transizione drawable. Deve essere un elemento secondario di un elemento <transition>. Accetta il publisher secondario <bitmap> elementi.

Attributi:

android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable risorsa.
android:id
ID risorsa. Un ID risorsa univoco per questo drawable. Per creare una nuova risorsa per questo articolo, utilizza il modulo: "@+id/name". Il simbolo più indica che viene creato come nuovo ID. Puoi utilizzare questo identificatore per recupera e modifica il drawable con View.findViewById() o Activity.findViewById().
android:top
Numero intero. L'offset superiore in pixel.
android:right
Numero intero. L'offset destro in pixel.
android:bottom
Numero intero. L'offset inferiore in pixel.
android:left
Numero intero. L'offset sinistro in pixel.
esempio:
File XML salvato alle ore 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>

Questo file XML di layout applica l'elemento drawable a una visualizzazione:

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

Il seguente codice esegue una transizione di 500 ms dal primo elemento al secondo:

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);
}
vedi anche:

Drawable inserito

Un drawable definito in XML che ne inserisce un altro in base a una distanza specificata. È utile quando una vista necessita di uno sfondo più piccolo dei limiti effettivi della vista.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a InsetDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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" />
elementi:
<inset>
Obbligatorio. Definisce il drawable integrato. Deve essere l'elemento principale.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable la risorsa da inserire.
android:insetTop
Dimensione. Il riquadro superiore, come valore di dimensione o risorsa dimensione.
android:insetRight
Dimensione. Il riquadro corretto, come valore di dimensione o risorsa dimensione.
android:insetBottom
Dimensione. Il riquadro inferiore, come valore di dimensione o risorsa dimensione.
android:insetLeft
Dimensione. Il riquadro a sinistra, come valore di dimensione o risorsa dimensione.
esempio:
<?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" />
vedi anche:

Clip estraibile

Un drawable definito in XML che blocca un altro drawable in base al livello attuale di questo drawable. Tu controllare la misura in cui ritagliare l'elemento drawable secondario in larghezza e altezza in base al livello; inoltre, come gravità per controllare la posizione nel suo contenitore complessivo. Utilizzata più spesso per implementare come le barre di avanzamento.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a ClipDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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"] />
elementi:
<clip>
Obbligatorio. Definisce il drawable del clip. Deve essere l'elemento principale.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable risorsa da ritagliare.
android:clipOrientation
Parola chiave. L'orientamento del clip.

Deve essere uno dei seguenti valori costanti:

ValoreDescrizione
horizontal Ritaglia la risorsa drawable orizzontalmente.
vertical Fissa l'elemento drawable in verticale.
android:gravity
Parola chiave. Specifica dove ritagliare all'interno del drawable.

Deve essere uno o più dei seguenti valori costanti, separati da |:

ValoreDescrizione
top Posiziona l'oggetto nella parte superiore del contenitore senza cambiarne le dimensioni. Se il valore del campo clipOrientation è "vertical", viene creato un ritaglio nella parte inferiore dell'elemento drawable.
bottom Posiziona l'oggetto nella parte inferiore del contenitore, senza cambiarne le dimensioni. Se clipOrientation è "vertical", il ritaglio viene eseguito nella parte superiore dell'elemento drawable.
left Posiziona l'oggetto sul bordo sinistro del contenitore, senza modificarne le dimensioni. Questo è il predefinito. Quando il valore del campo clipOrientation è "horizontal", il ritaglio avviene sul lato destro di il drawable.
right Posiziona l'oggetto sul bordo destro del contenitore, senza cambiarne le dimensioni. Quando il valore del campo clipOrientation è "horizontal", viene creato un ritaglio sul lato sinistro di il drawable.
center_vertical Posiziona l'oggetto al centro verticale del contenitore, senza cambiarne le dimensioni. Il ritaglio funziona la stessa cosa di quando la gravità è "center".
fill_vertical Se necessario, aumenta la dimensione verticale dell'oggetto in modo che riempia completamente il suo contenitore. Se il valore di clipOrientation è "vertical", non si verifica alcun ritaglio perché l'elemento drawable riempie il valore spazio verticale (a meno che il livello disegnabile sia 0, nel qual caso non è visibile).
center_horizontal Posiziona l'oggetto al centro orizzontale del contenitore senza modificarne le dimensioni. La creazione di clip si comporta come quando la gravità è "center".
fill_horizontal Aumenta la dimensione orizzontale dell'oggetto, se necessario, in modo che riempia completamente il suo contenitore. Quando clipOrientation è "horizontal", non si verifica alcun ritaglio perché l'elemento drawable riempie il spazio orizzontale (a meno che il livello drawable non sia 0, nel qual caso non è visibile).
center Posiziona l'oggetto al centro del contenitore, sia sull'asse verticale che su quello orizzontale, non cambiandone le dimensioni. Se il valore del campo clipOrientation è "horizontal", il ritaglio avviene a sinistra e a destra. Se il valore del campo clipOrientation è "vertical", il ritaglio avviene nella parte superiore e inferiore.
fill Aumenta la dimensione orizzontale e verticale dell'oggetto, se necessario, in modo che riempia completamente la sua containerizzato. Non viene visualizzato alcun ritaglio perché il drawable riempie il spazio orizzontale e verticale (a meno che il livello disegnabile sia 0, nel qual caso non lo è visibile).
clip_vertical Opzione aggiuntiva che può essere impostata in modo da ritagliare i bordi superiore e/o inferiore del riquadro secondario limiti del rispettivo container. Il clip si basa sulla gravità verticale: una gravità superiore collega la il bordo inferiore, una gravità inferiore blocca il bordo superiore e nessuna delle due clip viene agganciata a entrambi i bordi.
clip_horizontal Opzione aggiuntiva che può essere impostata in modo da ritagliare i bordi sinistro e/o destro del riquadro secondario limiti del rispettivo container. Il clip si basa sulla gravità orizzontale, ovvero clip sulla gravità sinistra il bordo destro, una gravità destra intercala il bordo sinistro e nessuno dei due blocca entrambi i bordi.
esempio:
File XML salvato alle ore 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" />

Il seguente file XML di layout applica l'elemento disegnabile del clip a una visualizzazione:

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

Il seguente codice ottiene il drawable e aumenta la quantità di clipping a rivelano progressivamente l'immagine:

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

Aumentando il livello si riduce la quantità di clip e l'immagine viene svelata lentamente. Eccolo a un livello di 7000:

Nota: il livello predefinito è 0, che viene completamente ritagliato in modo che l'immagine non è visibile. Quando il livello è 10.000, l'immagine non viene ritagliata ed è completamente visibile.

vedi anche:

Risorsa disegnabile in scala

Un drawable definito in XML che modifica le dimensioni di un altro drawable in base al relativo attuale livello.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a ScaleDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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" />
elementi:
<scale>
Obbligatorio. Definisce il drawable della scala. Deve essere l'elemento principale.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
android:drawable
Risorsa disegnabile. Obbligatorio. Riferimento a un drawable risorsa.
android:scaleGravity
Parola chiave. Specifica la posizione della gravità dopo il ridimensionamento.

Deve essere uno o più dei seguenti valori costanti, separati da |:

ValoreDescrizione
top Posiziona l'oggetto nella parte superiore del contenitore senza cambiarne le dimensioni.
bottom Posiziona l'oggetto nella parte inferiore del contenitore, senza cambiarne le dimensioni.
left Posiziona l'oggetto sul bordo sinistro del contenitore, senza modificarne le dimensioni. Questo è il predefinito.
right Posiziona l'oggetto sul bordo destro del contenitore, senza cambiarne le dimensioni.
center_vertical Posiziona l'oggetto al centro verticale del contenitore, senza cambiarne le dimensioni.
fill_vertical Se necessario, aumenta la dimensione verticale dell'oggetto in modo che riempia completamente il suo contenitore.
center_horizontal Posiziona l'oggetto al centro orizzontale del contenitore senza modificarne le dimensioni.
fill_horizontal Aumenta la dimensione orizzontale dell'oggetto, se necessario, in modo che riempia completamente il suo contenitore.
center Posiziona l'oggetto al centro del contenitore, sia sull'asse verticale che su quello orizzontale, non cambiandone le dimensioni.
fill Aumenta la dimensione orizzontale e verticale dell'oggetto, se necessario, in modo che riempia completamente la sua containerizzato.
clip_vertical Opzione aggiuntiva che può essere impostata in modo da ritagliare i bordi superiore e/o inferiore del riquadro secondario limiti del rispettivo container. Il clip si basa sulla gravità verticale: una gravità superiore collega la il bordo inferiore, una gravità inferiore blocca il bordo superiore e nessuna delle due clip viene agganciata a entrambi i bordi.
clip_horizontal Opzione aggiuntiva che può essere impostata in modo da ritagliare i bordi sinistro e/o destro del riquadro secondario limiti del rispettivo container. Il clip si basa sulla gravità orizzontale, ovvero clip sulla gravità sinistra il bordo destro, una gravità destra intercala il bordo sinistro e nessuno dei due blocca entrambi i bordi.
android:scaleHeight
Percentuale: L'altezza della scala, espressa come percentuale della limitato. Il formato del valore è XX%, ad esempio 100% o 12,5%.
android:scaleWidth
Percentuale: La larghezza della scala, espressa come percentuale della dimensione limitato. Il formato del valore è XX%, ad esempio 100% o 12,5%.
esempio:
<?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%" />
vedi anche:

Forma disegnabile

Si tratta di una forma generica definita in XML.

percorso del file:

res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilato:
Puntatore della risorsa a GradientDrawable
riferimento della risorsa:
In Java: R.drawable.filename
In XML: @[package:]drawable/filename
sintassi:
<?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>
elementi:
<shape>
Obbligatorio. La forma disegnabile. Deve essere l'elemento principale.

Attributi:

xmlns:android
Stringa. Obbligatorio. Definisce lo spazio dei nomi XML, che deve essere "http://schemas.android.com/apk/res/android".
android:shape
Parola chiave. Definisce il tipo di forma. I valori validi sono:
ValoreDescrizione
"rectangle" Un rettangolo che riempie la vista contenitore. Questa è la forma predefinita.
"oval" Una forma ovale che si adatta alle dimensioni della vista contenitore.
"line" Una linea orizzontale che copre la larghezza della visualizzazione che la contiene. Questo richiede che l'elemento <stroke> definisca la larghezza dell'elemento dalla riga di comando.
"ring" A forma di anello.

I seguenti attributi vengono utilizzati solo quando android:shape="ring":

android:innerRadius
Dimensione. Il raggio del parte interna dell'anello (il foro al centro), come valore di dimensione o risorsa dimensione.
android:innerRadiusRatio
In virgola mobile. Il raggio per l'interno parte dell'anello, espressa come rapporto tra la larghezza dell'anello. Ad esempio, se android:innerRadiusRatio="5", il raggio interno equivale alla larghezza dell'anello diviso per 5. Questo viene sostituito da android:innerRadius. Il valore predefinito è 9.
android:thickness
Dimensione. Lo spessore del come valore di dimensione o risorsa dimensione.
android:thicknessRatio
In virgola mobile. Lo spessore dell'anello espressa come rapporto della larghezza dell'anello. Ad esempio, se android:thicknessRatio="2": lo spessore è uguale alla larghezza dell'anello divisa per 2. Questo valore è stato sostituito da android:innerRadius. Il valore predefinito è 3.
android:useLevel
Booleano. True se utilizzato come LevelListDrawable. In genere è falso, altrimenti la forma potrebbe non apparire.
<corners>
Crea angoli arrotondati per la forma. Si applica solo quando la forma è un rettangolo.

Attributi:

android:radius
Dimensione. Il raggio di tutti gli angoli, sotto forma di valore di dimensione o risorsa dimensione. Viene eseguito l'override di in base ai seguenti attributi.
android:topLeftRadius
Dimensione. Il raggio per l'angolo in alto a sinistra, come valore di dimensione o risorsa dimensione.
android:topRightRadius
Dimensione. Il raggio per l'angolo in alto a destra, come valore di dimensione o risorsa dimensione.
android:bottomLeftRadius
Dimensione. Il raggio per l'angolo in basso a sinistra, come valore di dimensione o risorsa dimensione.
android:bottomRightRadius
Dimensione. Il raggio dell'angolo in basso a destra, sotto forma di valore di dimensione o risorsa dimensione.

Nota: all'inizio, ogni angolo deve avere un angolo maggiore di 1, altrimenti gli angoli non vengono arrotondati. Se vuoi degli angoli specifici in modo che non venga arrotondato, una soluzione alternativa è usare android:radius per impostare un angolo predefinito maggiore di 1 e poi sostituisci ogni angolo con i valori che vuoi, specificando 0 ("0dp") dove non vuoi che gli angoli arrotondati siano arrotondati.

<gradient>
Specifica un colore gradiente per la forma.

Attributi:

android:angle
Numero intero. L'angolo del gradiente, in gradi. 0 indica da sinistra a destra, 90 indica dal basso verso l'alto. Deve essere un multiplo di 45. Il valore predefinito è 0.
android:centerX
In virgola mobile. La posizione X relativa del centro del gradiente (0-1,0).
android:centerY
In virgola mobile. La posizione Y relativa del centro del gradiente (0-1,0).
android:centerColor
Colore. Colore facoltativo compreso tra i colori di inizio e fine, come valore esadecimale o risorsa colore.
android:endColor
Colore. Il colore finale, in formato esadecimale o una risorsa colore.
android:gradientRadius
In virgola mobile. Il raggio del gradiente. Applicato solo quando android:type="radial".
android:startColor
Colore. Il colore iniziale, in formato esadecimale o una risorsa colore.
android:type
Parola chiave. Il tipo di pattern a gradiente da applicare. I valori validi sono:
ValoreDescrizione
"linear" Un gradiente lineare. Questa è l'impostazione predefinita.
"radial" Un gradiente radiale. Il colore iniziale è il colore centrale.
"sweep" Un gradiente di linea diretta.
android:useLevel
Booleano. True se viene utilizzato come LevelListDrawable.
<padding>
Spaziatura interna da applicare all'elemento vista contenitore. In questo modo viene mantenuta la posizione della vista contenuti, non la forma.

Attributi:

android:left
Dimensione. Spaziatura interna sinistra, come valore di dimensione o risorsa dimensione.
android:top
Dimensione. Spaziatura interna superiore, come valore di dimensione o risorsa dimensione.
android:right
Dimensione. Spaziatura interna destra, come valore di dimensione o risorsa dimensione.
android:bottom
Dimensione. Spaziatura interna inferiore, come valore di dimensione o risorsa dimensione.
<size>
Le dimensioni della forma.

Attributi:

android:height
Dimensione. L'altezza della forma, come valore di dimensione o risorsa dimensione.
android:width
Dimensione. La larghezza della forma, come valore di dimensione o risorsa dimensione.

Nota:per impostazione predefinita, la forma viene adattata alle dimensioni del contenitore viene visualizzata in proporzione alle dimensioni definite qui. Quando utilizzi la forma in una ImageView, puoi limitare il ridimensionamento impostando android:scaleType su "center".

<solid>
Un colore a tinta unita per riempire la forma.

Attributi:

android:color
Colore. Il colore da applicare alla forma, come esadecimale o una risorsa colore.
<stroke>
Una linea tratto per la forma.

Attributi:

android:width
Dimensione. Lo spessore della linea, come valore di dimensione o risorsa dimensione.
android:color
Colore. Il colore della linea, come valore esadecimale o risorsa colore.
android:dashGap
Dimensione. La distanza tra i trattini, sotto forma di valore di dimensione o risorsa dimensione. Valido solo se è impostato android:dashWidth.
android:dashWidth
Dimensione. La dimensione di ogni linea tratteggiata, come valore di dimensione o risorsa dimensione. Valido solo se è impostato android:dashGap.
esempio:
File XML salvato alle ore 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>

Questo file XML di layout applica la forma di cui è possibile disegnare a una visualizzazione:

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

Questo codice dell'applicazione ottiene la forma disegnabile e la applica a una vista:

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);
vedi anche: