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
.