[benchmark] Run benchmark as NativeActivity application on Android

benchmark/android/README.md

@@ -0,0 +1,3 @@
+# BenchmarkRunner
+
+This app is a purely native application that can run **mbgl-benchmark-runner** on Android devices.

benchmark/android/app/build.gradle

@@ -0,0 +1,52 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 28
+
+    defaultConfig {
+        applicationId = 'com.mapbox.mapboxsdk.maps.benchmark_runner'
+        minSdkVersion 14
+        targetSdkVersion 28
+        def abi = 'all'
+        if (project.hasProperty('mapbox.abis')) {
+            abi = project.getProperty('mapbox.abis')
+        }
+        ndk {
+            if (abi != 'all') {
+                abiFilters abi.split(' ')
+            } else {
+                abiFilters 'armeabi-v7a', 'x86', 'arm64-v8a', 'x86_64'
+            }
+        }
+        externalNativeBuild {
+            cmake {
+                arguments '-DANDROID_CCACHE=ccache'
+                arguments '-DANDROID_STL=c++_static'
+                targets 'mbgl-benchmark-runner'
+            }
+        }
+        android {
+            testBuildType 'release'
+        }
+        testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
+    }
+    externalNativeBuild {
+        cmake {
+            version '3.10.2'
+            path '../../../next/CMakeLists.txt'
+        }
+    }
+    buildTypes {
+        release {
+            signingConfig signingConfigs.debug
+        }
+    }
+}
+
+dependencies {
+    implementation 'androidx.appcompat:appcompat:1.1.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+    androidTestImplementation 'androidx.test:rules:1.2.0'
+}

benchmark/android/app/src/androidTest/java/android/app/NativeActivityTest.java

@@ -0,0 +1,32 @@
+package android.app;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.LargeTest;
+import androidx.test.rule.ActivityTestRule;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.Assert;
+import org.junit.runner.RunWith;
+import android.util.Log;
+
+@LargeTest
+@RunWith(AndroidJUnit4.class)
+public class NativeActivityTest {
+
+    @Rule
+    public ActivityTestRule<NativeActivity> mActivityTestRule = new ActivityTestRule<>(NativeActivity.class, false, false);
+
+    @Test(timeout = 1200000L)
+    public void runBenchmark() throws Exception {
+        Log.v("Benchmark", "Start the benchmark");
+        mActivityTestRule.launchActivity(null);
+        while (TestState.running) {
+            Log.v("Benchmark", "Benchmark is running...");
+            Thread.sleep(1000L);
+        }
+        Log.v("Benchmark", "All benchmarks are finished!");
+        mActivityTestRule.finishActivity();
+        Assert.assertTrue("Benchmark was successfully finished", TestState.testResult);
+    }
+}

benchmark/android/app/src/androidTest/java/android/app/TestState.java

@@ -0,0 +1,6 @@
+package android.app;
+
+public class TestState {
+    static boolean running = true;
+    static boolean testResult = true;
+}

benchmark/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.mapbox.mapboxsdk.maps.benchmark_runner"
+          android:versionCode="1"
+          android:versionName="1.0">
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+  <application
+      android:allowBackup="false"
+      android:fullBackupContent="false"
+      android:icon="@mipmap/ic_launcher"
+      android:label="@string/app_name"
+      android:hasCode="true">
+
+    <activity android:name="android.app.NativeActivity"
+              android:label="@string/app_name"
+              android:configChanges="orientation|keyboardHidden"
+              android:screenOrientation="portrait">
+      <meta-data android:name="android.app.lib_name"
+                 android:value="mbgl-benchmark-runner" />
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+  </application>
+
+</manifest>

benchmark/android/app/src/main/assets/to_zip.txt

@@ -0,0 +1,3 @@
+benchmark/results/
+benchmark/fixtures/
+test/fixtures/api/assets/streets/

benchmark/android/app/src/main/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">BenchmarkRunner</string>
+</resources>

benchmark/android/build.gradle

@@ -0,0 +1,21 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+buildscript {
+    repositories {
+       google()
+       jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.5.3'
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        jcenter()
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

benchmark/android/gradle.properties

@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx1536m

benchmark/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Sun Feb 05 19:39:12 IST 2017
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip

benchmark/android/gradlew

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

benchmark/android/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

benchmark/android/settings.gradle

@@ -0,0 +1,2 @@
+include ':app'
+

benchmark/include/mbgl/benchmark.hpp

@@ -1,9 +1,7 @@
 #pragma once
 
-#include <mbgl/util/util.hpp>
-
 namespace mbgl {
 
-MBGL_EXPORT int runBenchmark(int argc, char* argv[]);
+int runBenchmark(int argc, char* argv[]);
 
 } // namespace mbgl

next/benchmark/CMakeLists.txt

@@ -1,5 +1,5 @@
 add_library(
-    mbgl-benchmark SHARED EXCLUDE_FROM_ALL
+    mbgl-benchmark STATIC EXCLUDE_FROM_ALL
     ${MBGL_ROOT}/benchmark/api/query.benchmark.cpp
     ${MBGL_ROOT}/benchmark/api/render.benchmark.cpp
     ${MBGL_ROOT}/benchmark/function/camera_function.benchmark.cpp
@@ -31,12 +31,8 @@ get_target_property(MBGL_CORE_PRIVATE_LIBRARIES mbgl-core LINK_LIBRARIES)
 
 target_link_libraries(
     mbgl-benchmark
-    PRIVATE
-        ${MBGL_CORE_PRIVATE_LIBRARIES}
-        mbgl-vendor-benchmark
-        mbgl-compiler-options
-        mbgl-core
-        $<$<PLATFORM_ID:Android>:mbgl-core-android>
+    PRIVATE ${MBGL_CORE_PRIVATE_LIBRARIES} mbgl-vendor-benchmark mbgl-compiler-options
+    PUBLIC mbgl-core
 )
 
 set_property(TARGET mbgl-benchmark PROPERTY FOLDER Core)

next/platform/android/android.cmake

@@ -334,19 +334,59 @@ target_link_libraries(
         mbgl-test
 )
 
-add_executable(
+add_library(
+    mbgl-benchmark-runner SHARED
+    ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c
+    ${MBGL_ROOT}/platform/android/src/test/benchmark_runner.cpp
+    ${MBGL_ROOT}/platform/default/src/mbgl/text/local_glyph_rasterizer.cpp
+    ${MBGL_ROOT}/platform/android/src/test/render_test_collator.cpp
+    ${MBGL_ROOT}/platform/android/src/test/render_test_number_format.cpp
+    ${MBGL_ROOT}/platform/default/src/mbgl/storage/file_source.cpp
+    ${MBGL_ROOT}/platform/default/src/mbgl/storage/default_file_source.cpp
+)
+
+target_include_directories(
     mbgl-benchmark-runner
-    ${MBGL_ROOT}/platform/android/src/test/benchmark_runner.cpp ${MBGL_ROOT}/platform/android/src/test/runtime.cpp
-    ${MBGL_ROOT}/platform/android/src/test/runtime.hpp
+    PRIVATE
+        ${ANDROID_NDK}/sources/android/native_app_glue
+        ${MBGL_ROOT}/platform/android/src
+        ${MBGL_ROOT}/src
+        ${MBGL_ROOT}/platform/default/include
 )
 
 target_link_libraries(
     mbgl-benchmark-runner
     PRIVATE
         Mapbox::Base::jni.hpp
-        mapbox-gl
+        android
+        log
         mbgl-compiler-options
+        -Wl,--whole-archive
         mbgl-benchmark
+        -Wl,--no-whole-archive
+)
+
+add_custom_command(
+    TARGET mbgl-benchmark-runner PRE_BUILD
+    COMMAND
+        ${CMAKE_COMMAND}
+        -E
+        make_directory
+        ${MBGL_ROOT}/benchmark/results
+    COMMAND
+        ${CMAKE_COMMAND}
+        -E
+        tar
+        "chf"
+        "benchmark/android/app/src/main/assets/data.zip"
+        --format=zip
+        --files-from=benchmark/android/app/src/main/assets/to_zip.txt
+    COMMAND
+        ${CMAKE_COMMAND}
+        -E
+        remove_directory
+        ${MBGL_ROOT}/benchmark/results
+    WORKING_DIRECTORY ${MBGL_ROOT}
 )
 
 add_library(

next/platform/linux/linux.cmake

@@ -106,7 +106,11 @@ add_executable(
 
 target_link_libraries(
     mbgl-benchmark-runner
-    PRIVATE mbgl-compiler-options mbgl-benchmark
+    PRIVATE
+        mbgl-compiler-options
+        -Wl,--whole-archive
+        mbgl-benchmark
+        -Wl,--no-whole-archive
 )
 
 add_executable(

platform/android/src/test/benchmark_runner.cpp

@@ -1,10 +1,312 @@
-#include "runtime.hpp"
+#include <android_native_app_glue.h>
 #include <mbgl/benchmark.hpp>
+#include <mbgl/util/logging.hpp>
 
-int main(int argc, char *argv[]) {
-    if (!mbgl::android::initRuntime(argc, argv)) {
-        return 1;
+#include <android/asset_manager.h>
+#include <android/log.h>
+
+#include "jni.hpp"
+
+#include <unistd.h>
+#include <cstdio>
+#include <string>
+#include <thread>
+
+namespace mbgl {
+
+namespace {
+
+int severityToPriority(EventSeverity severity) {
+    switch (severity) {
+        case EventSeverity::Debug:
+            return ANDROID_LOG_DEBUG;
+        case EventSeverity::Info:
+            return ANDROID_LOG_INFO;
+        case EventSeverity::Warning:
+            return ANDROID_LOG_WARN;
+        case EventSeverity::Error:
+            return ANDROID_LOG_ERROR;
+        default:
+            return ANDROID_LOG_VERBOSE;
+    }
+}
+
+} // namespace
+
+void Log::platformRecord(EventSeverity severity, const std::string& msg) {
+    __android_log_print(severityToPriority(severity), "mbgl", "%s", msg.c_str());
+}
+
+} // namespace mbgl
+
+namespace {
+
+template <class T>
+class JavaWrapper {
+public:
+    JavaWrapper(JNIEnv* env_, T obj_) : env(env_), obj(obj_) {}
+    ~JavaWrapper() {
+        env->DeleteLocalRef(obj);
+        env = nullptr;
+        obj = NULL;
+    }
+    T& get() { return obj; }
+
+private:
+    JavaWrapper() = delete;
+    JNIEnv* env;
+    T obj;
+};
+
+void changeState(JNIEnv* env, struct android_app* app, bool result) {
+    jobject nativeActivity = app->activity->clazz;
+    jclass acl = env->GetObjectClass(nativeActivity);
+    jmethodID getClassLoader = env->GetMethodID(acl, "getClassLoader", "()Ljava/lang/ClassLoader;");
+    jobject cls = env->CallObjectMethod(nativeActivity, getClassLoader);
+    JavaWrapper<jclass> classLoader(env, env->FindClass("java/lang/ClassLoader"));
+    jmethodID findClass = env->GetMethodID(classLoader.get(), "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+    JavaWrapper<jstring> strClassName(env, env->NewStringUTF("android.app.TestState"));
+    jclass testStateClass = static_cast<jclass>(env->CallObjectMethod(cls, findClass, strClassName.get()));
+    if (testStateClass != NULL) {
+        jfieldID id0 = env->GetStaticFieldID(testStateClass, "testResult", "Z");
+        env->SetStaticBooleanField(testStateClass, id0, result);
+        jfieldID id = env->GetStaticFieldID(testStateClass, "running", "Z");
+        env->SetStaticBooleanField(testStateClass, id, false);
+    }
+}
+
+bool copyFile(JNIEnv* env,
+              AAssetManager* assetManager,
+              const std::string& filePath,
+              const std::string& destinationPath,
+              const std::string& fileName) {
+    JavaWrapper<jclass> fileClass(env, env->FindClass("java/io/File"));
+    jmethodID fileCtor = env->GetMethodID(fileClass.get(), "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+    jmethodID fileExists = env->GetMethodID(fileClass.get(), "exists", "()Z");
+
+    JavaWrapper<jstring> destination(env, env->NewStringUTF(destinationPath.c_str()));
+    JavaWrapper<jstring> file(env, env->NewStringUTF(fileName.c_str()));
+    JavaWrapper<jobject> fileToCopy(env, env->NewObject(fileClass.get(), fileCtor, destination.get(), file.get()));
+
+    bool stateOk = true;
+    if (env->CallBooleanMethod(fileToCopy.get(), fileExists)) {
+        mbgl::Log::Warning(mbgl::Event::General, "File '%s' already exists", filePath.c_str());
+    } else {
+        std::unique_ptr<AAsset, std::function<void(AAsset*)>> fileAsset(
+            AAssetManager_open(assetManager, fileName.c_str(), AASSET_MODE_BUFFER),
+            [](AAsset* asset) { AAsset_close(asset); });
+        if (fileAsset == nullptr) {
+            mbgl::Log::Warning(mbgl::Event::General, "Failed to open asset file %s", fileName.c_str());
+            return false;
+        }
+        const void* fileData = AAsset_getBuffer(fileAsset.get());
+        const off_t fileLen = AAsset_getLength(fileAsset.get());
+
+        std::unique_ptr<FILE, std::function<void(FILE*)>> newFile(std::fopen(filePath.c_str(), "w+"),
+                                                                  [](FILE* file) { std::fclose(file); });
+        stateOk = newFile != nullptr;
+
+        if (!stateOk) {
+            mbgl::Log::Warning(mbgl::Event::General, "Failed to create new file entry %s", fileName.c_str());
+        } else {
+            auto res = static_cast<off_t>(std::fwrite(fileData, sizeof(char), fileLen, newFile.get()));
+            if (fileLen != res) {
+                mbgl::Log::Warning(
+                    mbgl::Event::General, "Failed to generate file entry %s from assets", fileName.c_str());
+            }
+        }
+    }
+    return stateOk;
+}
+
+std::string jstringToStdString(JNIEnv* env, jstring jStr) {
+    if (!jStr) {
+        return std::string();
     }
 
-    return mbgl::runBenchmark(argc, argv);
+    JavaWrapper<jclass> stringClass(env, env->GetObjectClass(jStr));
+    const jmethodID getBytes = env->GetMethodID(stringClass.get(), "getBytes", "(Ljava/lang/String;)[B");
+    JavaWrapper<jbyteArray> stringJbytes(
+        env,
+        static_cast<jbyteArray>(
+            env->CallObjectMethod(jStr, getBytes, JavaWrapper<jstring>(env, env->NewStringUTF("UTF-8")).get())));
+
+    size_t length = static_cast<size_t>(env->GetArrayLength(stringJbytes.get()));
+    jbyte* pBytes = env->GetByteArrayElements(stringJbytes.get(), NULL);
+
+    std::string ret = std::string(reinterpret_cast<char*>(pBytes), length);
+    env->ReleaseByteArrayElements(stringJbytes.get(), pBytes, JNI_ABORT);
+
+    return ret;
+}
+
+void unZipFile(JNIEnv* env, const std::string& zipFilePath, const std::string& destinationPath) {
+    JavaWrapper<jclass> fileClassWrapper(env, env->FindClass("java/io/File"));
+    auto fileClass = fileClassWrapper.get();
+    jmethodID fileCtor = env->GetMethodID(fileClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+    jmethodID fileExists = env->GetMethodID(fileClass, "exists", "()Z");
+    jmethodID fileIsDirectory = env->GetMethodID(fileClass, "isDirectory", "()Z");
+    jmethodID deleteFile = env->GetMethodID(fileClass, "delete", "()Z");
+    jmethodID createNewFile = env->GetMethodID(fileClass, "createNewFile", "()Z");
+    jmethodID fileGetName = env->GetMethodID(fileClass, "getName", "()Ljava/lang/String;");
+
+    JavaWrapper<jclass> fileInputStreamWrapper(env, env->FindClass("java/io/FileInputStream"));
+    auto fileInputStream = fileInputStreamWrapper.get();
+    jmethodID finCtor = env->GetMethodID(fileInputStream, "<init>", "(Ljava/lang/String;)V");
+
+    JavaWrapper<jclass> fileOutputStreamWrapper(env, env->FindClass("java/io/FileOutputStream"));
+    auto fileOutputStream = fileOutputStreamWrapper.get();
+    jmethodID foutCtor = env->GetMethodID(fileOutputStream, "<init>", "(Ljava/io/File;)V");
+    jmethodID foutClose = env->GetMethodID(fileOutputStream, "close", "()V");
+    jmethodID foutWrite = env->GetMethodID(fileOutputStream, "write", "([BII)V");
+
+    JavaWrapper<jclass> zipInputStreamWrapper(env, env->FindClass("java/util/zip/ZipInputStream"));
+    auto zipInputStream = zipInputStreamWrapper.get();
+    jmethodID zinCtor = env->GetMethodID(zipInputStream, "<init>", "(Ljava/io/InputStream;)V");
+    jmethodID zinGetNextEntry = env->GetMethodID(zipInputStream, "getNextEntry", "()Ljava/util/zip/ZipEntry;");
+    jmethodID zinRead = env->GetMethodID(zipInputStream, "read", "([B)I");
+    jmethodID zinCloseEntry = env->GetMethodID(zipInputStream, "closeEntry", "()V");
+
+    JavaWrapper<jclass> zipEntryWrapper(env, env->FindClass("java/util/zip/ZipEntry"));
+    auto zipEntry = zipEntryWrapper.get();
+    jmethodID zipGetName = env->GetMethodID(zipEntry, "getName", "()Ljava/lang/String;");
+    jmethodID zipIsDirectory = env->GetMethodID(zipEntry, "isDirectory", "()Z");
+
+    // Unzip the resource folder to destination path
+    JavaWrapper<jstring> destination(env, env->NewStringUTF(destinationPath.c_str()));
+    JavaWrapper<jstring> zipFile(env, env->NewStringUTF(zipFilePath.c_str()));
+    JavaWrapper<jobject> fileIn(env, env->NewObject(fileInputStream, finCtor, zipFile.get()));
+    JavaWrapper<jobject> zipIn(env, env->NewObject(zipInputStream, zinCtor, fileIn.get()));
+
+    while (true) {
+        JavaWrapper<jobject> obj(env, env->CallObjectMethod(zipIn.get(), zinGetNextEntry));
+        jobject zEntry = obj.get();
+        if (zEntry == NULL) {
+            break;
+        }
+        jstring dir = static_cast<jstring>(env->CallObjectMethod(zEntry, zipGetName));
+        std::string name = jstringToStdString(env, dir);
+        bool isDir = env->CallBooleanMethod(zEntry, zipIsDirectory);
+
+        JavaWrapper<jobject> fileHandle(env, env->NewObject(fileClass, fileCtor, destination.get(), dir));
+        jobject& f = fileHandle.get();
+        std::string fileName = jstringToStdString(env, static_cast<jstring>(env->CallObjectMethod(f, fileGetName)));
+
+        if (isDir) {
+            if (!(env->CallBooleanMethod(f, fileIsDirectory))) {
+                jmethodID mkdirs = env->GetMethodID(fileClass, "mkdirs", "()Z");
+                bool success = (env->CallBooleanMethod(f, mkdirs));
+                std::string fileNameStr =
+                    jstringToStdString(env, static_cast<jstring>(env->CallObjectMethod(f, fileGetName)));
+
+                if (!success) {
+                    mbgl::Log::Warning(
+                        mbgl::Event::General, "Failed to create folder entry %s from zip", fileNameStr.c_str());
+                }
+            }
+        } else if (!(env->CallBooleanMethod(f, fileExists))) {
+            bool success = env->CallBooleanMethod(f, createNewFile);
+            std::string fileNameStr =
+                jstringToStdString(env, static_cast<jstring>(env->CallObjectMethod(f, fileGetName)));
+
+            if (!success) {
+                mbgl::Log::Warning(
+                    mbgl::Event::General, "Failed to create folder entry %s from zip", fileNameStr.c_str());
+                continue;
+            }
+
+            JavaWrapper<jobject> fout(env, env->NewObject(fileOutputStream, foutCtor, f));
+            JavaWrapper<jbyteArray> jBuff(env, env->NewByteArray(2048));
+
+            int count;
+            while ((count = env->CallIntMethod(zipIn.get(), zinRead, jBuff.get())) != -1) {
+                env->CallVoidMethod(fout.get(), foutWrite, jBuff.get(), 0, count);
+            }
+
+            env->CallVoidMethod(zipIn.get(), zinCloseEntry);
+            env->CallVoidMethod(fout.get(), foutClose);
+        }
+    }
+
+    JavaWrapper<jobject> fileToDelete(env, env->NewObject(fileClass, fileCtor, destination.get(), zipFile.get()));
+    if (env->CallBooleanMethod(fileToDelete.get(), fileExists)) {
+        jboolean success = (env->CallBooleanMethod(fileToDelete.get(), deleteFile));
+        if (!success) {
+            mbgl::Log::Warning(mbgl::Event::General, "Failed to delete file entry %s", zipFilePath.c_str());
+        }
+    }
+}
+
+} // namespace
+
+bool running = false;
+bool done = false;
+ALooper* looper = NULL;
+
+void runner() {
+    std::vector<std::string> arguments = {"mbgl-benchmark-runner",
+                                          "--benchmark_repetitions=3",
+                                          "--benchmark_format=json",
+                                          "--benchmark_out=/sdcard/benchmark/results/results.json"};
+    std::vector<char*> argv;
+    for (const auto& arg : arguments) {
+        argv.push_back(const_cast<char*>(arg.data()));
+    }
+    argv.push_back(nullptr);
+
+    mbgl::Log::Info(mbgl::Event::General, "Start BenchmarkRunner");
+    int status = mbgl::runBenchmark(argv.size(), argv.data());
+    mbgl::Log::Info(mbgl::Event::General, "BenchmarkRunner finished with status: '%d'", status);
+    running = false;
+    ALooper_wake(looper);
+}
+
+void android_main(struct android_app* app) {
+    mbgl::android::theJVM = app->activity->vm;
+    JNIEnv* env = nullptr;
+    std::thread benchmarkThread;
+    app->activity->vm->AttachCurrentThread(&env, NULL);
+    looper = ALooper_forThread();
+
+    std::string storagePath(app->activity->internalDataPath);
+    std::string zipFile = storagePath + "/data.zip";
+
+    if (copyFile(env, app->activity->assetManager, zipFile, storagePath, "data.zip")) {
+        if (chdir("/sdcard")) {
+            mbgl::Log::Error(mbgl::Event::General, "Failed to change the directory to /sdcard");
+            done = true;
+            changeState(env, app, false);
+        } else {
+            unZipFile(env, zipFile, "/sdcard/");
+            running = true;
+            benchmarkThread = std::thread(runner);
+        }
+    } else {
+        mbgl::Log::Error(mbgl::Event::General, "Failed to copy zip file '%s' to external storage", zipFile.c_str());
+        done = true;
+        changeState(env, app, false);
+    }
+
+    int outFd, outEvents;
+    struct android_poll_source* source = nullptr;
+
+    while (true) {
+        ALooper_pollAll(-1, &outFd, &outEvents, reinterpret_cast<void**>(&source));
+        if (source != nullptr) {
+            source->process(app, source);
+        }
+
+        if (!running && !done) {
+            mbgl::Log::Info(mbgl::Event::General, "BenchmarkRunner done");
+            done = true;
+            benchmarkThread.join();
+            changeState(env, app, true);
+        }
+
+        if (app->destroyRequested != 0) {
+            app->activity->vm->DetachCurrentThread();
+            mbgl::Log::Info(mbgl::Event::General, "Close the App!");
+            return;
+        }
+    }
 }