Se usó la API de Cloud Translation para traducir esta página.

Cómo inicializar la casa en Android

Antes de usar cualquiera de las APIs de Home para Android, debes inicializar la casa en tu app. En este paso, crearás una instancia singleton de Home para el contexto local.

Solo debe haber una instancia de Home activa a la vez.

Este es el punto de entrada a las APIs de Home y también implica declarar qué rasgos y tipos de dispositivos planeas usar con las APIs de Device & Structure y Automation. Si recién comienzas a usar el ecosistema de Google Home y no sabes qué rasgos o tipos de dispositivos registrar, te sugerimos algunos de los más comunes en esta guía.

Crea una instancia de Home

Para comenzar, importa estos paquetes a tu app:

import android.content.Context
import com.google.home.FactoryRegistry
import com.google.home.HomeConfig
import com.google.home.Home

Para inicializar las APIs de Home, haz lo siguiente:

Obtén una referencia al contexto de Application. Este contexto no depende de ningún ciclo de vida de la actividad y existirá mientras tu app esté activa. Puedes obtenerlo llamando a getApplicationContext() dentro de un Activity o Service:
```
val context = getApplicationContext()
```

Crea una instancia de FactoryRegistry con todos los rasgos y tipos de dispositivos que planeas usar en tu app.

En esta guía, sugerimos algunos comunes (tipos de dispositivos Luz, Enchufe, Sensor, Interruptor y Termostato, y rasgos de presencia y Asistente para automatizaciones), en caso de que no sepas qué necesitas. Para obtener más información, consulta Registro de rasgos y tipos de dispositivos.

val registry = FactoryRegistry(
  traits = listOf(
            AirQuality,
            AreaAttendanceState,
            AreaPresenceState,
            AssistantBroadcast,
            AssistantFulfillment,
            BooleanState,
            ColorControl,
            ExtendedColorControl,
            FlowMeasurement,
            IlluminanceMeasurement,
            LevelControl,
            Notification,
            OccupancySensing,
            OnOff,
            RelativeHumidityMeasurement,
            Switch,
            TemperatureMeasurement,
            Thermostat),
  types = listOf(
            AirQualitySensorDevice,
            ColorDimmerSwitchDevice,
            ColorTemperatureLightDevice,
            ContactSensorDevice,
            DimmableLightDevice,
            DimmablePlugInUnitDevice,
            DimmerSwitchDevice,
            ExtendedColorLightDevice,
            FlowSensorDevice,
            GenericSwitchDevice,
            HumiditySensorDevice,
            LightSensorDevice,
            OccupancySensorDevice,
            OnOffLightDevice,
            OnOffLightSwitchDevice,
            OnOffPluginUnitDevice,
            OnOffSensorDevice,
            SpeakerDevice,
            TemperatureSensorDevice,
            ThermostatDevice))

Se requieren instrucciones de importación para cada rasgo y tipo de dispositivo individuales registrados aquí (Android Studio debería solicitarte que los agregues).

Crea una instancia de HomeConfig con el contexto de la corrutina Dispatchers.IO y tu instancia de registro.

val homeConfig = HomeConfig(
        coroutineContext = Dispatchers.IO,
        factoryRegistry = registry)

Por último, crea la instancia singleton de Home, que es el punto de entrada a las APIs, con el contexto y el HomeConfig.
```
val homeManager: HomeClient = Home.getClient(context, homeConfig)
```

Para evitar errores con sesiones no válidas, es importante que solo se cree una instancia singleton de Home, para lo cual se debe encapsular en una declaración de objeto.

Por ejemplo, la app de ejemplo lo hace de la siguiente manera:

internal object HomeClientModule {
  @Provides
  @Singleton
  fun provideHomeClient(@ApplicationContext context: Context): HomeClient {
    return Home.getClient(
      context,
      HomeConfig(
        coroutineContext = IODispatcherModule.provideIoDispatcher(),
        factoryRegistry = registry,
      ),
    )
  }
}

Acceso con Google iniciado por la app

Es posible que desees administrar las autenticaciones de Google de tus usuarios dentro de tu app. Esto te permite usar la misma cuenta de usuario en varios servicios de Google, como Google Home, Drive, Maps, etcétera.

Con el acceso con Google iniciado por la app, puedes obtener una instancia de HomeClient vinculada de forma explícita a un usuario en particular, lo que permite omitir el selector de Cuentas de Google y la pantalla de consentimiento cuando la cuenta ya está autorizada.

Además, este enfoque evita que los usuarios vean dos pantallas diferentes de selección de cuentas: una del acceso de la app y otra de Google Home.

Para ello, debes consultar Cómo autenticar usuarios con Acceder con Google y completar los siguientes pasos:

Crea un ID de cliente de aplicación web de OAuth

Abre la consola de Google Cloud.
- Navega a la página Credenciales de la consola de Google Cloud.
- Selecciona un proyecto existente o crea uno nuevo.
Configura la pantalla de consentimiento de OAuth (si aún no lo hiciste)
- Antes de crear credenciales, asegúrate de que la pantalla de consentimiento de OAuth esté configurada con los detalles de tu app, incluidas las URLs de la política de privacidad y las condiciones del servicio.
Crea un ID de cliente de OAuth (tipo de aplicación web)
- En la página Credenciales, haz clic en + CREATE CREDENTIALS y selecciona ID de cliente de OAuth en el menú desplegable.
- En Tipo de aplicación, selecciona Aplicación web.
- Ingresa un nombre para tu cliente web (p.ej., "My App Web Backend").
- Haz clic en Crear.
Recupera el ID de cliente.
- Después de la creación, la consola mostrará tu nuevo ID de cliente. Este es el valor que usarás en tu aplicación para Android (p. ej., "{project number}-.....apps.googleusercontent.com").
- Te recomendamos que almacenes el ID de cliente de forma externa (p. ej., en build.gradle) en lugar de codificarlo directamente.

Cómo crear una instancia de una solicitud de acceso con Google

Usa el ID de la app web para crear una solicitud de acceso con Google:

// Your Google Cloud console Web Client ID for Google Sign-In
val serverClientId = BuildConfig.DEFAULT_WEB_CLIENT_ID

// Build the request for Google ID token
val googleIdOption = GetGoogleIdOption.Builder()
    .setFilterByAuthorizedAccounts(false) // Show all Google Accounts on the device
    .setServerClientId(serverClientId) // embed WebClientID in token
    .build()

// Build the GetCredentialRequest
val request = GetCredentialRequest.Builder().addCredentialOption(googleIdOption).build()

Crea el flujo de Acceder con Google

Para implementar el flujo de acceso, usa CredentialManager para ejecutar una solicitud Sign in with Google. Una vez que el usuario selecciona una cuenta, extrae su correo electrónico del token de ID de Google resultante para crear un android.accounts.Account. Luego, esta cuenta se usa para inicializar una instancia de HomeClient vinculada específicamente a ese usuario que accedió.

  try {
    // CredentialManager is responsible for interacting with various credential providers on the device
    val credentialManager = CredentialManager.create(context)
    // Credential returns when user has selected an account and the getCredential call completes
    val result = credentialManager.getCredential(context = context, request = request)
    val credential = result.credential

    if (
      credential is CustomCredential &&
      credential.type == GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL
    ) {
      try {
        val googleCredential = GoogleIdTokenCredential.createFrom(credential.data)
        googleCredential.id.let { userEmail ->
          Log.i(TAG, "Email found in Google ID Token: $email")
          /*
           Why "com.google"?
           The string "com.google" is a standard identifier used in Android's android.accounts.
           Account system to represent accounts managed by Google. This is often used when
           interacting with Android's Account Manager or when using Google-specific APIs. So,
           even if the email ends in "@gmail.com", the underlying account type or provider is
           still considered "com.google" within the Android system.
          */
          val account = Account(userEmail, "com.google")
          Log.d(TAG,"Switched account to : $userEmail")
          // Get the new Home Client Instance with the userEmail
        }
        Log.i(TAG, "Account switch complete. Emitting navigation event.")
      } catch (e: Exception) {
        Log.e(TAG,"Could not convert CustomCredential to Google ID Token", e)
      }
    }
  } catch (e: Exception) {
    Log.e(TAG, "Google Sign-In failed with unexpected error", e)
  }

Obtén una instancia nueva de HomeClient

Sigue los mismos pasos que se describen en Cómo crear una instancia de Home, pero, en lugar de llamar a Home.getClient(context, homeConfig) en el paso 4, llama a Home.getClient(context, userAccount, homeConfig), donde el segundo parámetro es un Lazy<UserAccount>. Esto devuelve una instancia de HomeClientWithProvidedAccount, una subclase de HomeClient, que está vinculada de forma explícita a la Cuenta de Google especificada:

val client =
     Home.getClient(
       context = context.applicationContext,
       account =
         lazy {
         // 1. Create the Account object.
           val androidAccount = Account(userEmail,
                                        GoogleAuthUtil.GOOGLE_ACCOUNT_TYPE)
         // 2. Wrap it in UserAccount.GoogleAccount.
           UserAccount.GoogleAccount(androidAccount)
         },
       homeConfig = HomeConfig()
     )

Si el usuario especificado no está autorizado, pídele permiso llamando a los siguientes métodos en la instancia de HomeClientWithProvidedAccount:

registerActivityResultCallerForPermissions() con una referencia al ActivityResultCaller que deseas usar.
requestPermissions(). Aparecerá la pantalla de consentimiento de GHP, en la que el usuario puede otorgar su permiso.

Puedes crear un HomeClient con un UserAccount y, luego, llamar a requestPermissions() con forceLaunch==true para volver a iniciar la pantalla de consentimiento y permitir que el usuario actualice el otorgamiento de permisos:

val client =
     Home.getClient(
       context = context.applicationContext,
       account =
         lazy {
              UserAccount.GoogleAccount(androidAccount)
         },
       homeConfig = HomeConfig()
     )

client.registerActivityResultCallerForPermissions(this)
client.requestPermissions(forceLaunch= true)

Consulta la API de Permissions para obtener más información sobre cómo administrar los permisos de las APIs de Home.

Actualiza toda la actividad con el nuevo HomeClient

Una vez que tengas una nueva instancia de HomeClient, debes actualizar toda la actividad para volver a suscribirte y recuperar las estructuras, los dispositivos y otros datos pertinentes completos asociados con esta cuenta de usuario.

Registro de características y tipos de dispositivos

La clase FactoryRegistry ayuda a los desarrolladores a optimizar el tamaño del archivo binario de su app, ya que les permite indicar explícitamente qué rasgos y tipos de dispositivos usa su app.

Ten en cuenta que los permisos y el registro de fábrica están desacoplados. Por lo tanto, no se puede acceder a los tipos y rasgos no registrados que están disponibles para tu app a través de permisos, pero que no se incluyen en el registro de fábrica, con la API de Automation, ni se devuelven en las llamadas a los métodos traits() o types() masivos.

2. Configura OAuth

4. API de Permissions

Cómo inicializar la casa en Android Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.