Share
Il duro lavoro non è finito solo perché la tua app ha accumulato un sacco di download e recensioni positive sul Google Play Store. Il tuo tipico utente mobile ha dozzine delle app installate sul loro dispositivo e con le nuove app rilasciate in continuazione, dovrai lavorare duro per mantenere l'interesse del pubblico!
L'utente sta tornando alla tua app cruciale per creare una base di utenti stabile e leale. Inoltre, se hai monetizzato la tua app, la quantità di tempo che le persone spendono nella tua applicazione influisce direttamente sulla somma che guadagni: pensa a ogni secondo aggiuntivo come un'altra opportunità di mostrare un annuncio o indurre l'utente a sborsare un -app acquisto!
All'I / O di quest'anno, Google ha introdotto fette, una nuova funzionalità che promette di indirizzare gli utenti verso la tua app mettendo le funzionalità e il contenuto della tua app davanti a loro nel momento esatto in cui sono più necessari.
Con le sezioni che si configurano come uno strumento importante per mantenere il tuo pubblico, ora è il momento perfetto per fare esperienza pratica con questa promettente funzionalità Android. Alla fine di questo articolo, avrai creato una serie di sezioni, partendo da una semplice sezione che avvia un'attività quando si passa a sezioni più complesse composte da icone, immagini, griglie e più SliceActions.
Analogamente ai widget, le fette sono frammenti di contenuto che appaiono al di fuori del contesto dell'applicazione, aumentando la visibilità della tua app e offrendoti maggiori opportunità di coinvolgere il tuo pubblico.
Le fette possono aumentare notevolmente la visibilità della tua app, con Google che promette di aggiungere il supporto per le sezioni alle aree in cui molti utenti Android dedicano molto tempo, tra cui la ricerca Google e l'Assistente Google. Poiché fanno parte di Android Jetpack, le slice sono compatibili con Android 4.4 e versioni successive, il che significa che le tue fette hanno il potenziale per raggiungere il 95% di tutti gli utenti Android.
Quindi le fette hanno molto da offrire, ma come funzionano?
Attualmente, se esegui una ricerca nell'app Google, Google potrebbe suggerire un'applicazione pertinente installata sul tuo dispositivo. Ad esempio, se hai installato Facebook per dispositivi mobili, quindi digita Facebook mostrerà un collegamento diretto all'app Facebook.
Le fette portano questa app a un ulteriore passaggio, concentrandosi su attività specifiche che l'utente potrebbe voler eseguire all'interno delle applicazioni che hanno già installato.
Diamo un'occhiata a un esempio: immagina di aver installato un'app Book A Hotel che ti consente di cercare un hotel e prenotare una stanza. Quando scrivi Hotel a Londra in Google, trovi i soliti risultati di ricerca, oltre a una sezione dall'applicazione Book A Hotel. Questa sezione consiglia un hotel a Londra e mostra informazioni come il nome e l'indirizzo dell'hotel, più un SliceAction, sotto forma di un pulsante che ti consente di prenotare una stanza direttamente dall'interfaccia utente della sezione (interfaccia utente).
Per l'utente, questa sezione ha fornito un facile accesso alle informazioni e alle funzionalità di cui avevano bisogno in quel particolare momento. Per lo sviluppatore, questa sezione ha consentito loro di mettere la propria applicazione di fronte a un utente nel punto esatto in cui avevano la maggiore possibilità di reinnescarla con successo.
Iniziamo creando una semplice fetta che, quando viene toccata, avvierà la nostra applicazione Attività principale.
Questa semplice tecnica consente di avviare qualsiasi attività, direttamente dall'interfaccia utente di una slice. Nel nostro esempio Book A Hotel, potremmo semplicemente collegare il pulsante alle app correlate BookRoomActivity, quale sarebbe un modo semplice ma efficace per ridurre il numero di schermate che l'utente deve percorrere per completare questo particolare compito.
Per iniziare, crea un nuovo progetto Android. Puoi usare qualunque impostazione tu voglia, ma assicurati di selezionare il Include il supporto Kotlin casella di controllo quando richiesto.
Una volta creato il tuo progetto, apri il suo file build.gradle e aggiungi il slice-core e slice-builder dipendenze:
dipendenze implementazione 'androidx.appcompat: appcompat: 1.0.0-alpha3' implementazione 'androidx.slice: slice-core: 1.0.0-alpha3' implementazione 'androidx.slice: slice-builders: 1.0.0-alpha3' implementation ' androidx.constraintlayout: constraintlayout: 1.1.0 'implementazione' org.jetbrains.kotlin: kotlin-stdlib-jdk7: $ kotlin_version "
Quindi, dobbiamo creare un fornitore di fette, che è il componente responsabile della visualizzazione dei contenuti della tua app al di fuori del contesto dell'applicazione.
Crei un fornitore di sezioni utilizzando il modello di fornitore di slice di Android Studio:
Accentsconagua
MySliceProvider classe, e dovresti vedere il seguente codice generato automaticamente: importazione android.content.ContentResolver importazione android.content.Intent importazione android.net.Uri importazione androidx.slice.Slice importazione androidx.slice.SliceProvider importazione androidx.slice.builders.ListBuilder classe MySliceProvider: SliceProvider () override fun onCreateSliceProvider () : Boolean return true override fun onMapIntentToUri (intent: Intent?): Uri var uriBuilder: Uri.Builder = Uri.Builder (). Scheme (ContentResolver.SCHEME_CONTENT) if (intent == null) restituisce uriBuilder.build () val data = intent.data if (data! = null && data.path! = null) val path = data.path.replace ("/", "") uriBuilder = uriBuilder.path (percorso) val context = contesto if (context! = null) uriBuilder = uriBuilder.authority (context.getPackageName ()) return uriBuilder.build () // Costruisce la slice // override fun onBindSlice (sliceUri: Uri): Slice? val context = getContext ()?: return null return if (sliceUri.path == "/") // Personalizza la Slice // ListBuilder (context, sliceUri) .addRow it.setTitle ("URI found.") .build () else ListBuilder (context, sliceUri) .addRow it.setTitle ("URI non trovato.") .build () // Iscriviti a un'origine dati, se necessario // override fun onSlicePinned (sliceUri: Uri?) // Evita perdite di memoria cancellando l'iscrizione dall'origine dati e rimuovendo eventuali osservatori // override fun onSliceUnpinned (sliceUri: Uri?) Se crei il tuo fornitore di slice usando Nuovo > Altro > Fornitore di fette, quindi Android Studio aggiungerà anche il provider necessario al tuo manifest:
Questa voce garantisce che la tua fetta possa essere scoperta da altre applicazioni.
Finora, abbiamo utilizzato solo il codice generato automaticamente da Android Studio, ma il tuo progetto potrebbe già si rifiuta di compilare!
Insetti, funzionalità mancanti e comportamenti strani a tutto tondo sono solo parte del divertimento di lavorare con le prime versioni. Al momento della scrittura, la generazione di un fornitore di slice a volte aggiungeva inspiegabilmente un nuovo insieme di dipendenze ai progetti build.gradle file.
implementazione 'androidx.slice: slices-core: 1.0.0-alpha1' implementazione 'androidx.slice: slices-builders: 1.0.0-alpha1'
Non solo queste dipendenze non sono necessarie, lo sono sbagliato. Anche se è facile non vedere, confronta:
implementazione 'androidx.slice: slices-core: 1.0.0-alpha3'
Con il corretto:
implementazione 'androidx.slice: slice-core: 1.0.0-alpha1'
Una sola S può significare la differenza tra un'applicazione funzionante e un progetto che rifiuta di compilare. È probabile che questo bug venga risolto prima del rilascio ufficiale delle slice, ma se Android Studio inizia a lamentarsi delle dipendenze irrisolte, controlla il tuo build.gradle file per vedere se questo è accaduto nel tuo progetto.
SliceActions, e Slice LayoutsPer trasformare il codice standard del fornitore di slice in una slice funzionante, dobbiamo apportare diverse modifiche:
Ogni slice ha un URI univoco ed è compito del fornitore della slice fornire il mapping tra questo URI e la slice corrispondente.
Le app che sono in grado di visualizzare una sezione sono conosciute come applicazioni host. Ogni volta che un host deve visualizzare una sezione, invia una richiesta di associazione al provider di slice con l'URI della sezione che sta cercando. Il provider di slice controllerà quindi l'URI e restituirà la slice appropriata.
Nel seguente frammento, il onBindSlice il metodo sta controllando per / myURI percorso e ritorno di una sezione che visualizza a Ciao mondo Messaggio.
class MySliceProvider: SliceProvider () override fun onCreateSliceProvider (): Boolean return true override fun onBindSlice (sliceUri: Uri): Slice? return if (sliceUri.path == "/ myURI") ListBuilder (context, sliceUri, ListBuilder.INFINITY) .addRow it.setTitle ("Hello World") .build () else ...Mentre tu poteva crea una sezione che mostra semplicemente alcune informazioni, se vuoi che la tua fetta sia interattiva, dovrai crearne una o più SliceActions.
UN SliceAction può consistere in un titolo, un'icona e a PendingIntent. Puoi anche segnare SliceActions come azioni primarie, che si attivano ogni volta che l'utente tocca ovunque sulla riga di quel segmento.
Si definisce il layout di una sezione implementando a ListBuilder, aggiungere una riga e quindi aggiungere elementi a quella riga. Ad esempio, qui sto usando ListBuilder e Aggiungi riga per creare una sezione composta da un titolo e un sottotitolo:
importazione android.net.Uri importazione androidx.slice.Slice importazione androidx.slice.SliceProvider importazione androidx.slice.builders.ListBuilder importazione androidx.slice.builders.ListBuilder.INFINITY classe MySliceProvider: SliceProvider () override fun onCreateSliceProvider (): Boolean return true override fun onBindSlice (sliceUri: Uri): Slice? val path = sliceUri.path when (path) "/ launchMainActivity" -> return createSlice (sliceUri) return null fun createSlice (sliceUri: Uri): Slice return ListBuilder (context, sliceUri, INFINITY) .addRow it .apply setTitle ("Questo è un titolo") setSubtitle ("Questo è un sottotitolo") .build ()È possibile visualizzare una combinazione di diversi tipi di contenuto nella stessa riga, ad esempio testo, azioni e icone.
Ora applichiamo tutto questo al nostro progetto e creiamo una sezione che avvia le nostre applicazioni Attività principale quando toccato.
Apri il MySliceProvider classe e aggiungere quanto segue:
importazione android.app.PendingIntent importazione android.content.Intent importazione android.net.Uri importazione androidx.core.graphics.drawable.IconCompat importazione androidx.slice.Slice importazione androidx.slice.SliceProvider importazione androidx.slice.builders.ListBuilder importazione androidx .slice.builders.SliceAction // Estendi dalla classe SliceProvider // MySliceProvider: SliceProvider () // Inizializza il tuo fornitore di slice // override fun onCreateSliceProvider (): Boolean return true // Crea la slice // override fun onBindSlice ( sliceUri: Uri): Slice? // Controlla il percorso URI // val path = sliceUri.path when (path) // Definisci l'URI della slice; Sto usando 'launchMainActivity' // "/ launchMainActivity" -> return createSlice (sliceUri) return null fun createSlice (sliceUri: Uri): Slice val activityAction = createActivityAction () // Crea il ListBuilder, che sarà usa per aggiungere righe alla nostra slice // val listBuilder = ListBuilder (contesto !!, sliceUri, ListBuilder.INFINITY) // Costruisce le righe usando RowBuilder // val rowBuilder = ListBuilder.RowBuilder (listBuilder) // Imposta il testo del titolo // .setTitle ("Apri MainActivity.") // Imposta l'azione principale della riga // .setPrimaryAction (activityAction) // Aggiungi la riga al ListBuilder // listBuilder.addRow (rowBuilder) // Crea l'elenco // restituisci listBuilder.build () fun createActivityAction (): SliceAction val intent = Intent (context, MainActivity :: class.java) return SliceAction (PendingIntent.getActivity (context, 0, intent, 0), IconCompat.createWithResource (context !!, R. drawable.ic_home), "Apri MainActivity")Se hai intenzione di mettere le tue fette al test, allora avrai bisogno di almeno un'applicazione in grado di visualizzare fette.
Secondo quanto riferito, Slices farà il suo debutto nella ricerca di Google entro la fine dell'anno, ma al momento della stesura di questo articolo, questa funzione doveva ancora essere implementata. Attualmente, l'unico modo per testare le fette è installare l'app Slice Viewer di Google, progettata per emulare il modo in cui le fette appariranno alla ricerca di Google.
Per installare Slice Viewer su un dispositivo virtuale Android (AVD):
Per installare Slice Viewer su uno smartphone o tablet fisico:
CD) in modo che il prompt dei comandi o il terminale puntino alla cartella Android / sdk / piattaforma-strumenti, ad esempio, ecco il mio comando:cd / Utenti / jessicathornsby / Libreria / Android / sdk / piattaforma-strumenti
adb install comando per spingere l'APK sul tuo dispositivo Android:./ adb installa slice-viewer.apk
Successivamente, dovrai creare una configurazione di esecuzione che trasmetta l'URI univoco della slice al tuo dispositivo AVD o Android.
La prima volta che Slice Viewer tenta di visualizzare la sezione, richiederà l'autorizzazione per accedere all'URI univoco della slice. Rubinetto permettere e naviga nella finestra delle autorizzazioni e la tua fetta dovrebbe apparire sullo schermo.
Per interagire con il SliceAction, clicca il Apri MainActivity pulsante e la sezione risponderà avviando l'applicazione Attività principale.
SliceAction Perché limitarti a uno SliceAction, quando puoi averlo multiplo SliceActions? In questa sezione, ne implementeremo due SliceActions, dove ogni azione lancia un diverso Attività. Introdurrò anche alcuni nuovi elementi dell'interfaccia utente, aggiungendo un sottotitolo e alcuni articoli finali alla nostra fetta.
Prendiamo la configurazione fuori mano e crea un secondo Attività che il nostro secondo SliceAction può collegarsi a.
Per prima cosa, seleziona Nuovo > Kotlin File / Class dalla barra degli strumenti di Android Studio. Nella finestra di dialogo del nuovo file, apri il Genere menu a discesa e selezionare Classe. Nomina questa classe SecondActivity, e quindi fare clic ok.
Ora apri il tuo SecondActivity classe e aggiungere il seguente:
import androidx.appcompat.app.AppCompatActivity import android.os.Bundle class SecondActivity: AppCompatActivity () override fun onCreate (savedInstanceState: Bundle?) super.onCreate (savedInstanceState) setContentView (R.layout.activity_second)
Quindi, selezionare Nuovo > File di risorse Android dalla barra degli strumenti di Android Studio. Nella finestra successiva, apri il Tipo di risorsa menu a discesa e selezionare disposizione. Dai un nome a questo file activity_second, e fare clic ok.
Ora apri questo file di layout e aggiungi il seguente codice:
http://schemas.android.com/apk/res/android "xmlns: app =" http://schemas.android.com/apk/res-auto "xmlns: tools =" http://schemas.android. com / tools "android: layout_width =" match_parent "android: layout_height =" match_parent "tools: context =". MainActivity ">
Apri il Manifesto del tuo progetto e dichiara questo SecondActivity:
Gli elementi finali possono essere un timestamp, un'immagine o un SliceAction, ma come suggerisce il nome, appaiono sempre alla fine di una riga. Puoi aggiungere più elementi finali a una singola riga, anche se, a seconda dello spazio disponibile, non è garantito che tutti gli elementi finali verranno visualizzati all'utente.
Creeremo il nostro SliceActions come icone, quindi dovrai aggiungere due nuovi drawable al tuo progetto:
Ripeti i passaggi precedenti per creare un'icona per il tuo Avvia SecondActivity fetta d'azione. Per il mio secondo articolo di fine, sto usando il chiamata icona e nominandolo ic_call.
Siamo ora pronti per aggiungere un secondo SliceAction al MySliceProvider classe:
importazione android.app.PendingIntent importazione android.content.Intent importazione android.net.Uri importazione androidx.core.graphics.drawable.IconCompat importazione androidx.slice.Slice importazione androidx.slice.SliceProvider importazione androidx.slice.builders.ListBuilder importazione androidx .slice.builders.SliceAction class MySliceProvider: SliceProvider () override fun onCreateSliceProvider (): Boolean return true override fun onBindSlice (sliceUri: Uri): Slice? val path = sliceUri.path when (path) "/ launchMainActivity" -> return createSlice (sliceUri) return null fun createSlice (sliceUri: Uri): Slice val activityAction = createActivityAction () IconCompat.createWithResource (context !! , R.drawable.ic_home) .toIcon () val activityAction2 = createSecondActivityAction () IconCompat.createWithResource (contesto !!, R.drawable.ic_call) .toIcon () // Costruisce il generatore genitore // val listBuilder = ListBuilder (context! !, sliceUri) // Costruisce il builder per la riga // val myRow = ListBuilder.RowBuilder (listBuilder) .setTitle ("Avvia MainActivity.") .setSubtitle ("Questo è un sottotitolo") // Aggiungi le azioni che noi Verrà utilizzato come articoli finali // myRow.addEndItem (activityAction) myRow.addEndItem (activityAction2) // Aggiungi la riga al generatore genitore // listBuilder.addRow (myRow) // Costruisci la slice // restituisci listBuilder.build () fun createActivityAction (): SliceAction val intent = Intent (context, MainActivity :: class.java) return SliceAction (PendingIntent.getActivity ( context, 0, intent, 0), IconCompat.createWithResource (context !!, R.drawable.ic_home) .toIcon (), "Launch MainActivity") fun createSecondActivityAction (): SliceAction val intent = Intent (context, SecondActivity: : class.java) return SliceAction (PendingIntent.getActivity (context, 0, intent, 0), IconCompat.createWithResource (contesto !!, R.drawable.ic_call) .toIcon (), "Launch SecondActivity")Poiché non abbiamo modificato l'URI, non è necessario creare una nuova configurazione di esecuzione, il che significa che testare questa sezione è semplice come selezionare Correre > sliceConfig dalla barra degli strumenti di Android Studio.
Puoi scaricare questo progetto dal tutorial repo di GitHub.
Fino a questo punto, abbiamo costruito tutti i nostri segmenti usando solo le righe, ma puoi anche creare sezioni usando griglia righe e celle.
In questa sezione finale, creeremo una sezione composta da un titolo, un sottotitolo e una singola riga divisa in tre celle. Ogni cella avrà il suo titolo, un corpo del testo e un'immagine, e ognuno eseguirà un'azione unica quando viene toccato.
Per disporre la tua fetta in una griglia, devi:
ListBuilder.ListBuilder, utilizzando addGridRow. addCell. Ogni riga può visualizzare un massimo di cinque celle.È quindi possibile aggiungere contenuto a ogni cella, ad esempio:
addTitleText.Aggiungi testo.Aggiungi immagine. Ogni immagine di cella deve avere uno dei seguenti attributi: LARGE_IMAGE, small_image, o ICON_IMAGE. SliceAction. Per mantenere questo esempio semplice, toccando ogni cella verrà semplicemente caricato un articolo nel browser predefinito del dispositivo, ma se preferisci un'esperienza con fette più autentiche, puoi modificare setContentIntent codice. Inserirò alcune immagini nella mia griglia, quindi dovrai aggiungere almeno un disegno al tuo progetto. Sto usando il logo Kotlin, ma puoi prendere qualsiasi immagine e inserirla nel progetto drawable cartella.
Ora sei pronto per aprire il MySliceProvider classe e crea la tua griglia:
importazione android.app.PendingIntent importazione android.content.Context importazione android.content.Intent importazione android.net.Uri importazione androidx.core.graphics.drawable.IconCompat importazione androidx.slice.Slice importazione androidx.slice.SliceProvider importazione androidx.slice .builders.ListBuilder class MySliceProvider: SliceProvider () override fun onCreateSliceProvider (): Boolean return true override fun onBindSlice (sliceUri: Uri): Slice? val path = sliceUri.path when (path) "/ launchMainActivity" -> return createSliceWithGridRow (sliceUri) return null fun createSliceWithGridRow (sliceUri: Uri): Slice return ListBuilder (context, sliceUri, ListBuilder.INFINITY) .setHeader it.apply setTitle ("Vuoi iniziare a imparare Kotlin per Android?") setSubtitle ("Dai un'occhiata a questi articoli!") // Aggiungi una riga di griglia al generatore di liste // .addGridRow it.apply / / Aggiungi una cella alla riga // addCell it.apply // Aggiungi contenuto alla tua cella // addTitleText ("Java vs. Kotlin") addText ("Parte 1") addImage (IconCompat.createWithResource (context, R. drawable.kotlin), ListBuilder.LARGE_IMAGE) // Specifica l'intento che deve essere attivato ogni volta che l'utente interagisce con questa cella // .setContentIntent (loadArticlePendingIntent (context, "https://code.tutsplus.com/articles/java-vs- kotlin-should-you-be-using-kotlin-per-android-sviluppo ...) addCell it.apply addTitleText ("Coding in Kotlin") addText ("Parte 2") addImage (IconCompat.createWithResourc e (context, R.drawable.kotlin), ListBuilder.LARGE_IMAGE) .setContentIntent (loadArticlePendingIntent (context, "https://code.tutsplus.com/tutorials/start-developing-android-apps-with-kotlin-part-1 --cms-27827? _ga = ...) addCell it.apply addTitleText ("Lambdas & NPE") addText ("Parte 3") addImage (IconCompat.createWithResource (context, R.drawable.kotlin), ListBuilder. LARGE_IMAGE) .setContentIntent (loadArticlePendingIntent (context, "https://code.tutsplus.com/articles/coding-functional-android-apps-in-kotlin-lambdas-null-safety-more...) .build ( ) fun fun loadArticlePendingIntent (context: Context, url: String) = PendingIntent.getActivity (context, 0, Intent (Intent.ACTION_VIEW) .apply data = Uri.parse (url), 0)Puoi trovare il codice completo per questo progetto nel nostro repository GitHub.
Esegui questa app nell'AVD o dispositivo fisico Android e prova a interagire con ogni elemento della griglia. Ogni cella dovrebbe essere collegata a un articolo diverso.
Il modo in cui viene visualizzato il contenuto della tua fetta può variare, a seconda del modalità l'applicazione host è configurata per. Per assicurarti che le tue fette abbiano un bell'aspetto e funzionino correttamente, indipendentemente dall'applicazione di hosting, dovrai testare le sezioni su tutte le diverse modalità di sezione.
Dato che la nostra fetta di griglia ha un contenuto significativamente maggiore rispetto alle fette precedenti, è il miglior candidato per illustrare le differenze tra queste varie modalità di sezione.
Per mettere alla prova la tua fetta, fai clic sulla piccola icona nell'angolo in alto a destra del Slice Viewer, quindi passa in rassegna le seguenti modalità:
In questo formato, Android visualizza il maggior numero possibile di righe nello spazio disponibile. Questa è la modalità che Slice Viewer utilizza per impostazione predefinita.
In questa modalità, la tua fetta è rappresentata da un'icona e un'etichetta.
Se c'è un'intestazione primaria associata al tuo SliceAction, allora questo sarà usato come icona della tua fetta. Se non è disponibile un'icona, Android mostrerà invece l'azione principale associata alla prima riga della tua fetta, che in questo caso è il nostro Kotlin drawable.
Per cambiare l'icona visualizzata nella modalità di scelta rapida, aggiungi un secondo drawable al tuo progetto, quindi aggiorna la seguente sezione del fornitore di slice:
.addGridRow it.apply addCell it.apply addTitleText ("Java vs. Kotlin") addText ("Parte 1") // Riferimento al nuovo drawable // addImage (IconCompat.createWithResource (context, R.drawable.androidlogo) , ListBuilder.LARGE_IMAGE)La modalità piccola ha un'altezza limitata e visualizzerà un singolo SliceItem o una raccolta limitata di elementi come una singola riga di contenuti. Se la tua fetta ha un'intestazione, questa verrà visualizzata, che è esattamente ciò che sta accadendo con la nostra fetta.
La modifica del titolo o del sottotitolo influisce sul contenuto visualizzato in modalità ridotta.
fun createSliceWithGridRow (sliceUri: Uri): Slice return ListBuilder (context, sliceUri, ListBuilder.INFINITY) .setHeader it.apply setTitle ("Questo è il titolo") setSubtitle ("Questo è il sottotitolo")Se la tua fetta non contiene un'intestazione, verrà invece visualizzata la prima riga della sezione.
Una volta che hai imparato come implementare una nuova funzionalità, il prossimo passo è imparare come fornire gli stessi risultati, con meno codice!
Android KTX è una raccolta di moduli composta da estensioni che ottimizzano la piattaforma Android per Kotlin. Il modulo KTX di Slice Builders di Android KTX racchiude il pattern di builder in un DSL compatibile con Kotlin che ti aiuta a creare le tue fette in un modo più conciso e leggibile. Per iniziare con Slice Builders KTX, sostituire la seguente dipendenza:
implementazione 'androidx.slice: slice-builders: 1.0.0-alpha3'
Con:
implementazione 'androidx.slice: slice-builders-ktx: 1.0.0-alpha3'
Puoi quindi modificare il tuo createSlice metodo per usare questo DSL. Ad esempio, ecco una semplice sezione che mostra un titolo e un sottotitolo:
importazione android.net.Uri importazione androidx.slice.Slice importazione androidx.slice.Sli
