# Android Tutorial Prerequisites - The Qualcomm® Neural Processing SDK has been set up following the [Qualcomm (R) Neural Processing SDK Setup](https://docs.qualcomm.com/doc/80-63442-10/topic/SNPE_general_setup.html) chapter. - The [Tutorials Setup](https://docs.qualcomm.com/doc/80-63442-10/topic/tutorial_setup.html) has been completed. Introduction This tutorial walks through the process of integrating the Qualcomm® Neural Processing SDK and [snpe-platform-validator](https://docs.qualcomm.com/doc/80-63442-10/topic/SNPE_general_tools.html#tools_snpe-platform-validator) Java APIs within an Android application. The Qualcomm® Neural Processing SDK and Platform Validator Java APIs are made available as an Android Archive (AAR) file which application developers include as a dependency of their applications. Gradle project dependency allprojects { repositories { ... flatDir { // Marks the directory as a repository for // dependencies. Place the snpe-release.aar // in the directory below. dirs 'libs' } } } ... dependencies { ... // This adds the Qualcomm (R) Neural Processing SDK as a project dependency compile(name: 'snpe-release', ext:'aar') // This adds the Platform Validator tool (optional) as a project dependency compile(name: 'platformvalidator-release', ext:'aar') } Copy to clipboard In case both the archives are required in a project, “pickFirst” need to be used in gradle to avoid library conflicts. android { ... packagingOptions { pickFirst 'lib/arm64-v8a/libc++_shared.so' pickFirst 'lib/arm64-v8a/libSNPE.so' pickFirst 'lib/arm64-v8a/libSnpeHtpV73Skel.so' pickFirst 'lib/arm64-v8a/libSnpeHtpV73tub.so ' pickFirst 'lib/arm64-v8a/libSnpeHtpV69Skel.so' pickFirst 'lib/arm64-v8a/libSnpeHtpV69tub.so ' pickFirst 'lib/arm64-v8a/libSnpeHtpV68Skel.so' pickFirst 'lib/arm64-v8a/libSnpeHtpV68tub.so ' pickFirst 'lib/arm64-v8a/libSnpeDspV66Skel.so' pickFirst 'lib/arm64-v8a/libSnpeDspV66Stub.so ' pickFirst 'lib/arm64-v8a/libSnpeDspV65Skel.so' pickFirst 'lib/arm64-v8a/libSnpeDspV65Stub.so ' pickFirst 'lib/arm64-v8a/libSnpeHtpPrepare.so ' } Copy to clipboard Platform Validator Java API Overview Once the optional dependency of platform validator is added, the Platform Validator classes under the **com.qualcomm.qti.platformvalidator** package will be available in the application classpath. All applications will first create an object of Platform Validator with required runtime and then use that object to call validation APIs as described below. Using Platform Validator //Platform validator class for object creation import com.qualcomm.qti.platformvalidator.PlatformValidator; //available runtimes are defined in this class import com.qualcomm.qti.platformvalidator.PlatformValidatorUtil; ... //This create platform validator object for GPU runtime class PlatformValidator pv = new PlatformValidator(PlatformValidatorUtil.Runtime.GPU); // To check in general runtime is working use isRuntimeAvailable boolean check = pv.isRuntimeAvailable(getApplication()); // To check Qualcomm (R) Neural Processing SDK runtime is working use runtimeCheck boolean check = pv.runtimeCheck(getApplication()); //To get core version use libVersion api String str = pv.coreVersion(getApplication()); //To get core version use coreVersion api String str = pv.coreVersion(getApplication()); //List of available runtimes PlatformValidatorUtil.Runtime.CPU PlatformValidatorUtil.Runtime.GPU PlatformValidatorUtil.Runtime.DSP PlatformValidatorUtil.Runtime.GPU_FLOAT16 PlatformValidatorUtil.Runtime.AIP Copy to clipboard Qualcomm® Neural Processing SDK Java API Overview Once the dependency is added, the Qualcomm® Neural Processing SDK classes under the **com.qualcomm.qti.snpe** package will be available in the application classpath. Most applications will follow the following pattern while using a neural network: 1. Select the neural network model and runtime target 2. Create one or more input tensor(s) 3. Populate one or more input tensor(s) with the network input(s) 4. Forward propagate the input tensor(s) through the network 5. Process the network output tensor(s) The sections below describe how to implement each step described above. Configuring a Neural Network The code excerpt below illustrates how to configure and build a neural network using the JAVA APIs. final SNPE.NeuralNetworkBuilder builder = new SNPE.NeuralNetworkBuilder(application) // Allows selecting a runtime order for the network. // In the example below use DSP and fall back, in order, to GPU then CPU // depending on whether any of the runtimes is available. .setRuntimeOrder(DSP, GPU, CPU) // Loads a model from DLC file .setModel(new File("")); final NeuralNetwork network = builder.build(); ... // Calling release() once the application no longer needs the network instance // is highly recommended as it releases native resources. Alternatively the // resources will be released when the instance is garbage collected. network.release(); Copy to clipboard **Multiple ways to load a model** The SDK currently supports loading a model from a **java.io.File** within the Android device or from an **java.io.FileInputStream**. Creating an Input Tensor The code excerpt below illustrates how to create an input tensor and fill it with the input data. final FloatTensor tensor = network.createFloatTensor(height, width, depth); float[] input = // input data from application... // Fills the tensor fully tensor.write(input, 0, input.length); // Fills the tensor at a specific position tensor.write(input[0], y, x, z); // Fills the input tensors map which will be passed to execute() final Map inputsMap; inputsMap.put(/*network input name*/, tensor); Copy to clipboard **Notes about tensors** - **Reuse of input tensors** Developers are encouraged to re-use the same input tensor instance across multiple calls to NeuralNetwork.execute(..). Tensors are memory bound types and the effect of creating new instances for every execute call may have an impact in the application responsiveness. - **Batch write to tensor** Tensors are backed by native memory and writing multiple values at once, if possible, will reduce the overhead of crossing the Java and Native boundaries. Propagate Input Tensors Through the Network The excerpt of code below shows how to propagate input tensors through the neural network. final Map outputsMap = network.execute(inputsMap); for (Map.Entry output : outputsMap.entrySet()) { // An output tensor for each output layer will be returned. } Copy to clipboard Process the Neural Network Output The excerpt of code below shows how to read the output tensor of an output layer. final Map outputsMap = network.execute(inputsMap); for (Map.Entry output : outputsMap.entrySet()) { final FloatTensor tensor = output.getValue(); final float[] values = new float[tensor.getSize()]; tensor.read(values, 0, values.length); // Process the output ... } Copy to clipboard Release Input and Output Tensors Tensors are encouraged to be reused to reduce the application overhead. However, once the application no longer needs the input and/or output tensors, it is highly recommended to call release() on them to release native resources. This is particularly important for multi-threaded applications. // Release input tensors for (FloatTensor tensor: inputsMap) { tensor.release(); } // Release output tensors for (FloatTensor tensor: outputsMap) { tensor.release(); } Copy to clipboard Android Sample Application The Qualcomm® Neural Processing Android SDK includes a sample application that showcases the SDK features. The application source code is in: - $SNPE\_ROOT/examples/SNPE/android/image-classifiers Here is a screenshot of the sample: ![../images/snpe_root_sample_images.png](data:image/png;base64,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) Note that Qualcomm® Neural Processing SDK provides the following AAR file which include necessary binaries: - **snpe-release.aar**: Native binaries compiled with clang using libc++ STL. Available at $SNPE\_ROOT/lib/android/snpe-release.aar Please set environment variable SNPE\_AAR to this AAR file. Also, set the environment variable JAVA\_HOME to Java installation location. For example, export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64 Copy to clipboard To build this sample, include the Qualcomm® Neural Processing SDK AAR as described above and build with the following commands. export SNPE_AAR=snpe-release.aar cd $SNPE_ROOT/examples/SNPE/android/image-classifiers bash ./setup_inceptionv3.sh cp $SNPE_ROOT/lib/android/${SNPE_AAR} app/libs/snpe-release.aar # exporting gradle user_home is optional but suggested if USER_HOME storage is low export GRADLE_USER_HOME= export ANDROID_SDK_ROOT= ./gradlew assembleDebug Copy to clipboard **Note:** - When building the app through Android Studio with JVM VERSION >=16, you may observe **Unable to make field private final java.lang.String java.io.File.path accessible: module java.base doesnot “opens java.io” to unnamed module**. To solve this issue, either update the JAVA\_HOME to JDK < 16, or add **-–add-opens java.base/java.io=ALL-UNNAMED** in gradle.properties. - To build the sample, import the network model and sample images by invoking the **setup\_inceptionv3.sh** script as described above. - If building produces the error **gradle build failure due to“SDK location not found”**, set the environment variable ANDROID\_HOME to point to your SDK location. - Building the sample code with gradle requires Java 8. - The unsigned PD switch in the app can only be set/unset once when the model is loaded. On returning back to the menu screen and changing the option might result in unexpected behaviour. - Running networks with UDO on a specific runtime requires UDO packages for the corresponding runtime to be pushed on the device (Run setup\_inceptionv3.sh). On running a UDO network without UDO package may result in unexpected behaviour. After the build successfully completes, the output APK can be found in the application build folder: - $SNPE\_ROOT/examples/SNPE/android/image-classifiers/app/build/outputs/apk/debug Last Published: Jun 04, 2026 [Previous Topic C API Guidelines](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/c_api_guidelines.md) [Next Topic Windows Tutorial](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/build_samplecode_windows.md)