Integrate in-app reviews (Native)

This guide describes how to integrate in-app reviews in your app using native (C or C++) code. There are separate integration guides if you are using Kotlin or Java or Unity.

Native SDK overview

The Play Core Native SDK is part of Google Play Core libraries family. The Play Core Native SDK includes a C header file, review.h, that wraps ReviewManager from the Java Play In-App Review libraries. This header file allows your app to call the API directly from your native code. For an overview of the public functions that are available, see the Play Review native module documentation.

ReviewManager_requestReviewFlow starts a request that gathers the information that is required to launch the in-app review flow later. You can track the result of the request using ReviewManager_getReviewStatus. For more information about all the statuses that ReviewManager_getReviewStatus can return, see ReviewErrorCode.

Both the request and launch functions return REVIEW_NO_ERROR if the function succeeds.

Set up your development environment

1. Do either of the following:

   • Install Android Studio version 4.0 or higher. Use the SDK Manager UI to install Android SDK Platform version 10.0 (API level 29).
   • Install the Android SDK command-line tools and use sdkmanager to install Android SDK Platform version 10.0 (API level 29).

2. Prepare Android Studio for native development by using the SDK Manager to install the latest CMake and Android Native Development Kit (NDK). For more information on creating or importing native projects, see Getting Started with the NDK.

3. Download the zip file and extract it alongside your project.

   Download Link	Size	SHA-256 Checksum
   play-core-native-sdk-1.11.0.zip	55.6 MB	058b4069f09714da938656d43b6dc28d3bc6f821c9d406e9c96a1c3af014dc45

4. Update your app’s build.gradle file as shown below:

   Groovy

       // 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.
       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")
   
           // Use the following dependency for the Play Integrity API.
           implementation("com.google.android.play:integrity:1.0.0")
           ...
       }
       

   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. Update your app’s CMakeLists.txt files as shown below:

   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
           ...)
   

After you integrate the Play Core Native SDK into your project, include the following line in files that contain API calls:

Include review.h

After integrating the Play Core Native SDK into your project, include the following line in files that will contain API calls:

#include "play/review.h"

Initialize the Review API

Whenever you want to use the API, you must initialize it first by calling the ReviewManager_init function, as shown in the following example built with android_native_app_glue.h:

void android_main(android_app* app) {
  app->onInputEvent = HandleInputEvent;

  ReviewErrorCode error_code = ReviewManager_init(app->activity->vm, app->activity->clazz);
  if (error_code == REVIEW_NO_ERROR) {
    // You can use the API.
  }
}

Request the in-app review flow

Follow the guidance about when to request in-app reviews to determine good points in your app's user flow to prompt the user for a review (for example, after a user dismisses the summary screen at the end of a level in a game). When your app gets close one of these points, call ReviewManager_requestReviewFlow to asynchronously request the information that your app needs to launch an in-app review flow. Monitor the progress of the ReviewManager_requestReviewFlow operation by calling ReviewManager_getReviewStatus, for example once every frame. This might take up to a couple of seconds, so you should start this process before your app reaches the point when you want to show the in-app review flow.

ReviewErrorCode error_code = ReviewManager_requestReviewFlow();
if (error_code == REVIEW_NO_ERROR) {
    // The request has successfully started, check the status using
    // ReviewManager_getReviewStatus.
} else {
    // Error such as REVIEW_PLAY_STORE_NOT_FOUND indicating that the in-app
    // review isn't currently possible.
}

Handle statuses and launch the in-app review flow

Whenever a request has started or the in-app review flow is launched, you can check the status using ReviewManager_getReviewStatus. This allows you to define the logic depending on the API status. One way to approach this is to keep the status as a global variable and check whether the status is REVIEW_REQUEST_FLOW_COMPLETED when the user performs a certain action (for example, tapping a “Next Level” button in a game), as shown in the following example:

ReviewStatus status;
ReviewErrorCode error_code = ReviewManager_getReviewStatus(&status);
if (error_code != REVIEW_NO_ERROR) {
    // There was an error with the most recent operation.
    return;
}

switch (status) {
    case REVIEW_REQUEST_FLOW_PENDING:
        // Request is ongoing. The flow can't be launched yet.
        break;
    case REVIEW_REQUEST_FLOW_COMPLETED:
        // Request completed. The flow can be launched now.
        break;
    case REVIEW_LAUNCH_FLOW_PENDING:
        // The review flow is ongoing, meaning the dialog might be displayed.
        break;
    case REVIEW_LAUNCH_FLOW_COMPLETED:
        // The review flow has finished. Continue with your app flow (for
        // example, move to the next screen).
        break;
    default:
        // Unknown status.
        break;
}

When the status is REVIEW_REQUEST_FLOW_COMPLETED and your app is ready, launch the in-app review flow:

// This call uses android_native_app_glue.h.
ReviewErrorCode error_code = ReviewManager_launchReviewFlow(app->activity->clazz);
if (error_code != REVIEW_NO_ERROR) {
    // There was an error while launching the flow.
    return;
}

After launching the in-app review flow, keep checking the status for completion and continue with your app flow. A common way to handle this, would be by following the Game Loop pattern.

Free resources

Don't forget to free resources by calling the ReviewManager_destroy function once your app has finished using the API (for example, after the in-app review flow is completed).

void ReviewManager_destroy();

Next steps

Test your app's in-app review flow to verify that your integration is working correctly.