Codificar Su Primer Android Slice y Mantener los Usuarios Comprometidos

El trabajo no terminado sólo porque su aplicación ha acumulado un montón de descargas y revisiones positivas en la tienda de Google Play. El usuario móvil típico cuenta con decenas de aplicaciones instaladas en su dispositivo, y con nuevas aplicaciones liberadas todo el tiempo, tendrá que trabajar duro para mantener el interés de su audiencia!

Mantener a los usuarios volver a su aplicación es crucial para crear un usuario estable y leal base. Además, si has monetizan su aplicación, entonces la cantidad de tiempo que gastan en su aplicación directamente afecta a cuánto dinero usted hace, pensar cada segundo adicional como otra oportunidad para mostrar un anuncio o tentar al usuario a salpicar hacia fuera en una compra en aplicación !

En la entrada-salida de este año, Google introdujo slices, una nueva característica que promete a los usuarios de la unidad de su aplicación consiguiendo características de su aplicación y contenido frente a ellos en el momento exacto cuando son necesarias más.

Con láminas que será una herramienta importante para conservar su audiencia, ahora es el momento perfecto para obtener cierta experiencia práctica con esta emergente característica de Android. Al final de este artículo, habrá creado una gama de sectores, desde una simple división que inicia una actividad cuando golpeada a través a rodajas más complejas que consiste de iconos, imágenes, redes y múltiples SliceActions.

Sectores: Más Maneras Para Que los Usuarios Disfrutar de Su Aplicación

Similares a los widgets, rebanadas son fragmentos de contenido que aparecen fuera del contexto de aplicación, aumentar la visibilidad de la aplicación y le proporciona más oportunidades para atraer a su público.

Sectores tienen el potencial para aumentar considerablemente la visibilidad de la aplicación, Google promete añadir soporte para láminas para las áreas donde muchos usuarios Android pasan cantidades significativas de tiempo, incluyendo el Asistente de Google y Google search. Ya que son parte de Android Jetpack, rebanadas son compatibles con Android 4.4 más alto, que significa que sus rodajas tienen el potencial para alcanzar el 95% de todos los usuarios de Android.

Para Slices tienen mucho que ofrecer, pero ¿cómo funcionan?

En la actualidad, si se realiza una búsqueda en Google app Google podría sugerir una aplicación relevante que está instalada en su dispositivo. Por ejemplo, si has instalado Facebook para el móvil, escribe facebook aparecerá un enlace directo a la aplicación de Facebook.

Rebanadas de toman esta a un paso más, centrándose en tareas específicas que el usuario puede realizar dentro de las aplicaciones que ya han instalado la aplicación.

Veamos un ejemplo: Imagina que has instalado una aplicación de libro un Hotel que te permite buscar un hotel y reservar una habitación. Cuando escribes Hoteles de Londres en Google, puedes encontrar los resultados de búsqueda habitual, además de una rebanada de la aplicación de libro A Hotel. Este recomienda un hotel en Londres y muestra información como el nombre del hotel y dirección, además de un SliceAction, en la forma de un botón que le permite Reserva una habitación directamente desde la interfaz de usuario de slice (IU).

Para el usuario, este sector ha proporcionado acceso fácil a la información y las características que necesitaban en ese momento. Para el desarrollador, este sector les ha permitido conseguir su aplicación frente a un usuario en el punto exacto cuando se presentaban la mayor probabilidad de éxito volver a participar.

¿Cómo Crear Mi Primera Slice?

Vamos a empezar por crear una simple rebanada que, aprovechado, pondrá en marcha MainActivity de la aplicación.

Esta técnica sencilla permite iniciar cualquier tarea, directamente desde la interfaz de usuario de la división. En nuestro ejemplo del libro A Hotel, podríamos sólo enlazamos el botón a BookRoomActivity de app relacionados con, que sería una forma sencilla pero eficaz para reducir el número de pantallas que el usuario tiene que navegar para completar esta tarea.

Para empezar, cree un nuevo proyecto Android. Usted puede usar cualquier configuración que quiera, pero asegúrese de que selecciona el Kotlin incluyen ayuda casilla de verificación cuando se le solicite.

Una vez que has creado tu proyecto, abra su archivo build.gradle y añadir las dependencias de la base de slice-core y slice-builder:

1

dependencies {

2

   implementation 'androidx.appcompat:appcompat:1.0.0-alpha3'

3

   implementation 'androidx.slice:slice-core:1.0.0-alpha3'

4

   implementation 'androidx.slice:slice-builders:1.0.0-alpha3'

5

   implementation 'androidx.constraintlayout:constraintlayout:1.1.0'

6

   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"

7

}

Mostrando Su Aplicación Contenido en la Búsqueda de Google, Con los Proveedores del Sector

A continuación, necesitamos crear un proveedor de slice, que es el componente responsable de mostrar el contenido de su aplicación fuera del contexto de aplicación.

Crear un proveedor de rodaja con plantilla de proveedor de Studio Android slice:

• Seleccione Nuevo > Otros > proveedor de Slice de la barra de herramientas de estudio Android.
• Escriba el nombre MySliceProvider.
• Configurar el Idioma de origen a Kotlin.
• Haga clic en Finalizar.
• Abrir la clase MySliceProvider, y usted debería ver el siguiente código generado automáticamente:

1

import android.content.ContentResolver

2

import android.content.Intent

3

import android.net.Uri

4

import androidx.slice.Slice

5

import androidx.slice.SliceProvider

6

import androidx.slice.builders.ListBuilder

7

8

class MySliceProvider : SliceProvider() {

9

10

  override fun onCreateSliceProvider(): Boolean {

11

      return true

12

  }

13

14

  override fun onMapIntentToUri(intent: Intent?): Uri {

15

16

      var uriBuilder: Uri.Builder = Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT)

17

      if (intent == null) return uriBuilder.build()

18

      val data = intent.data

19

      if (data != null && data.path != null) {

20

          val path = data.path.replace("/", "")

21

          uriBuilder = uriBuilder.path(path)

22

      }

23

      val context = context

24

      if (context != null) {

25

          uriBuilder = uriBuilder.authority(context.getPackageName())

26

      }

27

      return uriBuilder.build()

28

  }

29

30

//Construct the slice//

31

32

  override fun onBindSlice(sliceUri: Uri): Slice? {

33

      val context = getContext() ?: return null

34

      return if (sliceUri.path == "/") {

35

36

//Customise the Slice//

37

38

          ListBuilder(context, sliceUri)

39

                  .addRow { it.setTitle("URI found.") }

40

                  .build()

41

      } else {

42

43

          ListBuilder(context, sliceUri)

44

                  .addRow { it.setTitle("URI not found.") }

45

                  .build()

46

      }

47

  }

48

49

//Subscribe to a data source, if necessary//

50

51

  override fun onSlicePinned(sliceUri: Uri?) {

52

53

  }

54

55

//Avoid memory leaks by unsubscribing from the data source and removing any observers//

56

57

  override fun onSliceUnpinned(sliceUri: Uri?) {

58

  }

59

}

Si crea su proveedor de rodaja con Nueva > Otros > Proveedor de Slice, luego Android Studio también añadirá el proveedor necesario a su manifiesto:

1

 <provider

2

       android:name=".MySliceProvider"

3

       android:authorities="com.jessicathornsby.kotlinslices"

4

       android:exported="true">

5

       <intent-filter>

6

           <action android:name="android.intent.action.VIEW" />

7

8

           <category android:name="android.app.slice.category.SLICE" />

9

10

           <data

11

               android:host="jessicathornsby.com"

12

               android:pathPrefix="/"

13

               android:scheme="http" />

14

       </intent-filter>

15

   </provider>

16

</application>

Esta entrada se asegura que su sector se puede descubrir por otras aplicaciones.

¿Ha Fallado la Sincronización de Gradle Proyecto?

Hasta ahora, sólo hemos utilizado código que estudio Android ha generado automáticamente, pero el proyecto ya puede ser negarse a compilar!

Errores, falta de funcionalidad y un comportamiento extraño son sólo una parte de la diversión de trabajar con las primeras versiones. En el momento de la escritura, generar un proveedor de rodaja a veces inexplicablemente añadiría un nuevo conjunto de dependencias para el archivo del proyecto build.gradle.

1

implementation 'androidx.slice:slices-core:1.0.0-alpha1'

2

implementation 'androidx.slice:slices-builders:1.0.0-alpha1'

No sólo son estas dependencias innecesarias, que están mal. Aunque es fácil perder, comparar:

1

implementation 'androidx.slice:slices-core:1.0.0-alpha3'

Con el correcto:

1

implementation 'androidx.slice:slice-core:1.0.0-alpha1'

Un solo s puede significar la diferencia entre una aplicación de funcionamiento y un proyecto que se niega a compilar. Lo más probable es que este fallo se abordarán antes del lanzamiento oficial de rebanadas, pero si estudio Android comienza a quejarse de dependencias no resueltas luego archivo build.gradle para ver si esto ha sucedido en su proyecto.

Construir un Slice: URIs, SliceActions y Diseño Slice

Para convertir código de modelo de proveedor de rodaja en un sector de funcionamiento, tenemos que hacer varios cambios:

1. Definir una URI

Cada rebanada tiene una URI única, y es trabajo del proveedor de rodaja para proporcionar la asignación entre este URI y el segmento correspondiente.

Aplicaciones que son capaces de mostrar una rebanada se conocen como aplicaciones de host. Cada vez que un huésped necesita mostrar una rebanada, envía una solicitud de enlace al proveedor de rodaja con el URI de la rebanada que está buscando. Su proveedor de rodaja luego Compruebe el identificador URI y devolver el segmento apropiado.

En el siguiente fragmento de código, el método onBindSlice es comprobando la ruta /myURI y regresar a un sector que muestra un mensaje Hola Mundo.

1

class MySliceProvider : SliceProvider() {

2

3

   override fun onCreateSliceProvider(): Boolean {

4

       return true

5

   }

6

7

   override fun onBindSlice(sliceUri: Uri): Slice? {

8

       return if (sliceUri.path == "/myURI") {

9

           ListBuilder(context, sliceUri, ListBuilder.INFINITY)

10

                   .addRow { it.setTitle("Hello World") }

11

                   .build()

12

       } else {

13

...

14

...

15

...

16

       }

17

   }

18

}

2. Hacer Su Slice Interactiva

Mientras que se puede crear un segmento que simplemente muestra algo de información, si usted quiere su rebanada a ser interactiva entonces usted necesitará crear uno o más SliceActions.

Un SliceAction puede consistir en un título, un icono y un PendingIntent. También puede marcar SliceActions como acciones primarias, que se activan cuando el usuario golpea en cualquier lugar en la fila de la división.

3. Construir la UI de Slice

Definir diseño de slice implementar un ListBuilder, añadiendo una fila, y luego agregar elementos a esa fila. Por ejemplo, aquí estoy utilizando ListBuilder y addRow para crear un segmento que consta de un título y un subtítulo:

1

import android.net.Uri

2

import androidx.slice.Slice

3

import androidx.slice.SliceProvider

4

import androidx.slice.builders.ListBuilder

5

import androidx.slice.builders.ListBuilder.INFINITY

6

7

class MySliceProvider : SliceProvider() {

8

9

   override fun onCreateSliceProvider(): Boolean {

10

11

       return true

12

   }

13

14

   override fun onBindSlice(sliceUri: Uri): Slice? {

15

       val path = sliceUri.path

16

       when (path) {

17

           "/launchMainActivity" -> return createSlice(sliceUri)

18

       }

19

       return null

20

   }

21

22

   fun createSlice(sliceUri: Uri): Slice {

23

       return ListBuilder(context, sliceUri, INFINITY)

24

               .addRow {

25

                   it.apply {

26

                       setTitle("This is a title")

27

                       setSubtitle("This is a subtitle")

28

29

                   }

30

               }.build()

31

   }

32

33

}

Puede mostrar una mezcla de distintos tipos de contenidos en la misma fila, como los iconos, texto y acciones.

Construir Su Primera Slice Android Completamente Funcional

Ahora vamos a aplicar todo esto a nuestro proyecto y crear un segmento que lanza MainActivity nuestra aplicación cuando aprovechado.

Abra la clase MySliceProvider y agregar lo siguiente:

1

import android.app.PendingIntent

2

import android.content.Intent

3

import android.net.Uri

4

import androidx.core.graphics.drawable.IconCompat

5

import androidx.slice.Slice

6

import androidx.slice.SliceProvider

7

import androidx.slice.builders.ListBuilder

8

import androidx.slice.builders.SliceAction

9

10

//Extend from SliceProvider//

11

12

class MySliceProvider : SliceProvider() {

13

14

//Initialise your slice provider//

15

16

  override fun onCreateSliceProvider(): Boolean {

17

      return true

18

  }

19

20

//Build the slice//

21

22

  override fun onBindSlice(sliceUri: Uri): Slice? {

23

24

//Check the URI path//

25

26

      val path = sliceUri.path

27

      when (path) {

28

29

//Define the slice’s URI; I’m using ‘launchMainActivity’//

30

31

          "/launchMainActivity" -> return createSlice(sliceUri)

32

      }

33

      return null

34

  }

35

36

  fun createSlice(sliceUri: Uri): Slice {

37

      val activityAction = createActivityAction()

38

39

//Create the ListBuilder, which we’ll use to add rows to our slice//

40

41

      val listBuilder = ListBuilder(context!!, sliceUri, ListBuilder.INFINITY)

42

43

//Construct the rows using RowBuilder//

44

45

      val rowBuilder = ListBuilder.RowBuilder(listBuilder)

46

47

//Set the title text//

48

49

              .setTitle("Open MainActivity.")

50

51

//Set the row’s primary action//

52

53

              .setPrimaryAction(activityAction)

54

55

//Add the row to the ListBuilder//

56

57

      listBuilder.addRow(rowBuilder)

58

59

//Build the list//

60

61

      return listBuilder.build()

62

63

  }

64

65

  fun createActivityAction(): SliceAction {

66

      val intent = Intent(context, MainActivity::class.java)

67

      return SliceAction(PendingIntent.getActivity(context, 0, intent, 0),

68

              IconCompat.createWithResource(context!!, R.drawable.ic_home),

69

              "Open MainActivity")

70

  }

71

72

}

Prueba Tus Slices: Instalar un Visor de Slice

Si vas a poner tus rebanadas a la prueba, entonces necesitarás al menos una aplicación que es capaz de mostrar rebanadas.

Rebanadas al parecer hará su debut en Google buscar finales de este año, pero en el momento de la escritura, esta función aún no había rodado hacia fuera. Actualmente, la única manera de probar rodajas es instalar aplicación de visor de rebanada de Google, que está diseñada para emular cómo rebanadas finalmente aparecerá en la búsqueda de Google.

Instalar Visor de Slice en un Dispositivo Virtual Android (AVD):

• Descargar Aplicación de Google Slice Viewer.
• Asegúrese de que su AVD ya está en marcha.
• Buscar el archivo APK de visor de rebanada y arrastre y suelte en la AVD.

Instalar Visor de Slice en un físico smartphone o tablet:

• Descargar Slice Viewer.
• Asegúrese de que su teléfono inteligente o tablet está conectado a tu máquina de desarrollo.
• Mover la rebanada visor de APK a la carpeta de Android/sdk/platform-tools del ordenador.
• Abra un Símbolo del Sistema (Windows) o la Ventana de Terminal (Mac).
• Cambie el directorio (cd) para que el indicador de comandos o Terminal está apuntando a la carpeta Android/sdk/plataforma-herramientas, por ejemplo, este es mi mandamiento:

1

cd /Users/jessicathornsby/Library/Android/sdk/platform-tools

• Ejecute el comando, pulsando la tecla Enter en su teclado.
• Uso del adb install comando para empujar el APK a tu dispositivo Android:

1

./adb install slice-viewer.apk

Crear una Configuración de Ejecución de URI

A continuación, debe crear una configuración de ejecución que pasa URI único de la división a su dispositivo AVD o Android.

• Seleccione Ejecutar > Editar Configuraciones... desde la barra de herramientas de estudio Android.
• Haga clic + botón y a continuación, seleccione Aplicación para Android.

• Dar la configuración de ejecución un nombre. Estoy usando sliceConfig.
• Abrir el menú desplegable del Módulo y seleccione la Aplicación.
• Abrir el menú desplegable de Lanzamiento y luego seleccione URL.
• Ingrese URL de la división, en el formato slice-content://package-name/slice-URL. Por ejemplo, es la URL de mi slice: slice-content://com.jessicathornsby.kotlinslices/launchMainActivity.
• Haga clic en Aceptar.
• Seleccione Ejecutar > Ejecutar sliceConfig desde la barra de herramientas de Studio Android y luego seleccionar tu dispositivo Android.

Primera vez que rebanada espectador intenta mostrar su rebanada, te solicita permiso a URI único de su segmento. Pulse Permitir y navegar el diálogo de los permisos, y su rebanada debe aparecer en pantalla.

Para interactuar con el SliceAction, clic en el botón Open MainActivity y responderá a la rebanada con el lanzamiento MainActivity de su aplicación.

Cada Vez Más Fuera de Sus Slices: Adición de un Segundo SliceAction

¿Por qué limitarte a una SliceAction, cuando usted puede tener múltiples SliceActions? En esta sección, vamos a implementar dos SliceActions, donde cada acción lanza una Actividad diferente. También voy a introducir algunos elementos de interfaz de usuario nueva, añadiendo subtítulos y algunos elementos finales a nuestro sector.

Crear un SecondActivity

Vamos a la configuración del camino y crear una segunda Actividad que nuestro segundo SliceAction puede enlazar a.

En primer lugar, seleccione Nuevo > Archivo de Kotlin / Clase de la barra de herramientas de estudio Android. En el cuadro de diálogo nuevo archivo, abrir el menú de Tipo desplegable y seleccione Clase. Nombre de esta clase SecondActivity y haga clic en Aceptar.

Ahora abra la clase SecondActivity y agregar lo siguiente:

1

import androidx.appcompat.app.AppCompatActivity

2

import android.os.Bundle

3

4

class SecondActivity : AppCompatActivity() {

5

   override fun onCreate(savedInstanceState: Bundle?) {

6

       super.onCreate(savedInstanceState)

7

       setContentView(R.layout.activity_second)

8

   }

9

}

A continuación, seleccione Nuevo > Archivo de Recursos de Android desde la barra de herramientas de estudio Android. En la ventana posterior, abra la lista desplegable de Tipo de Recurso y seleccione Diseño. Nombre este archivo activity_second y haga clic en Aceptar.

Ahora abrir este archivo diseño y agregue el código siguiente:

1

<?xml version="1.0" encoding="utf-8"?>

2

https://schemas.android.com/apk/res/android"

3

   xmlns:app="http://schemas.android.com/apk/res-auto"

4

   xmlns:tools="http://schemas.android.com/tools"

5

   android:layout_width="match_parent"

6

   android:layout_height="match_parent"

7

   tools:context=".MainActivity">

8

9

   <TextView

10

       android:layout_width="wrap_content"

11

       android:layout_height="wrap_content"

12

       android:text="Second Activity"

13

       app:layout_constraintBottom_toBottomOf="parent"

14

       app:layout_constraintLeft_toLeftOf="parent"

15

       app:layout_constraintRight_toRightOf="parent"

16

       app:layout_constraintTop_toTopOf="parent" />

17

18

</androidx.constraintlayout.widget.ConstraintLayout>

Abrir manifiesto de su proyecto y declarar este SecondActivity:

1

<activity android:name=".SecondActivity">

Creación de Interfaces Más Complejas: Slice Elementos Finales

Elementos finales pueden ser una marca de tiempo, una imagen o un SliceAction, pero como su nombre indica, siempre aparecen al final de una fila. Puede Agregar múltiples elementos finales a una sola fila, aunque dependiendo del espacio disponible no es posible garantizar que todos sus elementos finales se mostrará al usuario.

Nos va creando nuestra SliceActions como los iconos, así que necesitarás añadir dos nuevo dibujo a su proyecto:

• Seleccione Nuevo > Activo de Imagen de la barra de herramientas de estudio Android.
• Haga clic en el pequeño botón de Arte Clip (esto muestra una imagen de un Android por defecto).
• Seleccione el icono que desea utilizar para el elemento final de Lanzar MainActivity. Estoy usando el icono de Inicio.
• Dar a este icono de la ic_home nombre y haga clic en Siguiente.
• Lea la información en pantalla y si eres feliz proceder a continuación haga clic en Finalizar.

Repita los pasos anteriores para crear un icono para su acción de Slice de Lanzar SecondActivity. Para mi segundo punto de la final, estoy usando el icono de call y nombrarlo ic_call.

Creación de la Segunda SliceAction

Ahora estamos listos para añadir un segundo SliceAction a la clase MySliceProvider:

1

import android.app.PendingIntent

2

import android.content.Intent

3

import android.net.Uri

4

import androidx.core.graphics.drawable.IconCompat

5

import androidx.slice.Slice

6

import androidx.slice.SliceProvider

7

import androidx.slice.builders.ListBuilder

8

import androidx.slice.builders.SliceAction

9

10

class MySliceProvider : SliceProvider() {

11

12

  override fun onCreateSliceProvider(): Boolean {

13

      return true

14

  }

15

16

  override fun onBindSlice(sliceUri: Uri): Slice? {

17

      val path = sliceUri.path

18

      when (path) {

19

          "/launchMainActivity" -> return createSlice(sliceUri)

20

      }

21

      return null

22

  }

23

24

  fun createSlice(sliceUri: Uri): Slice {

25

      val activityAction = createActivityAction()

26

      IconCompat.createWithResource(context!!, R.drawable.ic_home).toIcon()

27

      val activityAction2 = createSecondActivityAction()

28

      IconCompat.createWithResource(context!!, R.drawable.ic_call).toIcon()

29

30

//Construct the parent builder//

31

32

          val listBuilder = ListBuilder(context!!, sliceUri)

33

34

//Construct the builder for the row//

35

36

          val myRow = ListBuilder.RowBuilder(listBuilder)

37

                  .setTitle("Launch MainActivity.")

38

                  .setSubtitle("This is a subtitle")

39

40

//Add the actions that we'll be using as end items//

41

42

          myRow.addEndItem(activityAction)

43

          myRow.addEndItem(activityAction2)

44

45

 //Add the row to the parent builder//

46

47

          listBuilder.addRow(myRow)

48

49

//Build the slice//

50

51

          return listBuilder.build()

52

      }

53

54

  fun createActivityAction(): SliceAction {

55

      val intent = Intent(context, MainActivity::class.java)

56

              return SliceAction(PendingIntent.getActivity(context, 0, intent, 0),

57

                      IconCompat.createWithResource(context!!, R.drawable.ic_home).toIcon(),

58

                      "Launch MainActivity")

59

  }

60

61

  fun createSecondActivityAction(): SliceAction {

62

      val intent = Intent(context, SecondActivity::class.java)

63

      return SliceAction(PendingIntent.getActivity(context, 0, intent, 0),

64

              IconCompat.createWithResource(context!!, R.drawable.ic_call).toIcon(),

65

              "Launch SecondActivity")

66

  }

67

68

}

Puesto que no hemos cambiado el URI, no necesitamos crear una nueva configuración de ejecución, lo que prueba esta rebanada es tan simple como seleccionar Run > sliceConfig de la barra de herramientas de estudio Android.

Puede descargar este proyecto desde el repositorio de GitHub del tutorial.

Slice de Multimedias: Creación de Diseños de Red

Hasta este punto, hemos construido todos nuestros sectores utilizando sólo las filas, pero también puede crear slices utilizando celdas y filas de cuadrícula.

En esta sección final, vamos a crear un segmento que consta de un título, un subtítulo y una sola fila dividida en tres células. Cada celda tendrá su propio título, un texto y una imagen, y cada uno realizará una acción única cuando aprovechado.

Para disponer su rebanada en una cuadrícula, es necesario:

• Implementar un ListBuilder.
• Agregar una fila de la cuadrícula a ListBuilder, usando addGridRow.
• Agregar celdas a la fila, utilizando addCell. Cada fila puede mostrar un máximo de cinco celdas.

Puede entonces agregar contenido a cada célula, tales como:

• Un título, que se agrega mediante addTitleText.
• Cuerpo del texto, utilizando addText.
• Imágenes, que se crean mediante addImage. Cada imagen de la célula debe tener uno de los siguientes atributos: LARGE_IMAGE, SMALL_IMAGE o ICON_IMAGE.
• Una intención de contenido, que es aproximadamente equivalente a un SliceAction. Para evitar que este ejemplo sencillo, aprovechando cada célula se carga simplemente un artículo en el navegador por defecto de los dispositivos, pero si usted prefiere una experiencia más auténtica de sectores puede cambiar el código de setContentIntent.

Voy a incluir algunas imágenes en mi red, así que necesitarás agregar al menos un dibujable a su proyecto. Estoy usando el logo de Kotlin, pero puede tomar cualquier imagen y colocar en la carpeta Drawable de su proyecto.

Ahora, usted está listo para abrir la clase MySliceProvider y construir tu red:

1

import android.app.PendingIntent

2

import android.content.Context

3

import android.content.Intent

4

import android.net.Uri

5

import androidx.core.graphics.drawable.IconCompat

6

import androidx.slice.Slice

7

import androidx.slice.SliceProvider

8

import androidx.slice.builders.ListBuilder

9

10

class MySliceProvider : SliceProvider() {

11

12

    override fun onCreateSliceProvider(): Boolean {

13

        return true

14

    }

15

16

    override fun onBindSlice(sliceUri: Uri): Slice? {

17

        val path = sliceUri.path

18

        when (path) {

19

            "/launchMainActivity" -> return createSliceWithGridRow(sliceUri)

20

        }

21

        return null

22

    }

23

24

    fun createSliceWithGridRow(sliceUri: Uri): Slice {

25

        return ListBuilder(context, sliceUri, ListBuilder.INFINITY)

26

                .setHeader {

27

                    it.apply {

28

                        setTitle("Want to start learning Kotlin for Android?")

29

                        setSubtitle("Check out these articles!")

30

                    }

31

                }

32

33

//Add a grid row to the list builder//

34

35

                .addGridRow {

36

                    it.apply {

37

38

//Add a cell to the row//

39

40

                        addCell {

41

                            it.apply {

42

43

//Add content to your cell//

44

45

                                addTitleText("Java vs. Kotlin")

46

                                addText("Part 1")

47

                                addImage(IconCompat.createWithResource(context, R.drawable.kotlin), ListBuilder.LARGE_IMAGE)

48

49

//Specify the intent that should trigger whenever the user interacts with this cell//  

50

51

52

                                        .setContentIntent(

53

                                                loadArticlePendingIntent(

54

                                                        context,

55

                                                        "https://code.tutsplus.com/articles/java-vs-kotlin-should-you-be-using-kotlin-for-android-development...)

56

                            }

57

                        }

58

                        addCell {

59

                            it.apply {

60

                                addTitleText("Coding in Kotlin")

61

                                addText("Part 2")

62

                                addImage(IconCompat.createWithResource(context, R.drawable.kotlin), ListBuilder.LARGE_IMAGE)

63

                                        .setContentIntent(

64

                                                loadArticlePendingIntent(

65

                                                        context,

66

                                                        "https://code.tutsplus.com/tutorials/start-developing-android-apps-with-kotlin-part-1--cms-27827?_ga=...)

67

                            }

68

                        }

69

70

                        addCell {

71

                            it.apply {

72

                                addTitleText("Lambdas & NPE")

73

                                addText("Part 3")

74

                                addImage(IconCompat.createWithResource(context, R.drawable.kotlin), ListBuilder.LARGE_IMAGE)

75

                                        .setContentIntent(

76

                                                loadArticlePendingIntent(

77

                                                        context,

78

                                                        "https://code.tutsplus.com/articles/coding-functional-android-apps-in-kotlin-lambdas-null-safety-more...)

79

                            }

80

                        }

81

                    }

82

                }

83

                .build()

84

    }

85

    private fun loadArticlePendingIntent(context: Context, url: String) =

86

            PendingIntent.getActivity(

87

                    context,

88

                    0,

89

                    Intent(Intent.ACTION_VIEW).apply { data = Uri.parse(url) },

90

                    0

91

            )

92

}

Usted puede encontrar el código completo para este proyecto en nuestro repositorio de GitHub.

Ejecutar esta aplicación en su dispositivo Android física o AVD y tratar de interactuar con cada elemento de la red. Cada célula debe enlazar a un artículo diferente.

Asegurar que Su Slide se Ve Bien, Independientemente de la Aplicación Host

La forma que se muestra el contenido de la división puede variar, dependiendo del modo de para que la aplicación host está configurada. Para asegurar tus rebanadas de buenas aspecto y funcionan correctamente independientemente de la aplicación de hosting, usted necesitará probar sus rebanadas a través de todos los modos de corte diferentes.

Puesto que nuestro segmento de red tiene mucho más contenido que los slices anteriores, es el mejor candidato para ilustrar las diferencias entre estos diversos modos de slice.

Para poner su rebanada a la prueba, haga clic en el icono en la esquina superior derecha de la rebanada espectador y luego recorrer los siguientes modos:

1. Grandes

En este formato, Android muestra tantas filas como sea posible en el espacio disponible. Este es el modo que utiliza la Slice visor por defecto.

2. Acceso Directo

En este modo, el sector está representado por un icono y una etiqueta.

Si hay un encabezado principal asociado con su SliceAction, entonces esto se utilizará como icono de la división. Si no hay ningún icono disponible, Android en su lugar mostrará la acción primaria asociada con la primera fila de la división, que en este caso es nuestro Kotlin dibujable.

Para cambiar el icono que se muestra en el modo de acceso directo, agregue un segundo dibujable a su proyecto y luego actualizar a la siguiente sección del proveedor de slice:

1

               .addGridRow {

2

                   it.apply {

3

                       addCell {

4

                           it.apply {

5

                               addTitleText("Java vs. Kotlin")

6

                               addText("Part 1")

7

8

//Reference the new drawable//

9

10

                               addImage(IconCompat.createWithResource(context, R.drawable.androidlogo), ListBuilder.LARGE_IMAGE)

3. Pequeño

Modo pequeño tiene una altura limitada y tampoco mostrará un SliceItem único o una colección limitada de elementos como una sola línea de contenido. Si su slice tiene una cabecera, entonces esto será mostrado, que es exactamente lo que está sucediendo con nuestro slice.

Cambiar el título o el subtítulo afecta el contenido que se muestra en modo pequeño.

1

fun createSliceWithGridRow(sliceUri: Uri): Slice {

2

   return ListBuilder(context, sliceUri, ListBuilder.INFINITY)

3

           .setHeader {

4

               it.apply {

5

               setTitle("This is the title")

6

               setSubtitle("This is the subtitle")

7

8

           }

9

       }

Si el slice no contiene un encabezado, entonces primera fila del slice se mostrará en su lugar.

Reducir Código, Con Slice Builders KTX

Una vez que haya aprendido cómo implementar una nueva característica, el siguiente paso es aprender a entregar los mismos resultados, con menos código.

KTX Android es una colección de módulos de extensiones que optimizan la plataforma Android para Kotlin. Módulo de corte constructores KTX de KTX Android envuelve el patrón builder en un DSL de Kotlin-friendly que le ayudará a crear tus rebanadas de una manera más concisa, legible. Para empezar con Slice Builders KTX, vuelva a colocar la siguiente dependencia:

1

implementation 'androidx.slice:slice-builders:1.0.0-alpha3'

Con:

1

implementation 'androidx.slice:slice-builders-ktx:1.0.0-alpha3'

Luego puede modificar su método de createSlice para usar este DSL. Por ejemplo, aquí es una simple slice que muestra un título y un subtítulo:

1

import android.net.Uri

2

import androidx.slice.Slice

3

import androidx.slice.SliceProvider

4

import androidx.slice.builders.ListBuilder

5

import androidx.slice.builders.ListBuilder.INFINITY

6

7

class MySliceProvider : SliceProvider() {

8

9

   override fun onCreateSliceProvider(): Boolean {

10

       return true

11

   }

12

13

   override fun onBindSlice(sliceUri: Uri): Slice? {

14

       val path = sliceUri.path

15

       when (path) {

16

           "/launchMainActivity" -> return createSlice(sliceUri)

17

       }

18

       return null

19

   }

20

21

   fun createSlice(sliceUri: Uri): Slice {

22

       return ListBuilder(context, sliceUri, INFINITY)

23

               .addRow {

24

                   it.apply {

25

                       setTitle("This is a title")

26

                       setSubtitle("This is a subtitle")

27

28

                   }

29

               }.build()

30

   }

31

32

}

Con el DSL, esto se convierte:

1

import android.net.Uri

2

import androidx.slice.Slice

3

import androidx.slice.SliceProvider

4

import androidx.slice.builders.ListBuilder

5

import androidx.slice.builders.list

6

import androidx.slice.builders.row

7

8

class MySliceProvider : SliceProvider() {

9

10

   override fun onCreateSliceProvider(): Boolean {

11

       return true

12

   }

13

14

   override fun onBindSlice(sliceUri: Uri): Slice? {

15

       val path = sliceUri.path

16

       when (path) {

17

           "/launchMainActivity" -> return createSlice(sliceUri)

18

       }

19

       return null

20

   }

21

22

   fun createSlice(sliceUri: Uri): Slice {

23

24

//Instantiate a ListBuilder and call build when the lambda has finished running//

25

26

       return list(context, sliceUri, ListBuilder.INFINITY) {

27

28

//Instantiate row and add it to the ListBuilder//

29

30

           row {

31

32

//setTitle and setSubtitle are both inside the row lambda//

33

34

               setTitle("This is a title")

35

               setSubtitle("This is a subtitle")

36

37

           }

38

39

       }

40

   }

41

}

Conclusión

En este artículo, tenemos alguna experiencia práctica con la característica de slice prometedores de Android. Hemos visto como crear un slice simple que puede proporcionar acceso directo a cualquier parte de la aplicación, antes de pasar a crear slices más complejos consisten en elementos finales, imágenes, texto adicional y varios SliceActions.

Usted puede aprender más sobre slices en la documentación oficial de Android.