From 3a55c123d7dd0d66b315a990de884e681ddf1896 Mon Sep 17 00:00:00 2001
From: Igor Chevdar <igor.chevdar@jetbrains.com>
Date: Wed, 14 Jun 2017 15:00:27 +0300
Subject: [PATCH] Sample: textured dodecahedron rotated by fingers

---
 build.gradle                                  |   4 +-
 runtime/src/launcher/cpp/androidLauncher.cpp  |  49 +--
 runtime/src/launcher/cpp/androidLauncher.h    |   2 +-
 runtime/src/launcher/cpp/launcher.cpp         |   2 +-
 runtime/src/main/cpp/KString.cpp              |   6 +-
 samples/androidNativeActivity/README.md       |  10 +
 samples/androidNativeActivity/android.def     |   8 +
 samples/androidNativeActivity/build.gradle    | 118 +++++++
 .../src/main/AndroidManifest.xml              |  35 +++
 .../src/main/assets/kotlin_logo.bmp           | Bin 0 -> 49206 bytes
 .../src/main/kotlin/engine.kt                 | 198 ++++++++++++
 .../src/main/kotlin/polyhedra.kt              |  58 ++++
 .../src/main/kotlin/renderer.kt               | 291 ++++++++++++++++++
 .../src/main/kotlin/vectors.kt                |  63 ++++
 .../main/res/mipmap-hdpi/konan_activity.png   | Bin 0 -> 4654 bytes
 .../main/res/mipmap-mdpi/konan_activity.png   | Bin 0 -> 2479 bytes
 .../main/res/mipmap-xhdpi/konan_activity.png  | Bin 0 -> 6120 bytes
 .../main/res/mipmap-xxhdpi/konan_activity.png | Bin 0 -> 11950 bytes
 .../src/main/res/values/strings.xml           |   4 +
 samples/settings.gradle                       |   1 +
 20 files changed, 819 insertions(+), 30 deletions(-)
 create mode 100644 samples/androidNativeActivity/README.md
 create mode 100644 samples/androidNativeActivity/android.def
 create mode 100644 samples/androidNativeActivity/build.gradle
 create mode 100644 samples/androidNativeActivity/src/main/AndroidManifest.xml
 create mode 100644 samples/androidNativeActivity/src/main/assets/kotlin_logo.bmp
 create mode 100644 samples/androidNativeActivity/src/main/kotlin/engine.kt
 create mode 100644 samples/androidNativeActivity/src/main/kotlin/polyhedra.kt
 create mode 100644 samples/androidNativeActivity/src/main/kotlin/renderer.kt
 create mode 100644 samples/androidNativeActivity/src/main/kotlin/vectors.kt
 create mode 100755 samples/androidNativeActivity/src/main/res/mipmap-hdpi/konan_activity.png
 create mode 100755 samples/androidNativeActivity/src/main/res/mipmap-mdpi/konan_activity.png
 create mode 100755 samples/androidNativeActivity/src/main/res/mipmap-xhdpi/konan_activity.png
 create mode 100755 samples/androidNativeActivity/src/main/res/mipmap-xxhdpi/konan_activity.png
 create mode 100644 samples/androidNativeActivity/src/main/res/values/strings.xml

diff --git a/build.gradle b/build.gradle
index fdc79f87a39..4f814ea1818 100644
--- a/build.gradle
+++ b/build.gradle
@@ -138,14 +138,14 @@ void setupCompilationFlags() {
                  "android_arm32":
                          ["-target", getTargetArg("android_arm32"),
                           "--sysroot=$android_arm32SysrootDir",
-                          "-D__ANDROID__", "-DUSE_GCC_UNWIND=1", "-DUSE_ELF_SYMBOLS=1", "-DELFSIZE=32", "-DANDROID",
+                          "-D__ANDROID__", "-DUSE_GCC_UNWIND=1", "-DUSE_ELF_SYMBOLS=1", "-DELFSIZE=32", "-DKONAN_ANDROID",
                           // HACKS!
                           "-I$android_arm32SysrootDir/usr/include/c++/4.9.x",
                           "-I$android_arm32SysrootDir/usr/include/c++/4.9.x/arm-linux-androideabi"],
                  "android_arm64":
                         ["-target", getTargetArg("android_arm64"),
                          "--sysroot=$android_arm64SysrootDir",
-                         "-D__ANDROID__", "-DUSE_GCC_UNWIND=1", "-DUSE_ELF_SYMBOLS=1", "-DELFSIZE=64", "-DANDROID",
+                         "-D__ANDROID__", "-DUSE_GCC_UNWIND=1", "-DUSE_ELF_SYMBOLS=1", "-DELFSIZE=64", "-DKONAN_ANDROID",
                          // HACKS!
                          "-I$android_arm64SysrootDir/usr/include/c++/4.9.x",
                          "-I$android_arm64SysrootDir/usr/include/c++/4.9.x/aarch64-linux-android"]
diff --git a/runtime/src/launcher/cpp/androidLauncher.cpp b/runtime/src/launcher/cpp/androidLauncher.cpp
index d0f32deb001..aa40c34cb02 100644
--- a/runtime/src/launcher/cpp/androidLauncher.cpp
+++ b/runtime/src/launcher/cpp/androidLauncher.cpp
@@ -20,7 +20,8 @@
 #include "KString.h"
 #include "Types.h"
 
-#ifdef ANDROID
+#ifdef KONAN_ANDROID
+
 #include <unistd.h>
 #include <pthread.h>
 #include <sys/types.h>
@@ -43,9 +44,11 @@
 //--- main --------------------------------------------------------------------//
 extern "C" KInt Konan_start(const ObjHeader*);
 
-static int pipeC, pipeKonan;
+namespace {
+int pipeC, pipeKonan;
 
-static NativeActivityState nativeActivityState;
+NativeActivityState nativeActivityState;
+}
 
 extern "C" void getNativeActivityState(NativeActivityState* state) {
   state->activity = nativeActivityState.activity;
@@ -54,13 +57,13 @@ extern "C" void getNativeActivityState(NativeActivityState* state) {
   state->looper = nativeActivityState.looper;
 }
 
-extern "C" void notifySysEventProcessed(int fd) {
-  if (fd != pipeKonan) return;
+extern "C" void notifySysEventProcessed() {
   int8_t message;
   write(pipeKonan, &message, sizeof(message));
 }
 
-static void* entry(void* param) {
+namespace {
+void* entry(void* param) {
   ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
   ALooper_addFd(looper, pipeKonan, LOOPER_ID_SYS, ALOOPER_EVENT_INPUT, NULL, NULL);
   nativeActivityState.looper = looper;
@@ -83,7 +86,7 @@ static void* entry(void* param) {
   return nullptr;
 }
 
-static void runKonan_start() {
+void runKonan_start() {
   int pipes[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipes)) {
     LOGE("Could not create pipe: %s", strerror(errno));
@@ -99,7 +102,7 @@ static void runKonan_start() {
   pthread_create(&thread, &attr, entry, nullptr);
 }
 
-static void putEventSynchronously(void* event) {
+void putEventSynchronously(void* event) {
   uint64_t value = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(event));
   if (write(pipeC, &value, sizeof(value)) != sizeof(value)) {
     LOGE("Failure writing event: %s\n", strerror(errno));
@@ -110,25 +113,25 @@ static void putEventSynchronously(void* event) {
   }
 }
 
-static void onDestroy(ANativeActivity* activity) {
+void onDestroy(ANativeActivity* activity) {
   LOGV("onDestroy called");
   NativeActivityEvent event = { DESTROY };
   putEventSynchronously(&event);
 }
 
-static void onStart(ANativeActivity* activity) {
+void onStart(ANativeActivity* activity) {
   LOGV("onStart called");
   NativeActivityEvent event = { START };
   putEventSynchronously(&event);
 }
 
-static void onResume(ANativeActivity* activity) {
+void onResume(ANativeActivity* activity) {
   LOGV("onResume called");
   NativeActivitySaveStateEvent event = { RESUME };
   putEventSynchronously(&event);
 }
 
-static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
+void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
   LOGV("onSaveInstanceState called");
   NativeActivitySaveStateEvent event = { SAVE_INSTANCE_STATE };
   putEventSynchronously(&event);
@@ -136,61 +139,61 @@ static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
   return event.savedState;
 }
 
-static void onPause(ANativeActivity* activity) {
+void onPause(ANativeActivity* activity) {
   LOGV("onPause called");
   NativeActivityEvent event = { PAUSE };
   putEventSynchronously(&event);
 }
 
-static void onStop(ANativeActivity* activity) {
+void onStop(ANativeActivity* activity) {
   LOGV("onStop called");
   NativeActivityEvent event = { STOP };
   putEventSynchronously(&event);
 }
 
-static void onConfigurationChanged(ANativeActivity* activity) {
+void onConfigurationChanged(ANativeActivity* activity) {
   LOGV("onConfigurationChanged called");
   NativeActivityEvent event = { CONFIGURATION_CHANGED };
   putEventSynchronously(&event);
 }
 
-static void onLowMemory(ANativeActivity* activity) {
+void onLowMemory(ANativeActivity* activity) {
   LOGV("onLowMemory called");
   NativeActivityEvent event = { LOW_MEMORY };
   putEventSynchronously(&event);
 }
 
-static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
+void onWindowFocusChanged(ANativeActivity* activity, int focused) {
   LOGV("onWindowFocusChanged called");
   NativeActivityEvent event = { focused ? WINDOW_GAINED_FOCUS : WINDOW_LOST_FOCUS };
   putEventSynchronously(&event);
 }
 
-static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
+void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
   LOGV("onNativeWindowCreated called");
   NativeActivityWindowEvent event = { NATIVE_WINDOW_CREATED, window };
   putEventSynchronously(&event);
 }
 
-static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
+void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
   LOGV("onNativeWindowDestroyed called");
   NativeActivityWindowEvent event = { NATIVE_WINDOW_DESTROYED, window };
   putEventSynchronously(&event);
 }
 
-static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
+void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
   LOGV("onInputQueueCreated called");
   NativeActivityQueueEvent event = { INPUT_QUEUE_CREATED, queue };
   putEventSynchronously(&event);
 }
 
-static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
+void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
   LOGV("onInputQueueDestroyed called");
   NativeActivityQueueEvent event = { INPUT_QUEUE_DESTROYED, queue };
   putEventSynchronously(&event);
 }
+}
 
-// ANativeActivity_onCreate.
 extern "C" void Konan_main(ANativeActivity* activity, void* savedState, size_t savedStateSize) {
   nativeActivityState = {activity, savedState, savedStateSize};
 
@@ -211,4 +214,4 @@ extern "C" void Konan_main(ANativeActivity* activity, void* savedState, size_t s
   runKonan_start();
 }
 
-#endif
\ No newline at end of file
+#endif // KONAN_ANDROID
\ No newline at end of file
diff --git a/runtime/src/launcher/cpp/androidLauncher.h b/runtime/src/launcher/cpp/androidLauncher.h
index 4e6ff4b405a..d1a3cb359ff 100644
--- a/runtime/src/launcher/cpp/androidLauncher.h
+++ b/runtime/src/launcher/cpp/androidLauncher.h
@@ -36,7 +36,7 @@ struct NativeActivityState {
 
 void getNativeActivityState(struct NativeActivityState* state);
 
-void notifySysEventProcessed(int fd);
+void notifySysEventProcessed();
 
 #define LOOPER_ID_SYS 1
 
diff --git a/runtime/src/launcher/cpp/launcher.cpp b/runtime/src/launcher/cpp/launcher.cpp
index 4b73b97397e..7f92019342e 100644
--- a/runtime/src/launcher/cpp/launcher.cpp
+++ b/runtime/src/launcher/cpp/launcher.cpp
@@ -20,7 +20,7 @@
 #include "KString.h"
 #include "Types.h"
 
-#ifndef ANDROID
+#ifndef KONAN_ANDROID
 
 //--- Setup args --------------------------------------------------------------//
 
diff --git a/runtime/src/main/cpp/KString.cpp b/runtime/src/main/cpp/KString.cpp
index c54c40790db..fba50b24ec4 100644
--- a/runtime/src/main/cpp/KString.cpp
+++ b/runtime/src/main/cpp/KString.cpp
@@ -34,7 +34,7 @@
 
 #include "utf8.h"
 
-#ifdef ANDROID
+#ifdef KONAN_ANDROID
 #include <android/log.h>
 #endif
 
@@ -1133,7 +1133,7 @@ void Kotlin_io_Console_print(KString message) {
   const KChar* utf16 = CharArrayAddressOfElementAt(message, 0);
   std::string utf8;
   utf8::utf16to8(utf16, utf16 + message->count_, back_inserter(utf8));
-  #ifdef ANDROID
+  #ifdef KONAN_ANDROID
   __android_log_print(ANDROID_LOG_INFO, "Konan_main", "%s", utf8.c_str());
   #else
   write(STDOUT_FILENO, utf8.c_str(), utf8.size());
@@ -1146,7 +1146,7 @@ void Kotlin_io_Console_println(KString message) {
 }
 
 void Kotlin_io_Console_println0() {
-  #ifdef ANDROID
+  #ifdef KONAN_ANDROID
   __android_log_print(ANDROID_LOG_INFO, "Konan_main", "\n");
   #else
   write(STDOUT_FILENO, "\n", 1);
diff --git a/samples/androidNativeActivity/README.md b/samples/androidNativeActivity/README.md
new file mode 100644
index 00000000000..04b8f5c1f03
--- /dev/null
+++ b/samples/androidNativeActivity/README.md
@@ -0,0 +1,10 @@
+# Android Native Activity
+ This example shows how to build an Android Native Activity.
+
+The example will render a textured dodecahedron using OpenGL ES library. It can be rotated with fingers.
+Please make sure that Android SDK version 25 is installed, using Android SDK manager.
+
+To build use `ANDROID_HOME=<your path to android sdk> ../gradlew buildApk`.
+
+Run `adb install build/outputs/apk/androidNativeActivity-arm-debug.apk` to deploy the apk on Android device or emulator
+(note that only ARM-based devices are currently supported).
diff --git a/samples/androidNativeActivity/android.def b/samples/androidNativeActivity/android.def
new file mode 100644
index 00000000000..d81fd536871
--- /dev/null
+++ b/samples/androidNativeActivity/android.def
@@ -0,0 +1,8 @@
+headers = stdio.h stdlib.h string.h math.h time.h android/log.h androidLauncher.h EGL/egl.h GLES/gl.h
+excludeDependentModules.osx = true
+
+---
+
+static int interop_errno() {
+	return errno;
+}
diff --git a/samples/androidNativeActivity/build.gradle b/samples/androidNativeActivity/build.gradle
new file mode 100644
index 00000000000..4e1bd8ef218
--- /dev/null
+++ b/samples/androidNativeActivity/build.gradle
@@ -0,0 +1,118 @@
+buildscript {
+    repositories {
+       jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle-experimental:0.9.2'
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
+
+apply plugin: "konan"
+
+konanInterop {
+    arm32 {
+        defFile "android.def"
+        pkg "android"
+        includeDirs "../../runtime/src/launcher/cpp"
+        target "android_arm32"
+    }
+    arm64 {
+        defFile "android.def"
+        pkg "android"
+        includeDirs "../../runtime/src/launcher/cpp"
+        target "android_arm64"
+    }
+}
+
+konanArtifacts {
+    PolyhedronArm32 {
+        useInterop "arm32"
+        target "android_arm32"
+    }
+    PolyhedronArm64 {
+        useInterop "arm64"
+        target "android_arm64"
+    }
+}
+
+def platforms = ["armeabi-v7a", "arm64-v8a"]
+def artifacts = ["PolyhedronArm32", "PolyhedronArm64"]
+
+apply plugin: "com.android.model.application"
+
+model {
+    android {
+        compileSdkVersion = 25
+        buildToolsVersion = '25.0.2'
+
+        defaultConfig {
+            applicationId = 'com.android.konan_activity'
+            minSdkVersion.apiLevel   9
+            targetSdkVersion.apiLevel  25
+        }
+
+        ndk {
+            moduleName = "polyhedron"
+        }
+
+        productFlavors {
+            create("arm") {
+                ndk {
+                    abiFilters.addAll(platforms)
+                }
+            }
+        }
+    }
+
+    repositories {
+        libs(PrebuiltLibraries) {
+            libpoly {
+                    binaries.withType(SharedLibraryBinary) {
+                        def name = targetPlatform.getName()
+                        def index = platforms.indexOf(name)
+                        if (index >= 0)
+                            sharedLibraryFile = file("build/konan/bin/${artifacts[index]}/libpoly.so")
+                    }
+            }
+        }
+    }
+    android.sources {
+        main {
+            jniLibs {
+                dependencies {
+                    library "libpoly" 
+                }
+            }
+        }
+    }
+}
+
+task renameArtifacts << {
+    for (artifact in artifacts) {
+        copy {
+            from "build/konan/bin/${artifact}"
+            into "build/konan/bin/${artifact}"
+            rename "${artifact}.kexe", "libpoly.so"
+        }
+    }
+}
+
+renameArtifacts.dependsOn "compileKonanPolyhedronArm32"
+renameArtifacts.dependsOn "compileKonanPolyhedronArm64"
+
+tasks.matching { it.name == 'preBuild' }.all {
+    it.dependsOn 'renameArtifacts'
+}
+
+task buildApk(type: DefaultTask) {
+    dependsOn "compileKonanPolyhedronArm32"
+    dependsOn "compileKonanPolyhedronArm64"
+    dependsOn "renameArtifacts"
+    dependsOn "assembleDebug"
+}
\ No newline at end of file
diff --git a/samples/androidNativeActivity/src/main/AndroidManifest.xml b/samples/androidNativeActivity/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..e9c2ffe931c
--- /dev/null
+++ b/samples/androidNativeActivity/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- BEGIN_INCLUDE(manifest) -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="polyhedron"
+          android:versionCode="1"
+          android:versionName="1.0">
+
+  <!-- This .apk has no Java code itself, so set hasCode to false. -->
+  <application
+      android:allowBackup="false"
+      android:fullBackupContent="false"
+      android:icon="@mipmap/konan_activity"
+      android:label="@string/app_name"
+      android:hasCode="false">
+
+    <!-- Our activity is the built-in NativeActivity framework class.
+         This will take care of integrating with our NDK code. -->
+    <activity android:name="android.app.NativeActivity"
+              android:label="@string/app_name"
+              android:configChanges="orientation|keyboardHidden">
+      <!-- Tell NativeActivity the name of our .so -->
+      <meta-data android:name="android.app.lib_name"
+                 android:value="poly" />
+      <meta-data android:name="android.app.func_name"
+                 android:value="Konan_main" />
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+  </application>
+
+</manifest>
+<!-- END_INCLUDE(manifest) -->
+
diff --git a/samples/androidNativeActivity/src/main/assets/kotlin_logo.bmp b/samples/androidNativeActivity/src/main/assets/kotlin_logo.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..3311764c70db8e17a9d5c0616b941c47e16893cf
GIT binary patch
literal 49206
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
RyU~L2x#Hme{uCO4{|~l#)=mHb

literal 0
HcmV?d00001

diff --git a/samples/androidNativeActivity/src/main/kotlin/engine.kt b/samples/androidNativeActivity/src/main/kotlin/engine.kt
new file mode 100644
index 00000000000..d6010647a98
--- /dev/null
+++ b/samples/androidNativeActivity/src/main/kotlin/engine.kt
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import kotlinx.cinterop.*
+import android.*
+
+private fun logError(message: String) {
+    __android_log_write(ANDROID_LOG_ERROR, "KonanActivity", message)
+}
+
+private fun logInfo(message: String) {
+    __android_log_write(ANDROID_LOG_INFO, "KonanActivity", message)
+}
+
+val errno: Int
+    get() = interop_errno()
+
+fun getUnixError() = strerror(errno)!!.toKString()
+
+const val LOOPER_ID_INPUT = 2
+
+fun main(args: Array<String>) {
+    logInfo("Hello world!")
+    memScoped {
+        val state = alloc<NativeActivityState>()
+        getNativeActivityState(state.ptr)
+        val engine = Engine(this, state)
+        engine.mainLoop()
+    }
+}
+
+class Engine(val arena: NativePlacement, val state: NativeActivityState) {
+    private val renderer = Renderer(arena, state.activity!!.pointed)
+    private var queue: CPointer<AInputQueue>? = null
+
+    private var currentPoint = Vector2.Zero
+    private var startPoint = Vector2.Zero
+    private var startTime = 0.0f
+    private var animationEndTime = 0.0f
+    private var velocity = Vector2.Zero
+    private var acceleration = Vector2.Zero
+
+    private var needRedraw = true
+    private var animating = false
+
+    fun mainLoop() {
+        while (true) {
+            // Process events.
+            memScoped {
+                eventLoop@while (true) {
+                    val fd = alloc<IntVar>()
+                    val id = ALooper_pollAll(if (needRedraw || animating) 0 else -1, fd.ptr, null, null)
+                    if (id < 0) break@eventLoop
+                    when (id) {
+                        LOOPER_ID_SYS -> {
+                            if (!processSysEvent(fd))
+                                return // An error occured.
+                        }
+
+                        LOOPER_ID_INPUT -> processUserInput()
+                    }
+                }
+            }
+            when {
+                animating -> {
+                    val elapsed = getTime() - startTime
+                    if (elapsed >= animationEndTime) {
+                        animating = false
+                    } else {
+                        move(startPoint + velocity * elapsed + acceleration * (elapsed * elapsed * 0.5f))
+                        renderer.draw()
+                    }
+                }
+
+                needRedraw -> renderer.draw()
+            }
+        }
+    }
+
+    private fun processSysEvent(fd: IntVar): Boolean = memScoped {
+        val ptr = allocArray<LongVar>(1)
+        val readBytes = read(fd.value, ptr, 8).toLong()
+        if (readBytes != 8L) {
+            logError("Failure reading event, $readBytes read: ${getUnixError()}")
+            return true
+        }
+        try {
+            val event = ptr[0].toCPointer<NativeActivityEvent>()!!.pointed
+            when (event.eventKind) {
+                NativeActivityEventKind.START -> logInfo("START event received")
+
+                NativeActivityEventKind.DESTROY -> return false
+
+                NativeActivityEventKind.NATIVE_WINDOW_CREATED -> {
+                    val windowEvent = ptr[0].toCPointer<NativeActivityWindowEvent>()!!.pointed
+                    if (!renderer.initialize(windowEvent.window!!))
+                        return false
+                    logInfo("Renderer initialized")
+                    renderer.draw()
+                }
+
+                NativeActivityEventKind.INPUT_QUEUE_CREATED -> {
+                    val queueEvent = ptr[0].toCPointer<NativeActivityQueueEvent>()!!.pointed
+                    if (queue != null)
+                        AInputQueue_detachLooper(queue)
+                    queue = queueEvent.queue
+                    AInputQueue_attachLooper(queue, state.looper, LOOPER_ID_INPUT, null, null)
+                }
+
+                NativeActivityEventKind.INPUT_QUEUE_DESTROYED -> {
+                    val queueEvent = ptr[0].toCPointer<NativeActivityQueueEvent>()!!.pointed
+                    AInputQueue_detachLooper(queueEvent.queue)
+                }
+
+                NativeActivityEventKind.NATIVE_WINDOW_DESTROYED -> {
+                    renderer.destroy()
+                }
+            }
+        } finally {
+            notifySysEventProcessed()
+        }
+        return true
+    }
+
+    private fun getTime(): Float {
+        memScoped {
+            val now = alloc<timespec>()
+            clock_gettime(CLOCK_MONOTONIC, now.ptr)
+            return now.tv_sec + now.tv_nsec / 1_000_000_000.0f
+        }
+    }
+
+    private fun getEventPoint(event: CPointer<AInputEvent>?, i: Int) =
+            Vector2(AMotionEvent_getRawX(event, i.signExtend<size_t>()), AMotionEvent_getRawY(event, i.signExtend<size_t>()))
+
+    private fun getEventTime(event: CPointer<AInputEvent>?) =
+            AMotionEvent_getEventTime(event) / 1_000_000_000.0f
+
+    private fun processUserInput(): Unit = memScoped {
+        logInfo("Processing user input")
+        val event = alloc<CPointerVar<AInputEvent>>()
+        if (AInputQueue_getEvent(queue, event.ptr) < 0) {
+            logError("Failure reading input event")
+            return
+        }
+        val eventType = AInputEvent_getType(event.value)
+        if (eventType == AINPUT_EVENT_TYPE_MOTION) {
+            val action = AKeyEvent_getAction(event.value) and AMOTION_EVENT_ACTION_MASK
+            when (action) {
+                AMOTION_EVENT_ACTION_DOWN -> {
+                    animating = false
+                    currentPoint = getEventPoint(event.value, 0)
+                    startTime = getEventTime(event.value)
+                    startPoint = currentPoint
+                }
+
+                AMOTION_EVENT_ACTION_UP -> {
+                    val endPoint = getEventPoint(event.value, 0)
+                    val endTime = getEventTime(event.value)
+                    animating = true
+                    velocity = (endPoint - startPoint) / (endTime - startTime + 1e-9f)
+                    if (velocity.length > renderer.screen.length)
+                        velocity = velocity * (renderer.screen.length / velocity.length)
+                    acceleration = velocity.normalized() * (-renderer.screen.length * 0.5f)
+                    animationEndTime = velocity.length / acceleration.length
+                    startPoint = endPoint
+                    startTime = endTime
+                    move(endPoint)
+                }
+
+                AMOTION_EVENT_ACTION_MOVE -> {
+                    val numberOfPointers = AMotionEvent_getPointerCount(event.value).toInt()
+                    for (i in 0 until numberOfPointers)
+                        move(getEventPoint(event.value, i))
+                }
+            }
+        }
+        AInputQueue_finishEvent(queue, event.value, 1)
+    }
+
+    private fun move(newPoint: Vector2) {
+        renderer.rotateBy(newPoint - currentPoint)
+        currentPoint = newPoint
+    }
+}
diff --git a/samples/androidNativeActivity/src/main/kotlin/polyhedra.kt b/samples/androidNativeActivity/src/main/kotlin/polyhedra.kt
new file mode 100644
index 00000000000..3eaa9962b39
--- /dev/null
+++ b/samples/androidNativeActivity/src/main/kotlin/polyhedra.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const val Zero = 0.0f
+const val DodeA = 0.93417235896f // (Sqrt(5) + 1) / (2 * Sqrt(3))
+const val DodeB = 0.35682208977f // (Sqrt(5) - 1) / (2 * Sqrt(3))
+const val DodeC = 0.57735026919f // 1 / Sqrt(3)
+const val IcosA = 0.52573111212f // Sqrt(5 - Sqrt(5)) / Sqrt(10)
+const val IcosB = 0.85065080835f // Sqrt(5 + Sqrt(5)) / Sqrt(10)
+
+enum class RegularPolyhedra(val vertices: Array<Vector3>, val faces: Array<ByteArray>) {
+    Dodecahedron(
+            arrayOf(
+                    Vector3(-DodeA, Zero, DodeB), Vector3(-DodeA, Zero, -DodeB), Vector3(DodeA, Zero, -DodeB),
+                    Vector3(DodeA, Zero, DodeB), Vector3(DodeB, -DodeA, Zero), Vector3(-DodeB, -DodeA, Zero),
+                    Vector3(-DodeB, DodeA, Zero), Vector3(DodeB, DodeA, Zero), Vector3(Zero, DodeB, -DodeA),
+                    Vector3(Zero, -DodeB, -DodeA), Vector3(Zero, -DodeB, DodeA), Vector3(Zero, DodeB, DodeA),
+                    Vector3(-DodeC, -DodeC, DodeC), Vector3(-DodeC, -DodeC, -DodeC), Vector3(DodeC, -DodeC, -DodeC),
+                    Vector3(DodeC, -DodeC, DodeC), Vector3(-DodeC, DodeC, DodeC), Vector3(-DodeC, DodeC, -DodeC),
+                    Vector3(DodeC, DodeC, -DodeC), Vector3(DodeC, DodeC, DodeC)
+            ),
+            arrayOf(
+                    byteArrayOf(0, 12, 10, 11, 16), byteArrayOf(1, 17, 8, 9, 13), byteArrayOf(2, 14, 9, 8, 18),
+                    byteArrayOf(3, 19, 11, 10, 15), byteArrayOf(4, 14, 2, 3, 15), byteArrayOf(5, 12, 0, 1, 13),
+                    byteArrayOf(6, 17, 1, 0, 16), byteArrayOf(7, 19, 3, 2, 18), byteArrayOf(8, 17, 6, 7, 18),
+                    byteArrayOf(9, 14, 4, 5, 13), byteArrayOf(10, 12, 5, 4, 15), byteArrayOf(11, 19, 7, 6, 16)
+            )),
+    Icosahedron(
+            arrayOf(
+                    Vector3(-IcosA, Zero, IcosB), Vector3(IcosA, Zero, IcosB), Vector3(-IcosA, Zero, -IcosB),
+                    Vector3(IcosA, Zero, -IcosB), Vector3(Zero, IcosB, IcosA), Vector3(Zero, IcosB, -IcosA),
+                    Vector3(Zero, -IcosB, IcosA), Vector3(Zero, -IcosB, -IcosA), Vector3(IcosB, IcosA, Zero),
+                    Vector3(-IcosB, IcosA, Zero), Vector3(IcosB, -IcosA, Zero), Vector3(-IcosB, -IcosA, Zero)
+            ),
+            arrayOf(
+                    byteArrayOf(1, 4, 0), byteArrayOf(4, 9, 0), byteArrayOf(4, 5, 9), byteArrayOf(8, 5, 4),
+                    byteArrayOf(1, 8, 4), byteArrayOf(1, 10, 8), byteArrayOf(10, 3, 8), byteArrayOf(8, 3, 5),
+                    byteArrayOf(3, 2, 5), byteArrayOf(3, 7, 2), byteArrayOf(3, 10, 7), byteArrayOf(10, 6, 7),
+                    byteArrayOf(6, 11, 7), byteArrayOf(6, 0, 11), byteArrayOf(6, 1, 0), byteArrayOf(10, 1, 6),
+                    byteArrayOf(11, 0, 9), byteArrayOf(2, 11, 9), byteArrayOf(5, 2, 9), byteArrayOf(11, 2, 7)
+            )
+    );
+
+    val verticesPerFace get() = faces[0].size
+}
\ No newline at end of file
diff --git a/samples/androidNativeActivity/src/main/kotlin/renderer.kt b/samples/androidNativeActivity/src/main/kotlin/renderer.kt
new file mode 100644
index 00000000000..9291b6a9fd1
--- /dev/null
+++ b/samples/androidNativeActivity/src/main/kotlin/renderer.kt
@@ -0,0 +1,291 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import kotlinx.cinterop.*
+import android.*
+
+private fun logError(message: String) {
+    __android_log_write(ANDROID_LOG_ERROR, "KonanActivity", message)
+}
+
+private fun logInfo(message: String) {
+    __android_log_write(ANDROID_LOG_INFO, "KonanActivity", message)
+}
+
+class Renderer(val arena: NativePlacement, val nativeActivity: ANativeActivity) {
+
+    private var display: EGLDisplay? = null
+    private var surface: EGLSurface? = null
+    private var context: EGLContext? = null
+    private var initialized = false
+
+    var screen = Vector2.Zero
+
+    fun initialize(window: CPointer<ANativeWindow>): Boolean {
+        with(arena) {
+            logInfo("Initializing context..")
+            display = eglGetDisplay(null)
+            if (display == null) {
+                logError("eglGetDisplay() returned error ${eglGetError()}")
+                return false
+            }
+            if (eglInitialize(display, null, null) == 0) {
+                logError("eglInitialize() returned error ${eglGetError()}")
+                return false
+            }
+
+            val attribs = cValuesOf(
+                    EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+                    EGL_BLUE_SIZE, 8,
+                    EGL_GREEN_SIZE, 8,
+                    EGL_RED_SIZE, 8,
+                    EGL_NONE
+            )
+            val numConfigs = alloc<EGLintVar>()
+
+            val supportedConfigs = allocArray<EGLConfigVar>(numConfigs.value)
+            if (eglChooseConfig(display, attribs, null, 0, numConfigs.ptr) == 0
+                    || eglChooseConfig(display, attribs, supportedConfigs, numConfigs.value, numConfigs.ptr) == 0) {
+                logError("eglChooseConfig() returned error ${eglGetError()}")
+                destroy()
+                return false
+            }
+            var configIndex = 0
+            while (configIndex < numConfigs.value) {
+                val r = alloc<EGLintVar>()
+                val g = alloc<EGLintVar>()
+                val b = alloc<EGLintVar>()
+                val d = alloc<EGLintVar>()
+                if (eglGetConfigAttrib(display, supportedConfigs[configIndex], EGL_RED_SIZE, r.ptr) != 0   &&
+                        eglGetConfigAttrib(display, supportedConfigs[configIndex], EGL_GREEN_SIZE, g.ptr) != 0 &&
+                eglGetConfigAttrib(display, supportedConfigs[configIndex], EGL_BLUE_SIZE, b.ptr) != 0  &&
+                eglGetConfigAttrib(display, supportedConfigs[configIndex], EGL_DEPTH_SIZE, d.ptr) != 0 &&
+                r.value == 8 && g.value == 8 && b.value == 8 && d.value == 0 ) {
+                    break
+                }
+                ++configIndex
+            }
+            if (configIndex >= numConfigs.value)
+                configIndex = 0
+
+            surface = eglCreateWindowSurface(display, supportedConfigs[configIndex], window, null)
+            if (surface == null) {
+                logError("eglCreateWindowSurface() returned error ${eglGetError()}")
+                destroy()
+                return false
+            }
+
+            context = eglCreateContext(display, supportedConfigs[configIndex], null, null)
+            if (context == null) {
+                logError("eglCreateContext() returned error ${eglGetError()}")
+                destroy()
+                return false
+            }
+
+            if (eglMakeCurrent(display, surface, surface, context) == 0) {
+                logError("eglMakeCurrent() returned error ${eglGetError()}")
+                destroy()
+                return false
+            }
+
+            val width = alloc<EGLintVar>()
+            val height = alloc<EGLintVar>()
+            if (eglQuerySurface(display, surface, EGL_WIDTH, width.ptr) == 0
+                    || eglQuerySurface(display, surface, EGL_HEIGHT, height.ptr) == 0) {
+                logError("eglQuerySurface() returned error ${eglGetError()}")
+                destroy()
+                return false
+            }
+
+            this@Renderer.screen = Vector2(width.value.toFloat(), height.value.toFloat())
+
+            glDisable(GL_DITHER)
+            glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)
+            glClearColor(0.0f, 0.0f, 0.0f, 0.0f)
+            glEnable(GL_CULL_FACE)
+            glShadeModel(GL_SMOOTH)
+            glEnable(GL_DEPTH_TEST)
+
+            glViewport(0, 0, width.value, height.value)
+
+            val ratio = width.value.toFloat() / height.value
+            glMatrixMode(GL_PROJECTION)
+            glLoadIdentity()
+            glFrustumf(-ratio, ratio, -1.0f, 1.0f, 1.0f, 10.0f)
+
+            glMatrixMode(GL_MODELVIEW)
+            glTranslatef(0.0f, 0.0f, -2.0f)
+            glLightfv(GL_LIGHT0, GL_POSITION, cValuesOf(1.25f, 1.25f, -2.0f, 0.0f))
+            glEnable(GL_LIGHTING)
+            glEnable(GL_LIGHT0)
+            glEnable(GL_TEXTURE_2D)
+            glMaterialfv(GL_FRONT, GL_DIFFUSE, cValuesOf(0.0f, 1.0f, 1.0f, 1.0f))
+            glMaterialfv(GL_FRONT, GL_SPECULAR, cValuesOf(0.3f, 0.3f, 0.3f, 1.0f))
+            glMaterialf(GL_FRONT, GL_SHININESS, 30.0f)
+
+            loadTexture("kotlin_logo.bmp")
+
+            glPushMatrix()
+            glLoadIdentity()
+            glGetFloatv(GL_MODELVIEW_MATRIX, matrix)
+            glPopMatrix()
+
+            initialized = true
+            return true
+        }
+    }
+
+    private val matrix = arena.allocArray<FloatVar>(16)
+
+    fun rotateBy(vec: Vector2) {
+        val len = vec.length
+        if (len < 1e-9f) return
+        val angle = 180 * len / screen.length
+        val x = - vec.y / len
+        val y = - vec.x / len
+
+        glPushMatrix()
+        glMatrixMode(GL_MODELVIEW)
+        glLoadIdentity()
+        glRotatef(angle, x, y, 0.0f)
+        glMultMatrixf(matrix)
+        glGetFloatv(GL_MODELVIEW_MATRIX, matrix)
+        glPopMatrix()
+    }
+
+    private class BMPHeader(val rawPtr: NativePtr) {
+        inline fun <reified T : CPointed> memberAt(offset: Long): T {
+            return interpretPointed<T>(this.rawPtr + offset)
+        }
+
+        val magic get() = memberAt<ShortVar>(0).value.toInt()
+        val size get() = memberAt<IntVar>(2).value
+        val zero get() = memberAt<IntVar>(6).value
+        val width get() = memberAt<IntVar>(18).value
+        val height get() = memberAt<IntVar>(22).value
+        val bits get() = memberAt<ShortVar>(28).value.toInt()
+        val data get() = interpretCPointer<ByteVar>(rawPtr + 54) as CArrayPointer<ByteVar>
+    }
+
+    private fun loadTexture(assetName: String): Unit = with(arena) {
+        val asset = AAssetManager_open(nativeActivity.assetManager, assetName, AASSET_MODE_BUFFER)
+        if (asset == null) {
+            logError("Error opening asset")
+            return
+        }
+        val length = AAsset_getLength(asset)
+        val buf = allocArray<ByteVar>(length)
+        if (AAsset_read(asset, buf, length) != length.toInt()) {
+            logError("Error reading asset")
+            AAsset_close(asset)
+        }
+        with (BMPHeader(buf.rawValue)) {
+            if (magic != 0x4d42 || zero != 0 || size != length.toInt() || bits != 24) {
+                logError("Error parsing texture file")
+                AAsset_close(asset)
+                return
+            }
+            val numberOfBytes = width * height * 3
+            for (i in 0 until numberOfBytes step 3) {
+                val t = data[i]
+                data[i] = data[i + 2]
+                data[i + 2] = t
+            }
+            glBindTexture(GL_TEXTURE_2D, 1)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND.toFloat())
+            glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, cValuesOf(1.0f, 1.0f, 1.0f, 1.0f))
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data)
+            AAsset_close(asset)
+        }
+    }
+
+    private val texturePoints = arrayOf(
+            Vector2(0.0f, 0.2f), Vector2(0.0f, 0.8f), Vector2(0.6f, 1.0f), Vector2(1.0f, 0.5f), Vector2(0.8f, 0.0f)
+    )
+
+    private val scale = 1.25f
+
+    fun draw() = with (arena) {
+        if (!initialized) return
+
+        glPushMatrix()
+        glMatrixMode(GL_MODELVIEW)
+
+        glMultMatrixf(matrix)
+
+        glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)
+
+        glEnableClientState(GL_VERTEX_ARRAY)
+        glEnableClientState(GL_NORMAL_ARRAY)
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY)
+
+        val poly = RegularPolyhedra.Dodecahedron
+        val vertices = mutableListOf<Float>()
+        val texCoords = mutableListOf<Float>()
+        val triangles = mutableListOf<Byte>()
+        val normals = mutableListOf<Float>()
+        for (face in poly.faces) {
+            val u = poly.vertices[face[2].toInt()] - poly.vertices[face[1].toInt()]
+            val v = poly.vertices[face[0].toInt()] - poly.vertices[face[1].toInt()]
+            val normal = u.crossProduct(v).normalized()
+
+            val copiedFace = ByteArray(face.size)
+            for (j in face.indices) {
+                copiedFace[j] = (vertices.size / 4).toByte()
+                poly.vertices[face[j].toInt()].copyCoordinatesTo(vertices)
+                vertices.add(scale)
+                normal.copyCoordinatesTo(normals)
+                texturePoints[j].copyCoordinatesTo(texCoords)
+            }
+
+            for (j in 1..face.size-2) {
+                triangles.add(copiedFace[0])
+                triangles.add(copiedFace[j])
+                triangles.add(copiedFace[j + 1])
+            }
+        }
+
+        glFrontFace(GL_CW)
+        glVertexPointer(4, GL_FLOAT, 0, vertices.toFloatArray().toCValues().getPointer(this))
+        glTexCoordPointer(2, GL_FLOAT, 0, texCoords.toFloatArray().toCValues().getPointer(this))
+        glNormalPointer(GL_FLOAT, 0, normals.toFloatArray().toCValues().getPointer(this))
+        glDrawElements(GL_TRIANGLES, triangles.size, GL_UNSIGNED_BYTE, triangles.toByteArray().toCValues().getPointer(this))
+
+        glPopMatrix()
+
+        if (eglSwapBuffers(display, surface) == 0) {
+            logError("eglSwapBuffers() returned error ${eglGetError()}")
+            destroy()
+        }
+    }
+
+    fun destroy() {
+        logInfo("Destroying context..")
+
+        eglMakeCurrent(display, null, null, null)
+        context?.let { eglDestroyContext(display, it) }
+        surface?.let { eglDestroySurface(display, it) }
+        eglTerminate(display)
+
+        display = null
+        surface = null
+        context = null
+        initialized = false
+    }
+}
\ No newline at end of file
diff --git a/samples/androidNativeActivity/src/main/kotlin/vectors.kt b/samples/androidNativeActivity/src/main/kotlin/vectors.kt
new file mode 100644
index 00000000000..86d30335e13
--- /dev/null
+++ b/samples/androidNativeActivity/src/main/kotlin/vectors.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import kotlinx.cinterop.*
+import android.*
+
+class Vector2(val x: Float, val y: Float) {
+    val length by lazy { sqrtf(x * x + y * y) }
+
+    fun normalized(): Vector2 {
+        val len = length
+        return Vector2(x / len, y / len)
+    }
+
+    fun copyCoordinatesTo(arr: MutableList<Float>) {
+        arr.add(x)
+        arr.add(y)
+    }
+
+    operator fun minus(other: Vector2) = Vector2(x - other.x, y - other.y)
+    operator fun plus(other: Vector2) = Vector2(x + other.x, y + other.y)
+    operator fun times(other: Float) = Vector2(x * other, y * other)
+    operator fun div(other: Float) = Vector2(x / other, y / other)
+
+    companion object {
+        val Zero = Vector2(0.0f, 0.0f)
+    }
+}
+
+class Vector3(val x: Float, val y: Float, val z: Float) {
+    val length by lazy { sqrtf(x * x + y * y + z * z) }
+
+    fun crossProduct(other: Vector3): Vector3 =
+            Vector3(y * other.z - z * other.y, z * other.x - x * other.z, x * other.y - y * other.x)
+
+    fun normalized(): Vector3 {
+        val len = length
+        return Vector3(x / len, y / len, z / len)
+    }
+
+    fun copyCoordinatesTo(arr: MutableList<Float>) {
+        arr.add(x)
+        arr.add(y)
+        arr.add(z)
+    }
+
+    operator fun minus(other: Vector3) = Vector3(x - other.x, y - other.y, z - other.z)
+    operator fun plus(other: Vector3) = Vector3(x + other.x, y + other.y, z + other.z)
+}
+
diff --git a/samples/androidNativeActivity/src/main/res/mipmap-hdpi/konan_activity.png b/samples/androidNativeActivity/src/main/res/mipmap-hdpi/konan_activity.png
new file mode 100755
index 0000000000000000000000000000000000000000..deb3f79d059af16fc82105019fbfcb05b6f0fff7
GIT binary patch
literal 4654
zcmV+}64C96P)<h;3K|Lk000e1NJLTq002k;002k`1^@s6RqeA!000s7Nkl<ZcwX(C
z3v^Z0oyNcOy6@yBJhTdmg;kY@Qyvy2g{d&M@~B0I!44`Qww>wfno=|(Gioi;x}0fe
zIn$YG*J2!|%t)~vo+1QN2uL1)fV>kH5Yzw)RHcTHg!?#q&-(9u&bjBF`wB@&>ss8k
zvXY#0?#VsB`+eX4zxUZU3a&r$5>T%5$xq-qpaKfH4(K|du7${T1zlHA4=8BX(?1Ij
zxUKj2Bx6GrhEPZTBx9`LVd+OOAj?zop2gY8vOP89@6+Kbly*(W@z|wA)xR&Acd5{e
zENHR$&%Sh1;Km!5T!|&daL!6Npu11XdA2{n;oa^W=Go!ip5s(VZFe2PVQrV&Qs=Q>
zPv&;oq5w%K{8Gs8-`(=b<?sCWPZxfe4^m!0_s{s7=!kpoUeO+pPtJ-VI~{P>_Oy%6
zvE6-qZul-tX`IrbrSN1w-h~pufWNx2@!e^aOaJ9!E=c(RDc@c6(<w$E^go=Vm-hs@
zE=s(cpAkR+E-T6S-z|OV+1HTO;6iaZAI7(ze|cUYT=Y)>wDfm2s~Ma_J}ZDY2TLa6
z|MuF;&n^TI&qg92py1qp_(^%Vxa7y#;G`gA=1oUcls!Ah1nF-;N|4zyNS-A#gJj^O
z9`-Nk){C{b{pX6Gy)Yj@`_%#pJ^uGUE{{Y@7dyVTUMa!hjKODUC<+DhSSp1;ysY#<
zN+~WaSF=WP+H>6ibA~?$TH4xiC7yt)s(_+GaRIZTUukQ7_4R-L(USmLuNF{v&cemz
zMJ2snbSpx@;S9Il*atJdb{~o(Vb^(cTQ9#U^VJb+-&LM~AYS<RB9^V)gpV(^K-Yax
zh>!)z1L!HrqfP;eL`wxAw~BOC!MsPNVc;z{BW`k-j6-qBL&<S5`Fjcu9Z9H4;r^)u
zI04mwqWe&_YcH0r+6Z4T2vyT0BvDA@Su6#063~Lh<&jb^Ackl-g!!}n3en<XtT}uE
z$Io4cVVckxht3%^#-MRPrJqd(m2s$?i|q>M$OOnythS&mxEoQuMZWSJcFfqBrPWY^
z#V|%c2DSG<9Bep_mzTVTKsW-;&;=m(Q@R9b)`G?5#U4P^A(w;$cyji`2uF(Wk2_AI
z?$kvDO$Hz35`8yK7>s~PSh{IJ6W<9Gb$KZQJ|&I^BHJ-Ea10vE?3PUf;SOt$TmupK
z$IpXy$Nh+#z>*cKP<OB%!Egks-a~+*;Q*eR{V+n2A}p>sgB_>-fG}eSnx+d9%L|EA
zMYc4M!1z!dMuiSQ71GLe@p+)wNPQs~_s)SaVg?c>N5%FU{C3k;Xuco}zaNT9LG4x$
z$Cb7=3hB;SESG{Lpcx27it(eGGuZlmGXf?<$b#fI368BKCX{5WNT`aGWO785HjE9v
zjZwjaP{Cx5x&7Bs)exXS5qxD&Kp!>*aZ|;*%5B*2Rvk=LgU=s?s>}RIcjPq!R2&YV
z+yeAM%~@17HACZE*eql+1eqzV=7wb1%!cJ-3H-Tl4@L*yfuY2qK`Kgdhjd2)`N>w_
zcWkv{-9}W_?tyCf;0wrbrW#NA-0gshN=h=Sm>1CIrb{Ax2@)wO({7YWQc09aelvl4
zw8NO-uZ5u`pa}IaXo_78sglvpX$_K<&z{Wjh2XnqHuRA*L`B`Wtp@*BQ6=F715i~R
zit0L(C;Yo?F)ttr>1ZUFrl8I5Uy}WW1xYB$wi{zGOoBq8Z6eHK7>oTFr|*SNNkCOh
z3lITeB8Nn!gXwDQa^w%$>dW7TK6H|>)tbsGRP5LZQ_<iH1fXg%l+)XkwBNd#L5rM5
z(LSvJ6b_<%j?5skm;=Z<h*XjW$;zaFnLrskg0HG|2%;UD!bJ8^?;}+tEk-SY$RuI6
z9B>?4eHC$&;n(Xbu%&hn6kp0#h2Y3Os7oO&0l8I4LkusVP48cF-feq~W@nOZw}6?%
zsN_jZXWI}`+MvP|5HtbEl*%F1ka`3-3CSL0yBkqt*s2;UE2^OQ{4V9F-exKzf4T)w
z#2RWiX&?XvP(Fvsyi|}4$U6l>N+2ag%{a!#>M=D@hcMctVgv+&WLl7<nj9tBc5`hL
zuOS$PZwytdNr;&W)>dvq#g1JrTiM;R@VsjTkZvvew=OB@(FKdji#>qsM)9dR)F>9?
zh3d1|)I>9v*~b@@J72kS60_TPAc_{z2s*aP3(1B^N}_X{Py)s9jh_eo_6gEfYd2!c
z&b?4v)k@kb`^eojU~+!!9zd?z$T&wd6hQgoDL@rX&DkfGILF}ldCb3DiQc?ff<aO!
zMkvSyC}lTyCP_t!=aH?-X2TdhUBIcJYPCsLE5j<~ibA%^tbE?m?i|5^SbG;T=+W{;
zS%(@TgDgNltUe<Y<Q<4AoMBY#4CY*}MIYWQm1BppH7FHOL>04CCG5uKaZYt(P=iGX
zmd$}7Yz3^@T!l^5yTDW(hCcw!8icwVgO1pX!1W9uS4hi&CdZKYIee?77B{eFaj_zd
z1tc4W70%oO=WI{UBsCC1c*6H!+;Jb`NrvTXH(=|oeU5Sp!LeRWPGxlqpsZEQtsplb
z&e1Q~jPG2k#en4RWi_&_L~60Cm)J&dEM+-LQYdpIB+VZ{xNIf@Bc=*lZK$fos?FQd
z;iziX>g2XjHrv_Yx(ukuJKbSdvB$qDLi+jYGolX?*~mEt#XrHLEql;EdC^i1K_E!B
z#pvRtie$c+!e%xo8>SwJplIA92o3uS$5xxGcUxmCY67jXRff3>S1z}zx*d>R#mc>a
zz|k+!j9JZl(BHf$6=18wRk?)SxScU6yJ<>N_C*SV77U@+gt-XbIo4w<>T_spB}e7-
zuH*{feAeoAKxua=I2ZFlUO=U0J05P{kHN8XvO}f|wem&4a%YcFjZ}{aXz{bGZo1!(
z(y`M~Jd%bFZd=(+peCj*G69G!1^XWF^SZ2{h<C8cxM&ogo}04RzQ%Ky-h2py;vYk|
zg4hma`P~9$H-=7$CzU0wrjfx21<`lhU!v%)`^3OgRI44bTBVJxJoCzuO0GL0`M`BU
z6)Objm2D>wJXnW8iH}6qIM#AHWNS!am3RUohZiYmq@p-CaQ=n~xc{-K@CW=jefAul
zf8{?!{sbdM&~zi~r2Eyt$)>t%s-S2%g6-?yLUY4mM>%%GCxh6sk^@KDiS{{=V8Y}Y
z4qv$gC*lL}#o_%ib?RLR1`X^zRFD5!wH`4BXokEik!{i|Z4i-XE<4+u@@@xYhxF5P
z{~9IXFm|ooiVu$+ml<PSy!>v5bZThffN^C~f*Uv-`vOiUZwBKEG*!Xy;r%dq@=yeW
zI^I51kLBwtaXFrZE+*Y6f81?puH4CQEgR}J2efnTR-8R{(ixSDDr5z61|++`vFw##
z8V<zo#E0e$Vy0DGHcjg5Du#ctAEr(FGbjqj-op)8vhocuMT1UOQ|&w99m}2Ufi4ks
z3m~^N>82rt^a4vkwQH+zwxQ8dkJZ<xDGO00BjwQ8%U$+qYeQln-e>(pzS_5g=sVSJ
zf;DPne|-JHVZv^E4jskPH5Ir*Q@3IwEc>0(!kOeYWETO=EMHV!6!lKIrUR;3yA4eZ
zr&0>C0+_0qRFd5p%V7qoDnW3}LHL081?LJBy2D{XqA3!gB$}O66^tCwACspHK_H-G
z_rarB{^sw{8cRSkWN2q*QlX00oq(QPR9;k?4#>`+1y9Hf+P<b5ryCjtjP!oTgzm8$
zg*Mf&BN&JaypOo2uM!vmC_5xwQ!!#he@vTpmsp~(=TJSC{B}K{X%-~+2>$BeblGAv
z9Y86sGbS5FVX;UARcmU{R8N3X)yc^qf@W<ei_zfXgmMd-a3d71h&!(|t4gX7wi0(^
zB`gue)^^%=&*%Y`k__zJe+0|cRv^ZhHScV7)_HrObmeqQNY8xohvh}3a`A%wkO~Sq
zfVQlz#d{6!iG0zmF_o<(cjhD%4ae16a8B(75FEN4P4@Gs$5xV<mv-e5-I%!h?prZw
z(qQ-lI_lmzgcTdMqAihxChnN#%cSgZx<Nq&0ENT&-Re5L+tB3Xi)aKbyOG7nRs^TP
zxD_8MC6+q4u$6=$@8Jv8Sn6>?+d4+f5poV)S21ejEtvX{wA;@8hw<u4vYP?jFyt~9
z>ycx1U<Ro!RWVXf#+<ZO#h#fv6VxbHuHK1L^-Zpjmf=iaIvAJ&G#WSItlme2uK+`L
zF9?XG9$PK;HnNn+rfhZtP<HQam^66^{C*uZdk^4$*H<EDQhQ+E<|()~)d6+Q0adKt
zjYbQQ6Vd{X2~$zg7`OrF^j=QB2slC+G#^9|tlK=cf?O5NYd3dw`_h*NVB*BV@cT8?
z>^q3pH*P_D()46fZfkX026+`^SFvZFkP3Qp^&Xt8KP@xJbsLANz_HLx_{b;{aOgIW
zSlJ;0*bT|5V6>0cG1K~L$9ginZ8gbEO4*Hq`@wGv1HGo2eFv~~^+qVVA;xWPyXC{w
zWd(&xJnMt3(fmRS(7ILoa6$lLLNx@5tH8-{ADj(DMKzLOQcGWGo2+02#bq}E$PLg{
z{%t$DsvF%aD=Ql)gWIp;t=;bkyCrDIV%g1m^Uw>cOMt#fRV)LLym3f?io+4CS+yU>
zkDd_~j8tT*3L1-h<9t9WM=qS=VsVvNP~}n*T_6FWZQ`zK*5J<7CrLHwnj%_&i4%vw
z@F{rf?frPYq6#tUxSi^jJCnK{kZrMrPdp+3ty*~i$Bv#AO(EH;zO)ZM3Wmf*8`fee
zf~1R3wg6?dTdImV)s0r9S*o&oBBxKXJ8pt+sQB`j&tuAzVMwy1fV6DQMyQ5gG?V%4
z)^$LhHHwVO6=pV|l`9Y8=#dY=H3cV1qBtFih|emB^+5#2&K+xEgJU-vlHCj0eUVkU
zL~dEzXaH-2akm5Z@I>5}=D@hIgYdw_JB8i0*6qQHja!i5YF@kb2%vq(E})@T3C={q
zLMik`>M^*4B$Q-TDQU5Et2t%9pxx}@2=z@?%itQj(XeF9y|>|kiGyJn3byZl2frb^
zF+eA~iDfY9cI$pX)*8iy-;x&l_3Fb|em;gXk&tNgsS?SxKwQG%42B1iP!$amESN$m
zY1J(~sMGo+0+M6wM(Q$jRRs5xDMN+bUVpO^n`-x2YlTv)T)U;rQ%Fa=qj|<r9P)zz
z^@>KZ?$8C)UW})Wg5=bzw1`1JTk0VtiD0(JUBX@vD`VxFAh`lh1h&{FFN4nG>}U3V
zYp2x)*wY;1ISNpA&u#d^?R|0Ncq3l?#jg+uhvi(7XT4At74%$rB$_@JqY=2mO?-F8
zgSdOx;KH5QAL$4=jAK~8bqAJj*n(h)mI3z=ATyanuSf`!#*Rk6&-I0twrHShM7*EV
z=<L~O*5TdLXR&T;HCkc`_?-m~-I+l@c&<F`S^gqEIKmmsL=uU349R#L%uJ?TN4`%D
zWDX*8A1(GcyYrnjJ4RZ9r~7;`e1V*mtV<S~@q_0wmf(q(B0jId!I&vN)Z$$@m7xOn
zD!QDK$UNxkk))rT@<vtVjYfO+v0FQ735bRo-cD5Z9fj<Wf65_`a=J<;%bSpG$U$#x
ztgZFc-@Ni-=N6Jr|K7sy7x(V_6Gct`KwT~o6rO|WSty0_i*uN*Eua2k)z4pgt}~zZ
z2~K?MZy);H=Lh{#Rn?NtLrDvgtfwgqw$P<^Za-tJ_4gk%J+pb)FP8ym%XXH0GfVz{
z1MeI#=Iamrs<^aInfu8dzo7hH>G*j%2cXciT0i~6{+dm1%sSs#e~NCAT`eG*l_<G+
z;O#?3Kk$uzEiUanSW(r0_~>52N8u3pBf?>fu~=*K#bdiSy)pmXdnXzId@5FnX3MSu
z*Xk!o(P*E3gU5{fO1PwSkf!Ou?9V9-r6AWHIKWJrS6W*yHJ#j7yZw{%=g(MhuH^dD
zg(h!lKS83;UD8*;8g3POUJqPqr~ZUoPb}?3AHk&0snX9m-`$R0s2GDn{?~;LSgcbo
zzNel<%l8RV0`y-P3OqUr$UcpI{MA0M(Cg@_{kBp%oClxP3+*YOdH?f5kG+UL<v(;?
kLEW4|f68z6HF<6S4?-E=?)fmQ<NyEw07*qoM6N<$g1JrNc>n+a

literal 0
HcmV?d00001

diff --git a/samples/androidNativeActivity/src/main/res/mipmap-mdpi/konan_activity.png b/samples/androidNativeActivity/src/main/res/mipmap-mdpi/konan_activity.png
new file mode 100755
index 0000000000000000000000000000000000000000..63a53c0b2f8d5801266aa1cfc4baaa83eb062b65
GIT binary patch
literal 2479
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

literal 0
HcmV?d00001

diff --git a/samples/androidNativeActivity/src/main/res/mipmap-xhdpi/konan_activity.png b/samples/androidNativeActivity/src/main/res/mipmap-xhdpi/konan_activity.png
new file mode 100755
index 0000000000000000000000000000000000000000..cb7cfc14d036c77c24b55cb6b45af0a6d0495a11
GIT binary patch
literal 6120
zcmV<E7Z>P>P)<h;3K|Lk000e1NJLTq003YB003YJ1^@s6;+S_h000-SNkl<ZcwX&Y
z3zQVqnf|J(-@{-~83tuQki>{Qf>C1<;+owUPmTdc6wStnnl)=4u0~<mv*ttsDrip3
z`T#Yc>l%DSG)hE_y1Ks5nL%Jc9S2bq9|Nf1%rFB3(_K}2{`;u9RbADOneG|nOrO*A
z&|O_s{eA!c{f~R=mWF{xzapUZ>(K`ejsXJt*$4&*7$BgZ5$NZ`4|u=;0sV|XKOcU;
z0|p4_X9W8B@ICba`ks8!Pw44>`uXSg`tY{c1HH;;Q9CUbIPLovT#%YF<+PurGuDqy
z%N_^V6@f>TrxtQLw(Z>@Yx6vx+w^;L9D{x2`8<1L?;+S8y$|0T{w>(Yn${W7w6~&$
z{=nL`FW&XcvSoYyN6y7aF$CyW&An-C>hMFCcXV}4GEFOVzkYDDewPp2EUefYxe3aD
zjBqslhtGmOAMgQ88HSF*sno{Kw%s%SblsdS0Kx%MPOVS^^nW^Q=8zNr;glCTyY`LG
z=VST7>814t5U8G0_Q$^C<pJ353R#w)!&L^Ql5aNEH=O$1V}EWfgoHu~h+TE#qFLP*
z7W5W;ZrleG0ol?P*R`wfm^<qx0NwfUDue(XK=O(k7r$&;_T*eU%xC#Q;P<us1gIN4
z79J2+)Xxj?uBf3kE}1*)6aW+ta!OGl1VjN;UVg*k9hPm=-@!3Ak1WV9mD~D*09K=M
zIrQHzf4Zin@18fS8bAktbZ>)j9Ka!$EnM_T;nvU1D2$V0NeK25_iO_4mw;mz5eNKU
zpqObP9zbVy&-~fL0JH<x-x~tx&_uwH%N8!$me2YLSlhPvk7uv$FA2;Toi_zxj+?09
z2EecE%=b+<euku={`A!UeQr74<7*man>zgijsD{)dxD9*Xa4LX08k(%0zwn!d=f;T
zCj<d4egZrI+ZHU-LPa8mn(Cp@p!o<0IS0>=4LwiKp}oB2{!U)W$(=qiuy^m-gAcZU
z$_UVP1DdXLLVUQY$GT_!>>~vM`^rLq7knF*X=2h>M&tY+o`%YbRKDQ<h5FpGENp1r
zjKvQ;hO}iN5{WSq{PlmI5#ZNw%QBIQMKSl67aerqtCq6-$!D?Rxz&g!5-=hWAxDZ_
zDb83H4+u^(ZBSMG)lo;_@}JBgFU8iKd(iaBUg)+B-L%-NA>38BY>(j>rU^|sal<O8
zfP@AM$3~lxiYPHIM}ZXXa=9f;JM1VJH7BsIH#WVE8<s3XJe5KuN?zbq@UnWquNK^v
z6$AK>vSDU2IQFO-Tz<hh?48G(KEtgqe~7qkBW7AKY#R~NLd>>c(Eq{zuhai68@i>u
z5@|#d{TeG6932);Nj2bG6?GJ8eAxQS++sg>cc)h!jl`J?p$#6+-u&Oy^;o+6aU@a|
zh{S{piOv17rsN(FMgVz*nMpGOu9!K4oz9A;o%q8mA0c5`h+8&d1h60>YFVJCA;AwI
zfq4uOL%+&jHQT^<QfqL^pw(pqo_4Gc9peGNwS70{-h3xMY2A%PG6jPOU>T7xLm$um
zO28v;?ZgdrEr^>Il8gikQ6hi>m}xTt=x-t+!hp{91SVgC1m+FQ*=(GY+<@;6dI^SR
zDg+d1^<rOPvP702Kl29Ym6XZ@ZM!?LV9`=+Y1x59Y7nCFICR4}unCw~zl{N(ux#<l
zEuR4APZLqgc07T|AiyaGNLk`B#D)$oNfYC5;Rlt^!hk6<5D9#d1mvjN{g&U>-hl;+
zm*U-zwjrLZK#T?8XiohnS-xlfzn3-*%_Tt@CP5?c>zU^=iy;q~Tfd!YJ;@Kr5P1Uq
z&E&{(y?~LyJU|e@<VPVvc)^6oW}II6EMnSzPKX@;P$PJ#W#=P^`$CZHEL?mS-u-YJ
z;;9N|`H@HzV0D1&KS9;;0YLz-8950F(?-G;awI%KN|8f?%$NiTJc9zpY42iM<x_}i
z)Li5q;gG-xP^-C~1>G$0+je8Y;=8cr<L!tiQx5p~@_(U~<@W$JB@OccX(S{cG27-b
zL6Trvh}gmt=x-6Ine{XM=U#A(z7@5Jr;yaT7@3+zX{t*C{ms0AhzOLH{MN4zrEF(`
zlkI%o){cd@-;FIF3Gfr#@_9SL8#%&yLuK)RpgMqMK_;c4*%IVAS0X@>BNmvY9N8A4
z4hcejY#U?o5zdXSLQ?M%7H_fqUji<@K*|w)=7T36TF|S;A~EfHFZj&zcd&e4$_}%9
zhJJAGM-e3UXUPfp<@L7))&XGzTvN9lvQAM?IboVCCh!zh)CLq2Oc|tkb~MJ?j`NHs
zFi776%KJ5qte%4(NP_KphaZfvT#;laUVEdH?X;@069_&FG9FU<%mZ=~K!w<7uLnp1
z{EE!vNMuJ23BnUdhR7>w%$=C2ufQQ%Cp6oHu36jz<f}sjmmZ!a338m6kXw5EnlEMN
zy^ppd)=TjF%mdg@WQCZJpbOnBhzL+K1;5!yIU*A1DO1!M^D|s*K7m8^HU=uUdj6_w
zeiG<2dI*9<JdklB%v1w4fAL*-@8cagz%ShT%Su3YyTz@9f1QT_HHHvyswWT$!!xb8
zwEJ;X;d4iJG?<S5a}xNIOOddAVfAiI;DMTCi#-&b(1(si;!L0B-+niw<;UWp(dKBr
zq%pfKl523L<T2nEIbwh%S`oPj2pcbEo?w#fwBxd_l{nJ=j8(=2E(4mZ-XVd=ke<LR
zXn#y#-(y}w?R!pyBtReb6~w1q?`XawJ0EXHESW+$_{CX&Sv(*Y0lXJ90#{ym9y6Cm
zns(xvdRKyS4c1dksLpg^PUk9&vUWgcU`y%oli-yjHz>=%Y_XWYNsz^wAgTJRNc?a<
z^uaV#3o!6Wc3O560RDkW01ZI`q8XP>K+dUa!m|gP`|zLbPhzayA}m_!y_6oI`%HF}
zm_YG?#RPwLq>#Wo1kkH_s;O62IpE(wdA?I*xw1nIwnE2!L$j@Nq@j)n1kC9%(`l9k
zsUGm#`fYh9j3%u#X16_q<E#%o!PX7Brm$wA`%;b=u$%x^6+1D(TPIKuk5r98vUY(3
z{;t+GR%E^3vO`q39DJRPa0P*1y!8`A|8s4LdqKar?w0U6K%}9PfQOj`<t89urEz)t
z3z%fSFR~p1(gobHcFhgKhVTN9Cn&K(trI9Sid2n7MeTeK_|#t5y6uxd@O|-G7<gfM
zznXC!7zEU93r#~~Rt7)sco`?`e_vR#qV25cQepu6zaW9t1k&Pjq^ML`SB*i%S@W{M
z|6tpvh$WMVifl((ej(r&vrV6PfUE;DnGD7$62v?pgn+1RV&?8O`1bzI&~37KD5<5;
zf0!O^=a$WbGg&|L1W$IP)CsT<8#V@&wbv-%x3iXVF7OKhH(zW}_fa+ig6aTj#*G_Y
z<HP_W;J0<#oK}Q%Pf8nScC5v>x;BfBrUW&N1f{@oDq=qgUQdWtAB`ckSBF?W@9j`O
zU#C7vjuEY(1fpLF_<7D4ke>ibH_z^P9sjtunOQQ8Xvv&iYBw*kcuFbLQU14^W>TEs
z|Ce&))(O$7qj2c--yl+XIOBX*t7`dbV=W)}#Rp!$2bJ6ddP4w#e?~_$zQ3o*>FY3n
zMQ_KS_w%fV58BJWWdn{EVyYbRR5U(p6b`Tb4;X`o76pDG($kY|`h);kU{N6!DnT}I
z>fU!Tb@v-=D3NC}Ja>11*J#>`xA^k*fMj~97GiF8l&l_wq0{FmmfyyTtgS5IQiaQ9
zhfO2#HK>Y_m0Wqhe?Mg-AgHQkb-<V!TqP=D83QQ5es|9n{9yN6h_JxQL3T(G7VdUB
z1u61<M~(zJzBH6PAvtU$s?VP7k)4H$mj-}e$Y4q#(v!VSkcX6<fJ?8vIe1=>Eh^yv
z0#4{^!SwcxhzL0$D`zCo7_d{>3U3gZ4P{2$GkCfwi!A;g4aUpL*Fvg#1dcrW$}G!&
zuVp(D$wA5hdN%kykrnO%g*4^LP>AIvU~~<xx`_9J$OBe9w-(ddn-E7@3?+)`Cr(Of
zdr07wtpMKX2W68$!IwzfnLZ3VMxBM)b5BAd5n;z|e&;=0zi0{e)A+M9eIyci4QIKe
zN6J*6dH_#DN8qZ9e#DMnw{8pGS+xpDyPJVZ)=mu;2C&Ea6*&@_jz2r{dIFcCotYtc
zY43^XvSJuNemKrM?|8&w20Qla&71MZ|Gpm?=&ab%BQ$@9h7%P951eq9ui`D-`f1BP
zBS6lKqaZ8^Xl{4|jemcRgRd4(QdWorrQ&r)yp(|#HAt%@>`Z?Nuk1S>`|P;WW+oEO
znK2oOIQN9tH@$;f?tO@P0-r=Br;~?WG*XDH6tay=a=#O>?#btQX5;9%V(rosd?cvZ
z5huu-E$uQ1{K@D>j3LQJ!`MY3z@&*sFcKV3*z^u=zV{(?n>Hfx7z~3v#On#gXnOv!
zV2_jazXz;+@&!@ty1gAKM@}cx?+MQEqmV17<7r`6<`C3%Pr`o0*ql)bK97m~qV0(j
zkH8FtgpJLcam%vhoP<~mhHd~JIV#ku3*D}tJb+@raXtxZSVi+UWv(yBa=Ax184y{x
zB!Pk})WGcacXpYFpdmdG-Joj(X&4f08Y4Z_d871y@`M@ZPDV7!W5R~F-o`D<9!6St
z0=vS+A)&OoulhjQBq%6*2qK_v)yr-w>DP8mEy#!j-d2zeH?>&%+&Tnn%<&w2vV1lX
zf?K@m364h~+Y^X{TbDhIZVQM+qgfMcC2&2<jJ(oQwk+sh=LgpTG6)|>b%4l%C<wo@
z>J@K3FUNI7V0Htvn;khV2vMxH+LdT9Cm@Xo1D%h(i&yChiX5pi;rPiTaP~Qq98aK&
zD{f;Xa5>61yScddkWE6#J)jr@UaxOP-Ky2BXTw_zil!@Bk*6vaftgRjve0f-VvTkz
z(mu<VB+#5uM~(tWU~)9+NX(e=H4h25{CPPtHasK*PnIrT_sc3l`3Rsibk@bZ4%k?~
ziFp9^ex#-I3AM7z=@wWj2?RXNifh*fp+P$aX*<d$=Q8Uji>KjUVfl_6g?IvMnb<Z?
z`1(kkHGLu@f!<p8W-}Ju_Xs1wh*4WQyG|&y+6@*T{%#pPAUkl$W}HgE%TLq^@Of)N
z=KVBf-EG40_tjLj6_r?Te3@xJ(|ADuP1sdqfRr0f4xgLr#02F!Gut8(YB2q5SB}<f
zd=rcBe-s&Lh-8rvSfzztbRI@R83_2V9Am;%36J!6z>6yzL~DWf{?)?DVEMghDT_`h
z4Li1Jl~`wd85zxRG@pYiG9N~WONz{ZToTAjBq82OS*j-xXlph$VetchMaI^024+!e
z<TCca&-#~ux@J88#A`~mD*#twf}5i9f~!rdKx6D^C*aDfVpPi}aNYL>5n|#Mn}d}j
zFw>{UPp<I<=7x<;SajdRurwV;loxC2bzeONzf2O8?EyS^*^on$voHQ<W(|#XoACU~
z*H~&PTM<m(#bAmI%$x)h?RpB0@uQK}DBBU5PrV~?X_6#?^^=6;$P4)RE6<J!3C!O(
zX%uSDnh088iN4yf;SJpW;G?Vxp-WHI>?p^TOnE(`EFKV+E%*soSGO7ew~~7Rf#^&p
zVI+71bBB?@`otIpKD#DNSTUCx{(lE}3BK?I788mN%)m(}j$|=`NT5gkhBtBh{eOk2
zNfPM&pteO`+?@?dPQcIR<%t1fY9Kv;2zX}YIzA4dkRVe`NkWI7L}SG$bW89>AoY+y
z*N%xxofsiX9FXyWuFH@CTgs3pZb&Ur+7{#qXVy+|vZK1j*Kx-KkHXTq9MN<Ye;2iI
z_{)$56+^&lb?@TomFt)X$fxQFl=XBPajdHxg|wzK>7Xo!05&`%2%TpnhyYAvh(OCc
zM#+vml`%<Kj<yAT?VBgNazx<1vTh^pc<@nJn!)RYUXaiy9w1jPWUUCr0~%i4f~Qxm
zcd{Vz1V@fwp*@<w`oSZR)+PA-VmvkoPh`mJgP9QUE9Rv<Nv(G>9~qbhG0a<hDQkG!
z!p6xbk4A0n1V@fmuid~%u=R+D2|e?Kk`r*ryg!BxN%{$R_0{(o0Zyhvb2Mo{9yWHz
z;#fcANTfBxkrT3h<^dKsQS_?B02!E764dO7UC=GFAx}LJ*0vBAb_hv2`5Q+$ftftv
zr8Vnu=U-L;M$bv;GXmUR&`2i+5CN+m-@syknr?PP<5+*#aAx^*X(|;^9C$80R0T_&
zm$Kv!%wZ(><Ad9@6WNidCxRMy<S<jdJqFXJO@MCjYi?d_SdTwF)N>O0o`BIcnElfq
zvy&$RR{m`xc)`U<=!nMf+R$obD9F*}sq9){9z11W<@zsVh>^hw3L?R2Pbd~I7x@To
zTlfmPfWZ8nDPu5os-J|%03%wo9F?B{S!lA=Quug)O2CR0Z;0MM$xaNfRaK#zET7hl
z5Kl&esBGOJECBbA;Uht;rs7<ZBuJ22@3th!04OHVn6%PUQnq)-6U3kndBW6b<DHoB
zeEm8sT~3}*90{c-;CI0>fC6zC0W=4yJrP6wu%Qfm3AiLcdIDRpg95H66XNR(@n^6n
zcq?NGFdwYp8IY(Y<QReo(CoTmnY#K0bx4lL6I3~Rp?)2fcu2^unEfeg-w_~|t6^D?
zB0=N<ZOJ%ZtsaUl!*FFsEJYKcHG@2!;L4E;x{@8`2+S_nZbOd66|tTKBTA&DvUtna
zw)oDJqcL^rcqb;1CoFkr1@vfK^p50(+riaAzY}opQ*Yzd>MHDw@S#C^ur-6klTytr
z68xUPg0rX(sEZmxf~=TjqfQoRa&<1(6L{Og8QjU!JMxpT^e>O$*@i~8WEo$&Abick
zJ|RG@1I8US0&^}op8>tT`BN-vZpB_U6T$mn1sQ2Dd4M2+NeltZ){bzynKIXxnogui
zLip8@ybaCPj$r*DH@#%z%Pdy71)1E|^QyG7`I*WAf4(xoly8p4*Cx}-GrWWP`@8OU
zmMmizcZ57jPQbtX?xv6>%V=t128R!>z``ppMI^%K<{T^!iV4!tUusy-W?Aqh%i{dH
zvi>K47V9vP*}orG{Nx;*FyYvP1$)o$*x#MTwYM$7rVm>9l4YV_bN~<l(7KwG36br8
z@8sh#cGL(&`^XatSunh}7SYkU2hXgoN7I%M5U1<QV!_K+s>dn21bJK2HfZfoGo3*u
z-Hl8-4J(sj%NY9~!2^ET5EU{-Bn(*px%HL+TB^pNwnQw(3Nm)BfwPQp@ZL*Kz)$Cf
z#{eF?EYSEX$&qcD%q!G^)PjM}zI#GZ_~l!QzNnpvjTzX6!3OZ<fK9Fph`!eM1TYfl
z=kruA$oknPVe44?7|Ksr_!shjw>TPT9c*{uZu&FdlG|k=;14aiZ<bX2&n|4pFaLfE
z+fQ+z_hxH~OZQ$kr?jgkUih0Ew-}KKt)!l7G4Q<ST{u`@JmBSzH_deCvISQkQ>xX|
z+5H2~pFRKY@ru->ya<PEP)gv1+V%8Q%Kp9mdpjE+ylLJUrMQ0poh-Y9#u*p?YR<5c
zqh}R*_Jsp3_n6<}4|L$AI&9zi-tV7Yb|>A$r`LDTpnbA?$PB5f8u7g!U9zHb$f2Wy
zNGKlg;-su+`!Cd7O1E7{TkDpm@42J4v$K^t2c4z3hYZ!*bVr6EqsC1h|MgQ(yLIrP
zhmF<fVuv0*3bS;_FN)i|M`u)uFVPJwI$C$V)A;-||F(70#wH;@U8T5-5}jWRz#sr$
zN+y$4C!Rk2g2SqZpB{<FhwFxs3co{2aq<!d#DQ%6mSyctckkQw`Hq&S);|5W`?|Wi
zJ`>>YDb;<%2p94KB7yE3St-b%jELkZcVoO1=5^rigZz`qeY#Z@-7AJ9hi+XZ!Owd)
ziu@IY`{M~{0-S(Pir`G`p8*1Zj39tWpeGTM7kq-Y7y{(>B>n`v1iyE4_zqm_F7(U@
zXnGO}^rRab6dbvVB|x5(yqT7>K6jyKdys7>fo8)&#Q?7Yd5~f9#riot^?)zduRMUy
uc7T9>CTD<v0Rs9Nfqp*xfCuz50sjv^W@uoD8pbsM0000<MNUMnLSTaW7={1<

literal 0
HcmV?d00001

diff --git a/samples/androidNativeActivity/src/main/res/mipmap-xxhdpi/konan_activity.png b/samples/androidNativeActivity/src/main/res/mipmap-xxhdpi/konan_activity.png
new file mode 100755
index 0000000000000000000000000000000000000000..8d42782443073fb84a94e5f17db84ff1a174d4cb
GIT binary patch
literal 11950
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
AVgLXD

literal 0
HcmV?d00001

diff --git a/samples/androidNativeActivity/src/main/res/values/strings.xml b/samples/androidNativeActivity/src/main/res/values/strings.xml
new file mode 100644
index 00000000000..e1033450618
--- /dev/null
+++ b/samples/androidNativeActivity/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">KonanActivity</string>
+</resources>
diff --git a/samples/settings.gradle b/samples/settings.gradle
index 05b061c3dc6..776a5d98095 100644
--- a/samples/settings.gradle
+++ b/samples/settings.gradle
@@ -8,4 +8,5 @@ include ':socket'
 include ':tetris'
 include ':tensorflow'
 include ':concurrent'
+include ':androidNativeActivity'
 includeBuild '../'