Empacotar e distribuir apps do Wear

Com o Wear OS by Google, um usuário pode acessar a Play Store em um smartwatch e fazer o download de um app Wear diretamente nele. Além disso, pode instalar um app diretamente no smartwatch pela Play Store da Web.

Todos os dispositivos com o Wear 2.0 usam o Android 7.1.1 (API de nível 25). Caso seu app seja compatível apenas com dispositivos que executam o Wear 2.0 ou posterior, o nível mínimo e de destino da API precisa ser de 25. Se o app for compatível com Wear 1.x e 2.0, o nível mínimo e de destino da API poderá ser de 23. Todos os apps Wear precisam ser criados para uma API de nível 23 ou mais recente, portanto, as permissões no momento da execução são necessárias.

Veja também Apps independentes.

Quando um app Wear 2.0 tem um app associado, você precisa usar a mesma chave para assinar cada um deles. Esse requisito também se aplica a um app Wear 1.x, que sempre tem um app associado.

Planejar para a Play Store

Para que seu app apareça na Play Store para smartwatches, faça upload do APK de smartwatches no Play Console, assim como faria com outros APKs. Se você só tiver um APK de smartwatches, nenhuma outra etapa será necessária.

Se você tiver um APK de smartphones e outro de smartwatches, use o Método de entrega de vários APKs.

Distribuição para smartwatches Wear 2.0

Nos dispositivos com Wear 2.0, quando um usuário instala um app para smartphone que tem um app para smartwatch associado (por um APK incorporado ou enviado pelo Play Console), o usuário recebe uma notificação sobre o app disponível para smartwatch. Tocar na notificação abre a Play Store do smartwatch, dando ao usuário a opção de instalar o app.

Além disso:

Quando você atualiza um APK de smartphones com um novo APK de smartwatches incorporado, o APK de smartwatches do usuário é atualizado automaticamente.
Ao fazer upload de um APK de smartwatches no Play Console, você pode atualizar o APK do Wear independentemente do APK do smartphone, e os usuários recebem atualizações pela Play Store do smartwatch.
Para um APK de smartwatches incorporado, o APK de smartwatches do usuário é atualizado automaticamente quando o APK de smartphones é atualizado. No caso de vários APKs, o comportamento de atualização depende da configuração da Play Store (atualização automática de apps). Não é recomendado ter um APK incorporado e vários APKs ao mesmo tempo no seu app caso eles não sejam da mesma versão. Vejamos um exemplo em que há um APK incorporado v1 e vários APKs v2. Se o APK incorporado for instalado primeiro, a versão com vários APKs substituirá o APK incorporado, já que é uma versão mais recente. Posteriormente, se um desenvolvedor atualizar o APK do smartphone para v3, um APK incorporado será automaticamente instalado, substituindo a versão mais recente entregue pelos vários APKs.

Distribuição para smartwatches Wear 1.x e 2.0

O modelo de distribuição padrão do Wear 1.x era a incorporação de um app para smartwatch dentro de um app para smartphone. Agora, o Wear OS permite distribuir o app da mesma forma para o Wear 1.0 e 2.0. Quando um usuário instalar seu app para smartphones, se você tiver um app Wear compatível na Play Store, ele será automaticamente instalado em smartwatches Wear 1.0. Esse recurso permite que você pare de incorporar apps para Wear no APK do seu app para smartphone. É possível fornecer versões independentes do seu APK para smartwatch na Play Store para smartwatches com Wear 1.0 e 2.0.

Especificar um código de versão

Para garantir que um APK independente atualize um APK do Wear incorporado em um smartwatch, o código de versão do APK independente do Wear geralmente precisará ser mais recente do que o código de versão do APK incorporado do Wear. O esquema de códigos de versão do APK de um smartphone pode ser independente do esquema do APK de um smartwatch, mas precisa ser único. No entanto, os códigos de versão do APK independente e do APK incorporado do Wear poderão ser o mesmo se os APKs forem equivalentes.

Se os APKs não forem equivalentes, mas os códigos de versão forem os mesmos, quando um smartwatch for atualizado do Wear 1.x para o 2.0, ele só poderá receber o novo APK depois de aguardar por um período maior do que o esperado.

Atualmente, não é possível criar um único APK que funcione em um smartphone e um smartwatch ao mesmo tempo.

Caso seu APK do Wear e o APK para dispositivo associado compartilhem um código e precisem de versões coordenadas, reserve os dois últimos dígitos do código da versão para as variantes do APK. Um exemplo de uma variante de APK é a arquitetura da CPU. Consulte Compatibilidade com várias arquiteturas de CPU.

Veja uma sugestão de esquema de código de versão:

Defina os dois primeiros dígitos do código da versão para o targetSdkVersion, por exemplo, 25.
Defina os três dígitos seguintes para a versão do produto. Por exemplo, 152 para uma versão do produto 1.5.2.
Defina os próximos dois dígitos para o número do lançamento. Por exemplo, 01.
Reserve os últimos dois dígitos para uma variante de vários APKs. Por exemplo, 00.

Se os valores do exemplo (25, 152, 01 e 00) desse código de versão fossem usados, o código de versão para a variante de APK seria 251520100.

Consulte também Definir informações da versão do aplicativo.

Compatibilidade no arquivo Gradle

Se você tem um app voltado para Wear 1.x e Wear 2.0, considere usar variações de produtos. Por exemplo, se você quiser programar para as versões 23 e 25 do SDK, atualize seu arquivo build.gradle do módulo do Wear para incluir o seguinte, caso a versão mínima do SDK de um app para Wear 1.x seja 23:

    android {
        // Allows you to reference product flavors in your
        // phone module's build.gradle file
        publishNonDefault true
        ...
        defaultConfig
        {
           // This is the minSdkVersion of the Wear 1.x app
           minSdkVersion 23
           ...
        }
        buildTypes {...}
        productFlavors {
            wear1 {
              // Use the defaultConfig value
            }
            wear2 {
                minSdkVersion 25
            }
        }
    }

Uma variante de compilação é uma combinação da variação de produto e do tipo de compilação. No Android Studio, selecione a variante de compilação adequada ao depurar ou publicar seu app. Por exemplo, se wear2 for uma variação de produto, selecione wear2Release como a variante de build de lançamento.

Para fins de código específico do Wear 2.0 ou do Wear 1.x, considere os conjuntos de origem para variantes de compilação.

Migrar um APK do Wear 1.0 de incorporado para vários APKs

Observação: devido a um problema de latência que afeta a disponibilidade de um app em smartwatches Wear 1.x, você pode incorporar um APK do Wear em vez de usar o método de entrega de vários APKs em smartwatches Wear 1.x.

Tradicionalmente, APKs do Wear 1.0 eram incorporados em APKs de smartphones para distribuição de apps de wearable para os usuários. Agora, o Wear OS permite que você faça upload de APKs do Wear 1.0 diretamente para a Play Store, em vez de incorporá-los. Isso ajuda a diminuir o tamanho de um APK de smartphones e permite um aumento da flexibilidade de versão e lançamento de APKs. Se você tem um APK incorporado do Wear 1.0, pode seguir as etapas abaixo para configurar, criar e enviar o APK para a Play Store:

Adicione uma configuração wearAppUnbundled true ao arquivo build.gradle do módulo do smartphone. Isso só é necessário se você já publicou um app Wear incorporado na Play Store.

    android {
      ...
      defaultConfig {
        ...
        wearAppUnbundled true
      }
    }

Remova a seguinte regra de dependência wearApp do arquivo build.gradle do app para smartphone:

    dependencies {
        ...
        wearApp project(path: ':wear', configuration: 'wear1Release')
    }

Verifique se a seguinte restrição de recurso está especificada no arquivo de manifesto do seu app Wear:

    <manifest package="com.example.standalone"
        xmlns:android="http://schemas.android.com/apk/res/android">
        <uses-feature
            android:name="android.hardware.type.watch"/>
        ...
    </manifest>

Defina a versão mínima do SDK como 23 no arquivo build.gradle do seu módulo do Wear.
Se quiser, especifique seu app Wear como independente depois de consultar a página Apps independentes.
Crie o APK do Wear e use o Google Play Console para implantá-lo.

Para a versão mínima do SDK do seu app Wear, considere o seguinte:

Se você tiver APKs diferentes para o Wear 1.0 e 2.0, defina a versão mínima do SDK como 25 no arquivo build.gradle do módulo do Wear 2.0. Isso garante que a Play Store distribua o APK do Wear 2.0 apenas para dispositivos com Wear 2.0.
Se você já tiver um app Wear 2.0 e quiser distribuí-lo para dispositivos Wear 1.0, verifique se ele funciona bem em dispositivos Wear 1.0 antes de definir a versão mínima do SDK como 23.

Definir a versão de destino de um smartwatch

No arquivo de manifesto do Android, defina o elemento uses-feature como android.hardware.type.watch. Além disso, não defina o atributo required como false. No momento, não é possível ter um único APK para dispositivos Wear e não Wear.

Assim, se um APK tiver a seguinte configuração, o Google Play distribuirá o APK apenas para smartwatches:

    <manifest package="com.example.standalone"
        xmlns:android="http://schemas.android.com/apk/res/android">
        <uses-feature
            android:name="android.hardware.type.watch"/>
        ...
    </manifest>

A configuração android.hardware.type.watch acima pode ser combinada com outros critérios, como versão do SDK, resolução da tela e arquitetura da CPU. Assim, diferentes APKs do Wear podem ser distribuídos para diferentes configurações de hardware.

Especificar um app como independente

O Wear 2.0 precisa de um elemento meta-data no arquivo de manifesto do Android de apps para smartwatch como um filho do elemento <application>. O nome do elemento meta-data é com.google.android.wearable.standalone, e o valor precisa ser true ou false. O elemento indica se o app para smartwatch é independente. Se a configuração do elemento for true, seu app poderá ser disponibilizado na Play Store em smartwatches pareados com iPhones, desde que os APKs ativos em todos os canais (por exemplo, no Canal Beta) tenham o elemento definido como true. Se nem todos os APKs (alfa, beta e produção) atualmente oferecidos para o usuário tiverem a configuração descrita acima, seu app ficará indisponível quando o usuário fizer uma pesquisa em um smartwatch pareado com um iPhone.

Um app para smartwatches pode ou não ser considerado independente. Ele pode ser categorizado como uma das seguintes formas:

Completamente independente de um app para smartphones
Semi-independente, ou seja, um app para smartphones não é necessário e só forneceria recursos opcionais
Dependente de um app para smartphones

Se um app para smartwatch for completamente independente ou semi-independente, defina o valor do novo elemento meta-data como true:

    <application>
    ...
      <meta-data
        android:name="com.google.android.wearable.standalone"
        android:value="true" />
    ...
    </application>

Como um app independente ou semi-independente pode ser instalado por um usuário de um iPhone ou de um smartphone Android sem a Play Store, o app para smartwatches precisa ser utilizável sem o app do smartphone Android.

Se um app para smartwatch depender de um app para smartphone, defina o valor do elemento meta-data acima como false. Definir o elemento como false significa que o app só pode ser instalado em um smartwatch pareado com um smartphone que tenha a Play Store.

Observação: mesmo que o valor seja false, o app para smartwatch pode ser instalado antes do app para smartphone.

Se seu app Wear 2.0 tiver um app para smartphones associado, use o mesmo nome de pacote em ambos.

Usar o Play Console

Você pode usar o Play Console para fazer upload de um APK independente do Wear em uma página "Detalhes do app".

Consulte também Compatibilidade com vários APKs e Gerenciar seu app. Antes de fazer upload de um APK como descrito abaixo, ele precisará ser assinado.

Fazer upload do APK e publicá-lo

Para fazer upload do APK e publicá-lo com o Play Console:

Acesse o Google Play Console.
No menu à esquerda, selecione Gerenciamento da versão > Versões de apps.
Observação: se o APK estiver no modo de rascunho, selecione Versões de apps diretamente no menu à esquerda.
Ao lado do tipo da versão (produção, alfa ou beta) que você quer criar, selecione Gerenciar.
Para criar uma nova versão, selecione Criar uma versão.
Selecione Adicionar APK da biblioteca para adicionar seu APK independente do Wear. Como alternativa, arraste e solte o arquivo do APK ou selecione Procurar arquivos.
Depois de preparar a versão, selecione Revisar. A tela "Revisar e lançar versão" é exibida. Aqui, você pode usar o ícone de informações para revisar os detalhes do APK, como número de dispositivos Android compatíveis. Verifique também se você definiu o recurso de hardware como android.hardware.type.Watch.
Selecione Confirmar lançamento para publicar seu app.

Incorporar um APK do Wear 1.x

Os processos nesta seção são mantidos para referência. Se um APK do Wear 1.x acompanhar um APK de app para smartphones, o sistema enviará o app Wear ao smartwatch pareado quando o usuário fizer o download do app para smartphones.

Observação: esse recurso não funciona quando você assina seus apps com uma chave de depuração. Durante o desenvolvimento, é necessário instalar os apps com adb install ou Android Studio diretamente no smartwatch.

Empacotar um app Wear 1.x com o Android Studio

Para empacotar um app Wear 1.x no Android Studio:

Verifique se os módulos do app para smartwatches e smartphones têm o mesmo nome de pacote.
Declare uma dependência do Gradle no arquivo build.gradle do app para smartphone que aponta para o módulo do app para smartwatch. A declaração seria semelhante à seguinte, mas consulte Configurar o Google Play Services e a biblioteca de compatibilidade v4 para encontrar as versões mais recentes:
```
    dependencies {
       compile 'com.google.android.gms:play-services-wearable:10.0.1'
       compile 'com.android.support:support-compat:25.1.0'
       wearApp project(':wearable')
    }
    
```
Siga as instruções em Assinar o build de lançamento para especificar o keystore do seu lançamento e assinar seu app. O Android Studio exporta um app para smartphone assinado para a pasta raiz do seu projeto, incluindo um app para smartwatch incorporado.
Como alternativa, assine os dois apps na linha de comando com o wrapper do Gradle. Os dois apps precisam ser assinados para permitir o envio automático do app para smartwatch. Consulte Assinar seu app.

Assinar o app Wear 1.x e o app para smartphones separadamente

Se o processo de compilação precisar da assinatura do app para smartwatch separadamente do app para smartphone, declare a seguinte regra do Gradle no arquivo build.gradle do módulo do smartphone a fim de incorporar o app para smartwatch assinado anteriormente:

    dependencies {
      ...
      wearApp files('/path/to/wearable_app.apk')
    }

Em seguida, assine o app para smartphone como achar melhor, ou seja, com o item de menu do Android Studio Build > Generate Signed APK… ou com as regras signingConfig do Gradle.

Empacotar um app Wear 1.x manualmente

Você poderá empacotar um app para smartwatches em um app para smartphones manualmente se estiver usando outro ambiente de desenvolvimento integrado ou outro método de criação:

Verifique se os APKs para smartwatches e smartphones têm o mesmo nome de pacote e número de versão.
Copie o app para smartwatch assinado para o diretório res/raw do seu projeto para smartphone. Vamos nos referir ao APK como wearable_app.apk.
Crie um arquivo res/xml/wearable_app_desc.xml que contenha a versão e a informação de caminho do app para smartwatch. Por exemplo:
```
    <wearableApp package="wearable.app.package.name">
      <versionCode>1</versionCode>
      <versionName>1.0</versionName>
      <rawPathResId>wearable_app</rawPathResId>
    
    </wearableApp>
    
```
Os valores de package, versionCode e versionName são os mesmos do arquivo de manifesto do app para smartwatch. O rawPathResId é o nome da variável estática do recurso do APK. Por exemplo, para wearable_app.apk, o nome da variável estática é wearable_app.
Adicione uma tag meta-data à tag <application> do app para smartphone para referenciar o arquivo wearable_app_desc.xml.
```
      <meta-data android:name="com.google.android.wearable.beta.app"
                     android:resource="@xml/wearable_app_desc"/>
    
```
Observação: a tag meta-data acima não pode ser mudada. com.google.android.wearable.beta.app é obrigatório.
Crie e assine o app para smartphones.

Desativar a compactação de recursos

Por padrão, Android Studio não compacta o APK. No entanto, se você usar outro processo de compilação, verifique se o app para smartwatches não foi duplamente compactado. Muitas ferramentas de compilação compactam automaticamente os arquivos adicionados ao diretório res/raw de um app para Android. O APK para smartwatch já está compactado, de modo que uma compactação dupla pode ocorrer. Como resultado, o instalador do app para smartwatch não pode ler o app, a instalação falha e o PackageUpdateService exibe o erro: "Este arquivo não pode ser aberto como um descritor do arquivo. É provável que ele esteja compactado".