Risorse disegnabili

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

File bitmap
Un file grafico bitmap (PNG, WEBP, JPG o GIF). Crea un BitmapDrawable.
File con 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 elemento disegnabile che gestisce un array di altri disegnabili. Questi elementi vengono disegnati in ordine array, quindi l'elemento con l'indice più grande viene disegnato in alto. Crea un LayerDrawable.
Elenco di stati
Un file XML che fa riferimento a diversi elementi grafici bitmap per stati diversi, ad esempio per utilizzare un'immagine diversa quando si tocca un pulsante. Crea un StateListDrawable.
Elenco dei livelli
Un file XML che definisce un disegno che gestisce una serie di elementi disegnati alternativi, a ciascuno dei quali è stato assegnato un valore numerico massimo. Crea un LevelListDrawable.
Transizione disegnabile
Un file XML che definisce un elemento disegnabile con dissolvenza incrociata tra due risorse disegnabili. Crea un TransitionDrawable.
Disegnabile a incasso
Un file XML che definisce un elemento disegnabile che inserisce un altro oggetto disegnabile in base a una distanza specificata. Ciò è utile quando una vista ha bisogno di uno sfondo disegnabile che sia più piccolo dei limiti effettivi della vista.
Clip disegnabile
Un file XML che definisce un elemento di disegno che esegue il clip di un altro oggetto di disegno in base al valore del livello corrente di questo disegno. Crea un ClipDrawable.
Scala disegnabile
Un file XML che definisce un elemento disegnabile che modifica le dimensioni di un altro elemento disegnabile in base al valore del suo livello corrente. Crea un ScaleDrawable
Forma disegnabile.
Un file XML che definisce una forma geometrica, inclusi colori e gradienti. Crea un GradientDrawable.

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

Nota: una risorsa colore può essere utilizzata anche come disegnabile in XML. Ad esempio, quando crei un elenco di stati disegnabile, 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 (consigliato), WEBP (consigliato, richiede API di 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 ID risorsa alias in XML.

Nota: i file bitmap potrebbero essere ottimizzati automaticamente con la compressione di immagini senza perdita di dati dallo strumento aapt durante il processo di compilazione. Ad esempio, un file PNG a colori reali che non richiede più di 256 colori potrebbe essere convertito in un file PNG a 8 bit con una tavolozza dei colori. Il risultato è un'immagine di pari qualità che richiede meno memoria.

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

File bitmap

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

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

Il seguente codice 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 è un alias per un file bitmap non elaborato. Il file XML può specificare proprietà aggiuntive per la bitmap, come dithering e tiling.

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

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un BitmapDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
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 è obbligatoria solo se <bitmap> è l'elemento principale. Non è necessario quando <bitmap> è nidificato all'interno di un <item>.
android:src
Risorsa tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile.
android:antialias
Booleano. Attiva o disattiva l'antialiasing.
android:dither
Booleano. Abilita o disabilita il dithering della bitmap se la bitmap non ha la stessa configurazione dei pixel dello schermo, ad esempio una bitmap ARGB 8888 su uno schermo RGB 565.
android:filter
Booleano. Attiva o disattiva il filtro bitmap. I filtri vengono utilizzati quando la bitmap viene ridotta o allungata per uniformarne l'aspetto.
android:gravity
Parola chiave. Definisce la gravità per la bitmap. La gravità indica dove posizionare il disegno a trascinamento nel contenitore se la bitmap è più piccola del container.

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

ValoreDescrizione
top Posiziona l'oggetto sopra il contenitore, senza modificarne le dimensioni.
bottom Posiziona l'oggetto nella parte inferiore del contenitore, senza modificarne 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 modificarne le dimensioni.
center_vertical Posiziona l'oggetto al centro verticale del contenitore, senza modificarne le dimensioni.
fill_vertical Se necessario, aumenta le dimensioni verticali dell'oggetto in modo che riempia completamente il contenitore.
center_horizontal Posiziona l'oggetto al centro orizzontale del contenitore, senza modificarne le dimensioni.
fill_horizontal Se necessario, aumenta le dimensioni orizzontali dell'oggetto in modo che riempia completamente il contenitore.
center Posiziona l'oggetto al centro del contenitore sia sull'asse verticale che su quello orizzontale, senza modificarne le dimensioni.
fill Se necessario, aumenta le dimensioni orizzontale e verticale dell'oggetto in modo che riempia completamente il contenitore. Questa è l'impostazione predefinita.
clip_vertical Opzione aggiuntiva che può essere impostata in modo che i bordi superiore e/o inferiore dell'asset secondario siano ritagliati in base ai limiti del container. La clip si basa sulla gravità verticale: una gravità superiore fissa il bordo inferiore, una gravità inferiore fissa il bordo superiore e nessuna delle due clip per entrambi i bordi.
clip_horizontal Opzione aggiuntiva che può essere impostata in modo che i bordi sinistro e/o destro dell'asset secondario siano ritagliati in base ai limiti del container. La clip si basa sulla gravità orizzontale: una gravità sinistra aggancia il bordo destro, una gravità destra fissa il bordo sinistro e nessuna delle due clip 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à riquadro è abilitata, la bitmap viene ripetuta. La gravità viene ignorata quando è attivata 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 scheduler disegna al di fuori dei suoi limiti originali
repeat Ripeti l'immagine dell'shadowr orizzontalmente e verticalmente.
mirror Ripeti l'immagine dell'ombreggiatore orizzontalmente e verticalmente, alternando immagini speculari in modo che le immagini adiacenti vengano 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 bende

Un elemento NinePatch è un'immagine PNG in cui puoi definire regioni estensibili che Android ridimensiona quando i contenuti all'interno della visualizzazione superano i normali limiti dell'immagine. In genere questo tipo di immagine viene assegnato come sfondo di una vista con almeno una dimensione impostata su "wrap_content".

Quando la visualizzazione si ingrandisce per adattarsi al contenuto, anche l'immagine con nove patch viene adattata alle dimensioni della visualizzazione. Un esempio di utilizzo di un'immagine con nove patch è lo sfondo utilizzato dal widget Button standard di Android, che deve allungarsi per ospitare il testo (o l'immagine) all'interno del pulsante.

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

Per una discussione completa su come creare un file con nove patch e regioni estendibili, vedi Creare bitmap ridimensionabili (file con 9 patch).

File nove patch

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

Nove patch XML

Un 9-patch XML è una risorsa definita nel file XML che rimanda a un file con nove patch. Il file XML può specificare il dithering per l'immagine.

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un NinePatchDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
Obbligatorio. Definisce l'origine delle nove patch e le sue 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 tracciabile. Obbligatorio. Riferimento a un file con nove patch.
android:dither
Booleano. Abilita o disabilita il dithering della bitmap se la bitmap non ha la stessa configurazione dei pixel dello schermo, ad esempio una bitmap ARGB 8888 su uno schermo RGB 565.
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 disegnabili. Ogni elemento disegnabile nell'elenco viene tracciato secondo l'ordine in cui è inserita. In alto viene disegnato l'ultimo elemento disegnabile dell'elenco.

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

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un LayerDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
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 disegnabile, in una posizione definita dai suoi attributi. Deve essere un elemento secondario di un elemento <layer-list>. Accetta gli elementi <bitmap> secondari.

Attributi:

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

Per impostazione predefinita, tutti gli elementi disegnabili vengono ridimensionati per adattarsi alle dimensioni della vista contenitore. Di conseguenza, il posizionamento delle immagini in un elenco di livelli in posizioni diverse potrebbe aumentare le dimensioni della visualizzazione e alcune immagini vengono ridimensionate a seconda dei casi.

Per evitare di ridimensionare gli elementi nell'elenco, utilizza un elemento <bitmap> all'interno dell'elemento <item> per specificare il disegno e definire la gravità per un elemento che non si adatta in scala, come "center". Ad esempio, il seguente <item> definisce un elemento scalato per adattarsi alla visualizzazione del contenitore:

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

Per evitare il ridimensionamento, nell'esempio seguente viene utilizzato un elemento <bitmap> con gravità centrata:

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

Questo esempio utilizza un elemento <bitmap> nidificato per definire la risorsa disegnabile per ogni elemento con gravità "center". Ciò garantisce che nessuna delle immagini venga scalata per adattarsi alle dimensioni del container, a causa del ridimensionamento causato dalle immagini offset.

Questo XML di layout applica il disegno a una vista:

<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 di stati

Un StateListDrawable è un oggetto disegnabile definito in XML che utilizza più immagini per rappresentare la stessa grafica, a seconda dello stato dell'oggetto. Ad esempio, lo stato di un widget Button può essere toccato, attivato o nessuno dei due; utilizzando un elenco di stati disegnabile, puoi fornire un'immagine di sfondo diversa per ogni stato.

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

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

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un StateListDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
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 registrata del disegno a disegno rimane costante quando lo stato cambia (la dimensione è la dimensione massima di tutti gli stati); false se le dimensioni variano in base allo stato corrente. Il valore predefinito è false.
android:dither
Booleano. True per abilitare il dithering della bitmap se la bitmap non ha la stessa configurazione dei pixel dello schermo, ad esempio una bitmap ARGB 8888 su uno schermo RGB 565; false per disattivare il dithering. Il valore predefinito è true.
android:variablePadding
Booleano. True se la spaziatura interna del disegnatore cambia in base allo stato corrente selezionato; false se la spaziatura interna deve rimanere invariata, in base alla spaziatura interna massima di tutti gli stati. L'attivazione di questa funzionalità richiede di gestire il layout dell'esecuzione quando lo stato cambia, il che spesso non è supportato. Il valore predefinito è false.
<item>
Definisce un disegno da utilizzare in determinati stati, come descritto dai suoi attributi. Deve essere un elemento secondario di un elemento <selector>.

Attributi:

android:drawable
Risorsa tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile.
android:state_pressed
Booleano. True se questo elemento viene utilizzato quando l'oggetto viene toccato, ad esempio quando si tocca un pulsante; false se l'elemento viene utilizzato nello stato predefinito non toccato.
android:state_focused
Booleano. True se questo elemento viene utilizzato quando l'oggetto è impostato come attivo per l'input, ad esempio quando l'utente seleziona un input di testo; false se questo elemento viene utilizzato nello stato non attivo predefinito.
android:state_hovered
Booleano. True se l'elemento viene utilizzato quando il cursore passa sopra l'oggetto; false se l'elemento viene utilizzato nello stato predefinito, non posizionato al passaggio del mouse. Spesso, questo disegno può essere lo stesso utilizzato per lo stato "concentrato".

Introdotta nel livello API 14.

android:state_selected
Booleano. True se questo elemento viene utilizzato quando l'oggetto è la selezione utente corrente durante la navigazione con un controllo direzionale, ad esempio durante la navigazione in un elenco con un D-pad; false se l'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 elemento viene utilizzato quando l'oggetto non è selezionabile. Utile solo se è possibile passare da un widget selezionabile a un widget non selezionabile e viceversa.
android:state_checked
Booleano. True se questo elemento viene utilizzato quando l'oggetto è selezionato; false se viene utilizzato quando l'oggetto è deselezionato.
android:state_enabled
Booleano. True se questo elemento viene utilizzato quando l'oggetto è abilitato, ovvero in grado di ricevere eventi di tocco o clic; false se viene utilizzato quando l'oggetto è disabilitato.
android:state_activated
Booleano. True se questo elemento viene utilizzato quando l'oggetto è attivato come selezione permanente, ad esempio per "evidenziare" l'elemento dell'elenco selezionato in precedenza in una visualizzazione di navigazione permanente; false se viene utilizzato quando l'oggetto non è attivato.

Introdotta nel livello API 11.

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

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

esempio:
File XML salvato in 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 XML di layout applica l'elenco di stati disegnabile a un pulsante:

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

Elenco dei livelli

Un elemento disegnabile che gestisce un numero di disegnabili alternativi, a ciascuno dei quali è stato assegnato un valore numerico massimo. L'impostazione del valore del livello del disegno con setLevel() consente di caricare la risorsa disegnabile nell'elenco dei livelli con un valore di android:maxLevel maggiore o uguale al valore passato al metodo.

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un LevelListDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
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 tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile da inserire.
android:maxLevel
Numero intero. Il livello massimo consentito per questo articolo.
android:minLevel
Numero intero. Il livello minimo consentito per questo articolo.
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 l'applicazione a un View, il livello può essere modificato con setLevel() o setImageLevel().

vedi anche:

Transizione disegnabile

Un TransitionDrawable è un oggetto disegnabile che può applicare una dissolvenza incrociata tra altre due risorse disegnabili.

Ogni elemento disegnabile è rappresentato da un elemento <item> all'interno di un singolo elemento <transition>. Non sono supportati più di due elementi. Per effettuare la transizione, chiama il numero startTransition(). Per passare a ritroso, chiama reverseTransition().

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un TransitionDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
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 nell'ambito della transizione disegnabile. Deve essere un elemento secondario di un elemento <transition>. Accetta gli elementi <bitmap> secondari.

Attributi:

android:drawable
Risorsa tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile.
android:id
ID risorsa: Un ID risorsa univoco per questo disegno a disegno. Per creare un nuovo ID risorsa per questo elemento, utilizza il modulo: "@+id/name". Il simbolo più indica che si tratta di un nuovo ID. Puoi utilizzare questo identificatore per recuperare e modificare il disegno 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 in 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 XML di layout applica il disegno a una vista:

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

Inoltre, il codice seguente 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:

Riquadro disegnabile

Un elemento disegnabile definito in XML che inserisce un altro elemento disegnabile in base a una distanza specificata. Questo è utile quando una visualizzazione ha bisogno di uno sfondo più piccolo dei limiti effettivi della visualizzazione.

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un InsetDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
Obbligatorio. Definisce l'elemento 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:drawable
Risorsa tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile da inserire.
android:insetTop
Dimensione. Il riquadro superiore, come valore di dimensione o risorsa di dimensione.
android:insetRight
Dimensione. Il riquadro a destra, come valore di dimensione o risorsa di dimensione.
android:insetBottom
Dimensione. Il riquadro inferiore, come valore di dimensione o risorsa di dimensione.
android:insetLeft
Dimensione. Il riquadro sinistro, come valore di dimensione o risorsa di 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 disegnabile

Un elemento disegnabile definito nel file XML che ritaglia un altro oggetto di disegno in base al livello corrente di questo Drawable. Puoi controllare quanto può essere disegnato il bambino in larghezza e altezza in base al livello, nonché la gravità per controllare dove viene posizionato nel contenitore complessivo. Il più delle volte viene usato per implementare cose come le barre di avanzamento.

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un ClipDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
Obbligatorio. Definisce il clip 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:drawable
Risorsa tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile da ritagliare.
android:clipOrientation
Parola chiave. L'orientamento del clip.

Deve essere uno dei seguenti valori costanti:

ValoreDescrizione
horizontal Ritaglia il disegnabile orizzontalmente.
vertical Fissa il disegnabile in verticale.
android:gravity
Parola chiave. Specifica dove ritagliare all'interno del disegno.

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

ValoreDescrizione
top Posiziona l'oggetto sopra il contenitore, senza modificarne le dimensioni. Quando clipOrientation è "vertical", il ritaglio si verifica nella parte inferiore del disegnabile.
bottom Posiziona l'oggetto nella parte inferiore del contenitore, senza modificarne le dimensioni. Quando clipOrientation è "vertical", il ritaglio si verifica nella parte superiore dell'elemento disegnabile.
left Posiziona l'oggetto sul bordo sinistro del contenitore, senza modificarne le dimensioni. Questa è l'impostazione predefinita. Quando clipOrientation è "horizontal", il ritaglio si verifica sul lato destro della risorsa disegnabile.
right Posiziona l'oggetto sul bordo destro del contenitore, senza modificarne le dimensioni. Quando clipOrientation è "horizontal", il ritaglio viene eseguito sul lato sinistro del disegnabile.
center_vertical Posiziona l'oggetto al centro verticale del contenitore, senza modificarne le dimensioni. Il taglio si comporta come quando la gravità è "center".
fill_vertical Se necessario, aumenta le dimensioni verticali dell'oggetto in modo che riempia completamente il contenitore. Quando clipOrientation è "vertical", non si verifica alcun ritaglio perché l'elemento disegnabile riempie lo spazio verticale (a meno che il livello di disegno non sia 0, nel qual caso non è visibile).
center_horizontal Posiziona l'oggetto al centro orizzontale del contenitore, senza modificarne le dimensioni. Il taglio si comporta come quando la gravità è "center".
fill_horizontal Se necessario, aumenta le dimensioni orizzontali dell'oggetto in modo che riempia completamente il contenitore. Quando clipOrientation è "horizontal", non si verifica alcun ritaglio perché l'elemento disegnabile riempie lo spazio orizzontale (a meno che il livello di disegno non sia 0, nel qual caso non è visibile).
center Posiziona l'oggetto al centro del contenitore sia sull'asse verticale che su quello orizzontale, senza modificarne le dimensioni. Quando clipOrientation è "horizontal", il ritaglio viene eseguito a sinistra e a destra. Quando clipOrientation è "vertical", il ritaglio si verifica nella parte superiore e inferiore.
fill Se necessario, aumenta le dimensioni orizzontale e verticale dell'oggetto in modo che riempia completamente il contenitore. Non viene eseguito alcun ritaglio perché l'elemento disegnabile riempie lo spazio orizzontale e verticale (a meno che il livello di disegno non sia 0, nel qual caso non è visibile).
clip_vertical Opzione aggiuntiva che può essere impostata in modo che i bordi superiore e/o inferiore dell'asset secondario siano ritagliati in base ai limiti del container. La clip si basa sulla gravità verticale: una gravità superiore fissa il bordo inferiore, una gravità inferiore fissa il bordo superiore e nessuna delle due clip per entrambi i bordi.
clip_horizontal Opzione aggiuntiva che può essere impostata in modo che i bordi sinistro e/o destro dell'asset secondario siano ritagliati in base ai limiti del container. La clip si basa sulla gravità orizzontale: una gravità sinistra aggancia il bordo destro, una gravità destra fissa il bordo sinistro e nessuna delle due clip entrambi i bordi.
esempio:
File XML salvato in 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 XML di layout applica il clip disegnabile 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 disegnabile e aumenta la quantità di ritagli per mostrare 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 ritagli e l'immagine viene visualizzata lentamente. Eccolo a 7000:

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

vedi anche:

Ridimensionabile

Un elemento tracciabile definito in XML che modifica le dimensioni di un altro elemento disegnabile in base al livello attuale.

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un ScaleDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
Obbligatorio. Definisce la scala 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:drawable
Risorsa tracciabile. Obbligatorio. Riferimento a una risorsa disegnabile.
android:scaleGravity
Parola chiave. Specifica la posizione della gravità dopo la scalabilità.

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

ValoreDescrizione
top Posiziona l'oggetto sopra il contenitore, senza modificarne le dimensioni.
bottom Posiziona l'oggetto nella parte inferiore del contenitore, senza modificarne le dimensioni.
left Posiziona l'oggetto sul bordo sinistro del contenitore, senza modificarne le dimensioni. Questa è l'impostazione predefinita.
right Posiziona l'oggetto sul bordo destro del contenitore, senza modificarne le dimensioni.
center_vertical Posiziona l'oggetto al centro verticale del contenitore, senza modificarne le dimensioni.
fill_vertical Se necessario, aumenta le dimensioni verticali dell'oggetto in modo che riempia completamente il contenitore.
center_horizontal Posiziona l'oggetto al centro orizzontale del contenitore, senza modificarne le dimensioni.
fill_horizontal Se necessario, aumenta le dimensioni orizzontali dell'oggetto in modo che riempia completamente il contenitore.
center Posiziona l'oggetto al centro del contenitore sia sull'asse verticale che su quello orizzontale, senza modificarne le dimensioni.
fill Se necessario, aumenta le dimensioni orizzontale e verticale dell'oggetto in modo che riempia completamente il contenitore.
clip_vertical Opzione aggiuntiva che può essere impostata in modo che i bordi superiore e/o inferiore dell'asset secondario siano ritagliati in base ai limiti del container. La clip si basa sulla gravità verticale: una gravità superiore fissa il bordo inferiore, una gravità inferiore fissa il bordo superiore e nessuna delle due clip per entrambi i bordi.
clip_horizontal Opzione aggiuntiva che può essere impostata in modo che i bordi sinistro e/o destro dell'asset secondario siano ritagliati in base ai limiti del container. La clip si basa sulla gravità orizzontale: una gravità sinistra aggancia il bordo destro, una gravità destra fissa il bordo sinistro e nessuna delle due clip entrambi i bordi.
android:scaleHeight
Percentuale. L'altezza della scala, espressa come percentuale del limite del disegnabile. Il formato del valore è XX%, ad esempio 100% o 12,5%.
android:scaleWidth
Percentuale. La larghezza della scala, espressa come percentuale del limite del disegnabile. 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 nel file XML.

percorso file:
res/drawable/filename.xml
Il nome file è l'ID risorsa
tipo di dati della risorsa compilata:
Puntatore risorsa a un GradientDrawable
riferimento risorsa:
In Java: R.drawable.filename
In 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>
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 si estende per tutta la larghezza della vista contenitore. Questa forma richiede l'elemento <stroke> per definire la larghezza della linea.
"ring" A forma di anello.

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

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

Attributi:

android:radius
Dimensione. Il raggio per tutti gli angoli, come valore di dimensione o risorsa dimensione. Questo viene sostituito per ogni angolo dai seguenti attributi.
android:topLeftRadius
Dimensione. Il raggio dell'angolo in alto a sinistra, come valore di dimensione o risorsa dimensione.
android:topRightRadius
Dimensione. Il raggio dell'angolo in alto a destra, come valore di dimensione o risorsa dimensione.
android:bottomLeftRadius
Dimensione. Il raggio dell'angolo in basso a sinistra, come valore di dimensione o risorsa dimensione.
android:bottomRightRadius
Dimensione. Il raggio dell'angolo in basso a destra, come valore di dimensione o risorsa dimensione.

Nota: inizialmente deve essere fornito un raggio d'angolo maggiore di 1 per ogni angolo, altrimenti nessun angolo sarà arrotondato. Se vuoi che non vengano arrotondati angoli specifici, una soluzione alternativa consiste nell'utilizzare android:radius per impostare un raggio d'angolo predefinito maggiore di 1 e poi sostituire ogni angolo con i valori che desideri, fornendo 0 ("0dp") dove non vuoi che vengano arrotondati.

<gradient>
Specifica un colore del gradiente per la forma.

Attributi:

android:angle
Numero intero. L'angolo del gradiente, espresso in gradi. 0 da sinistra a destra, 90 dal basso verso l'alto. Deve essere un multiplo di 45. Il valore predefinito è 0.
android:centerX
Virgola mobile. La posizione X relativa per il centro del gradiente (0 - 1,0).
android:centerY
Virgola mobile. La posizione Y relativa per il centro del gradiente (0 - 1,0).
android:centerColor
Colore. Colore facoltativo compreso tra i colori di inizio e fine, come valore esadecimale o risorsa di colore.
android:endColor
Colore. Il colore finale, sotto forma di valore esadecimale o risorsa di colore.
android:gradientRadius
Virgola mobile. Il raggio del gradiente. Applicato solo quando android:type="radial".
android:startColor
Colore. Il colore iniziale, sotto forma di valore esadecimale o risorsa di colore.
android:type
Parola chiave. Il tipo di motivo 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" Una linea sfumata.
android:useLevel
Booleano. True se viene utilizzato come LevelListDrawable.
<padding>
Spaziatura interna da applicare all'elemento vista contenitore. Questo occupa la posizione dei contenuti della visualizzazione, non la forma.

Attributi:

android:left
Dimensione. Spaziatura interna sinistra, come valore di dimensione o risorsa di dimensione.
android:top
Dimensione. Spaziatura interna superiore, come valore di dimensione o risorsa di dimensione.
android:right
Dimensione. Spaziatura interna destra, come valore di dimensione o risorsa di dimensione.
android:bottom
Dimensione. Spaziatura interna inferiore, come valore di dimensione o risorsa di 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 della vista contenitore, in proporzione alle dimensioni qui definite. Quando utilizzi la forma in un 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 valore esadecimale o risorsa di colore.
<stroke>
Una linea del 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 di colore.
android:dashGap
Dimensione. La distanza tra i trattini, come 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 in 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 XML di layout applica la forma disegnabile a una vista:

<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: