Questa pagina è stata tradotta dall'API Cloud Translation.

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

Valore	Descrizione
`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:

Valore	Descrizione
`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:

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:

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:

LayerDrawable

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:

StateListDrawable

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:

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:

LevelListDrawable

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:

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:

TransitionDrawable

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:

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:

InsetDrawable

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:

Valore	Descrizione
`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 |:

Valore	Descrizione
`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 le dimensioni verticali 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:

ClipDrawable

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

Valore	Descrizione
`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 le dimensioni verticali 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:

ScaleDrawable

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:

Valore	Descrizione
`"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:

Valore	Descrizione
`"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:

ShapeDrawable

Indietro

Elenco stati dei colori

Avanti

Disposizione