LiteRT in Google Play services C API (Beta)

LiteRT in Google Play services runtime allows you to run machine learning (ML) models without statically bundling LiteRT libraries into your app. This guide provide instructions on how to use the C APIs for Google Play services.

Before working with the LiteRT in Google Play services C API, make sure you have the CMake build tool installed.

Update your build configuration

Add the following dependencies to your app project code to access the Play services API for LiteRT:

implementation "com.google.android.gms:play-services-tflite-java:16.2.0-beta02"

Then, enable the Prefab feature to access the C API from your CMake script by updating the android block of your module's build.gradle file:

buildFeatures {
  prefab = true
}

You finally need to add the package tensorflowlite_jni_gms_client imported from the AAR as a dependency in your CMake script:

find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG)

target_link_libraries(tflite-jni # your JNI lib target
        tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client
        android # other deps for your target
        log)

# Also add -DTFLITE_IN_GMSCORE -DTFLITE_WITH_STABLE_ABI
# to the C/C++ compiler flags.

add_compile_definitions(TFLITE_IN_GMSCORE)
add_compile_definitions(TFLITE_WITH_STABLE_ABI)

Initialize the LiteRT runtime

Before calling the LiteRT Native API you must initialize the TfLiteNative runtime in your Java/Kotlin code.

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

Using the Google Play services Task API, TfLiteNative.initialize asynchronously loads the TFLite runtime from Google Play services into your application's runtime process. Use addOnSuccessListener() to make sure the TfLite.initialize() task completes before executing code that accesses LiteRT APIs. Once the task has completed successfully, you can invoke all the available TFLite Native APIs.

Native code implementation

To use LiteRT in Google Play services with your native code, you can do one of the following:

• declare new JNI functions to call native functions from your Java code
• Call the LiteRT Native API from your existing native C code.

JNI functions:

You can declare a new JNI function to make the LiteRT runtime declared in Java/Kotlin accessible to your native code as follow:

package com.google.samples.gms.tflite.c;

public class TfLiteJni {
  static {
    System.loadLibrary("tflite-jni");
  }
  public TfLiteJni() { /**/ };
  public native void loadModel(AssetManager assetManager, String assetName);
  public native float[] runInference(float[] input);
}
      

package com.google.samples.gms.tflite.c

class TfLiteJni() {
  companion object {
    init {
      System.loadLibrary("tflite-jni")
    }
  }
  external fun loadModel(assetManager: AssetManager, assetName: String)
  external fun runInference(input: FloatArray): FloatArray
}
        

Matching the following loadModel and runInference native functions:

#ifdef __cplusplus
extern "C" {
#endif

void Java_com_google_samples_gms_tflite_c_loadModel(
  JNIEnv *env, jobject tflite_jni, jobject asset_manager, jstring asset_name){
  //...
}

jfloatArray Java_com_google_samples_gms_tflite_c_TfLiteJni_runInference(
  JNIEnv* env, jobject tfliteJni, jfloatArray input) {
  //...
}

#ifdef __cplusplus
}  // extern "C".
#endif

You can then call your C functions from your Java/Kotlin code:

tfLiteHandleTask.onSuccessTask(unused -> {
    TfLiteJni jni = new TfLiteJni();
    jni.loadModel(getAssets(), "add.bin");
    //...
});
    

tfLiteHandleTask.onSuccessTask {
    val jni = TfLiteJni()
    jni.loadModel(assets, "add.bin")
    // ...
}
      

LiteRT in C code

Include the appropriate API header file to include the TfLite with Google Play services API:

#include "tensorflow/lite/c/c_api.h"

You can then use the regular LiteRT C API:

auto model = TfLiteModelCreate(model_asset, model_asset_length);
// ...
auto options = TfLiteInterpreterOptionsCreate();
// ...
auto interpreter = TfLiteInterpreterCreate(model, options);

The LiteRT with Google Play services Native API headers provide the same API as the regular LiteRT C API, excluding features that are deprecated or experimental. For now the functions and types from the c_api.h, c_api_types.h and common.h headers are available. Please note that functions from the c_api_experimental.h header are not supported.

You can use functions specific to LiteRT with Google Play Services by including tflite.h.