Visão geral da biblioteca Google Play Core

Esta página descreve a Biblioteca Google Play Core e como adicioná-la ao seu projeto.

O que é a Play Core?

A biblioteca Play Core é a interface de tempo de execução do seu app com a Google Play Store. Algumas das coisas que você pode fazer com o Play Core incluem:

• Fazer o download de outros recursos de idioma
• Gerenciar a entrega de módulos de recursos
• Gerenciar a entrega de pacotes de recursos
• Acionar atualizações no app
• Solicitar avaliações no app

A biblioteca Play Core está disponível em Java, nativo e Unity. Para ver mais informações sobre a versão mais recente da biblioteca Play Core, consulte as Notas da versão.

Adicionar a Biblioteca Play Core ao seu projeto

Antes de começar a usar a Biblioteca Play Core, primeiro é necessário adicioná-la ao seu projeto do app. As etapas necessárias dependem de você estar desenvolvendo em Java, Kotlin, nativo ou usando Unity.

• Java ou Kotlin
• Nativo
• Unity

Java ou Kotlin

Se você estiver desenvolvendo seu projeto usando Java ou Kotlin, poderá importar a biblioteca Play Core para o projeto Android como uma dependência do Gradle, conforme mostrado abaixo.

// In your app’s build.gradle file:
...
dependencies {
    // This dependency is downloaded from the Google’s Maven repository.
    // So, make sure you also include that repository in your project's build.gradle file.
    implementation 'com.google.android.play:core:1.10.2'

    // For Kotlin users also add the Kotlin extensions library for Play Core:
    implementation 'com.google.android.play:core-ktx:1.8.1'
    ...
}

// In your app’s build.gradle file:
...
dependencies {
    // This dependency is downloaded from the Google’s Maven repository.
    // So, make sure you also include that repository in your project's build.gradle file.
    implementation("com.google.android.play:core:1.10.2")

    // For Kotlin users also import the Kotlin extensions library for Play Core:
    implementation("com.google.android.play:core-ktx:1.8.1")
    ...
}

A biblioteca Play Core KTX é opcional e fornece versões de corrotinas Kotlin para chamadas de métodos assíncronas na biblioteca normal do Play Core, além de outras extensões úteis que usam as APIs mais idiomáticas do Kotlin.

Nativo

O SDK nativo da Play Core oferece uma interface da API C/C++ para o Play Asset Delivery. O SDK foi projetado para compilar bibliotecas nativas ARM e x86 com o CMake e para usar o Gradle para gerar Android App Bundles e APKs.

Configurar seu ambiente de desenvolvimento

1. Realize uma das seguintes ações:

   • Instale o Android Studio versão 4.0 ou mais recente. Use a IU do SDK Manager para instalar o Android SDK Platform versão 10.0 (nível 29 da API).
   • Instale as ferramentas de linha de comando do SDK do Android e use o sdkmanager para instalar o Android SDK Platform versão 10.0 (API de nível 29).

2. Prepare o Android Studio para o desenvolvimento nativo usando o SDK Manager para instalar o CMake e o Android Native Development Kit (NDK) mais recentes. Para saber mais sobre como criar ou importar projetos nativos, consulte Primeiros passos com o NDK.

3. Faça o download do arquivo ZIP e extraia ele junto com o projeto.

   Link de download	Tamanho	Soma de verificação SHA-256
   play-core-native-sdk-1.10.2.zip	43,4 MB	ce312a423d2284be1ca114f242b61e3c52c490d1fffc25573e9ab4e75079aeed

4. Atualize o arquivo build.gradle do app como mostrado abaixo:

   Groovy

       // App build.gradle
   
       apply plugin: 'com.android.application'
   
       // Define a path to the extracted Play Core SDK files.
       // If using a relative path, wrap it with file() since CMake requires absolute paths.
       def playcoreDir = file('../path/to/playcore-native-sdk')
   
       android {
           defaultConfig {
               ...
               externalNativeBuild {
                   cmake {
                       // Define the PLAYCORE_LOCATION directive.
                       arguments "-DANDROID_STL=c++_static",
                                 "-DPLAYCORE_LOCATION=$playcoreDir"
                   }
               }
               ndk {
                   // Skip deprecated ABIs. Only required when using NDK 16 or earlier.
                   abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
               }
           }
           buildTypes {
               release {
                   // Include Play Core Library proguard config files to strip unused code while retaining the Java symbols needed for JNI.
                   proguardFile "$playcoreDir/proguard/common.pgcfg"
                   proguardFile "$playcoreDir/proguard/per-feature-proguard-files"
                   ...
               }
               debug {
                   ...
               }
           }
           externalNativeBuild {
               cmake {
                   path 'src/main/CMakeLists.txt'
               }
           }
       }
   
       dependencies {
           // Use the Play Core AAR included with the SDK.
           implementation files("$playcoreDir/playcore.aar")
           ...
       }
       

   Kotlin

   // App build.gradle
   
   plugins {
       id("com.android.application")
   }
   
   // Define a path to the extracted Play Core SDK files.
   // If using a relative path, wrap it with file() since CMake requires absolute paths.
   val playcoreDir = file("../path/to/playcore-native-sdk")
   
   android {
       defaultConfig {
           ...
           externalNativeBuild {
               cmake {
                   // Define the PLAYCORE_LOCATION directive.
                   arguments += listOf("-DANDROID_STL=c++_static", "-DPLAYCORE_LOCATION=$playcoreDir")
               }
           }
           ndk {
               // Skip deprecated ABIs. Only required when using NDK 16 or earlier.
               abiFilters.clear()
               abiFilters += listOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
           }
       }
       buildTypes {
           release {
               // Include Play Core Library proguard config files to strip unused code while retaining the Java symbols needed for JNI.
               proguardFile("$playcoreDir/proguard/common.pgcfg")
               proguardFile("$playcoreDir/proguard/per-feature-proguard-files")
               ...
           }
           debug {
               ...
           }
       }
       externalNativeBuild {
           cmake {
               path = "src/main/CMakeLists.txt"
           }
       }
   }
   
   dependencies {
       // Use the Play Core AAR included with the SDK.
       implementation(files("$playcoreDir/playcore.aar"))
       ...
   }
   

5. Atualize os arquivos CMakeLists.txt do seu app como mostrado abaixo:

   cmake_minimum_required(VERSION 3.6)
   
   ...
   
   # Add a static library called “playcore” built with the c++_static STL.
   include(${PLAYCORE_LOCATION}/playcore.cmake)
   add_playcore_static_library()
   
   // In this example “main” is your native code library, i.e. libmain.so.
   add_library(main SHARED
           ...)
   
   target_include_directories(main PRIVATE
           ${PLAYCORE_LOCATION}/include
           ...)
   
   target_link_libraries(main
           android
           playcore
           ...)
   

Unity

Os plug-ins do Unity estão disponíveis para algumas APIs Play Core, incluindo a Play Asset Delivery. Faça o download da versão mais recente do Google Play Plugins for Unity (link em inglês). Esse é um pacote único que inclui plug-ins da Play Core, além de outros plug-ins do Google Play, como o Faturamento em apps do Google Play e o Play Instant.

Termos de Serviço do kit de desenvolvimento de software do Play Core

1. Ao usar o kit de desenvolvimento de software da Play Core, você concorda com estes termos, além dos Termos de Serviço das APIs do Google ("TOS da API"). Se eles entrarem em conflito, estes termos terão prioridade em relação aos TOS da API. Leia estes termos e os TOS da API com atenção.
2. Para os fins destes termos, "APIs" significa as APIs do Google, outros serviços para desenvolvedores e os softwares associados, incluindo códigos redistribuíveis.
3. Um "código redistribuível" é um arquivo principal ou código de objeto fornecido pelo Google que chama as APIs.
4. Sujeito a estes termos e aos termos da TOS da API, você pode copiar e distribuir códigos redistribuíveis exclusivamente para inclusão como parte do seu cliente da API. O Google e nossos licenciantes são proprietários de todos os direitos, títulos e participações, incluindo toda e qualquer propriedade intelectual e outros direitos de propriedade relacionados aos códigos redistribuíveis. Não é permitido modificar, traduzir ou criar obras derivadas de códigos redistribuíveis.
5. O Google pode fazer alterações nestes termos a qualquer momento, mediante aviso prévio, incluindo a possibilidade de se recusar a continuar usando o kit de desenvolvimento de software da Play Core. O Google publicará avisos de modificações nos termos em https://developer.android.com/guide/playcore/license. As alterações não são retroativas.