SkAR: drawing text, shapes, rotation modes enabled, translating objects

To run this app, you need to create an out directory as such:
bin/gn gen out/arm64 --args='ndk="NDK_PATH" target_cpu="ABI"'

For now, the only supported ABI is arm64

Change-Id: I012f0c6a0550d80a0028f42177d5ca72974d848d
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/130980
Reviewed-by: Mike Reed <reed@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Ziad Ben Hadj-Alouane <ziadb@google.com>

41 files changed, 5809 insertions, 2 deletions

diff --git a/platform_tools/android/apps/arcore/CMakeLists.txt b/platform_tools/android/apps/arcore/CMakeLists.txt
new file mode 100644
index 0000000000..92c5968c95
--- /dev/null
+++ b/platform_tools/android/apps/arcore/CMakeLists.txt
@@ -0,0 +1,74 @@
+# Copyright (C) 2018 Google Inc.
+#
+# 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.
+##
+
+# Sets the minimum version of CMake required to build the native library.
+cmake_minimum_required(VERSION 3.4.1)
+
+# Import the ARCore library.
+add_library(arcore SHARED IMPORTED)
+set_target_properties(arcore PROPERTIES IMPORTED_LOCATION
+                      "${ARCORE_LIBPATH}/${ANDROID_ABI}/libarcore_sdk_c.so")
+
+add_library(sk_skia SHARED IMPORTED)
+set_target_properties(sk_skia PROPERTIES IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/src/main/libs/${ANDROID_ABI}/libarcore.so")
+
+# This is the main app library.
+add_library(hello_ar_native SHARED
+           "src/main/cpp/hello_ar_application.cc"
+           "src/main/cpp/background_renderer.cc"
+           "src/main/cpp/jni_interface.cc"
+           "src/main/cpp/plane_renderer.cc"
+           "src/main/cpp/point_cloud_renderer.cc"
+           "src/main/cpp/util.cc"
+           "src/main/cpp/pending_anchor.cc"
+           "src/main/cpp/anchor_wrapper.cc")
+
+target_include_directories(hello_ar_native PRIVATE
+            #BASIC AR NATIVE CODE
+            "src/main/cpp"
+
+            #ARCORE LIBRARY
+            "${ARCORE_INCLUDE}"
+
+            #GLM
+            "${ANDROID_NDK}/sources/third_party/vulkan/src/libs/glm"
+
+            #SKIA INCLUDE DIRECTORIES
+            "${SKIA_INCLUDE_PATH}/../modules/skshaper/include"
+            "${SKIA_INCLUDE_PATH}/../modules/skottie/include"
+            "${SKIA_INCLUDE_PATH}/../tools"
+            "${SKIA_INCLUDE_PATH}/../gm"
+            "${SKIA_INCLUDE_PATH}/core"
+            "${SKIA_INCLUDE_PATH}/config"
+            "${SKIA_INCLUDE_PATH}/gpu"
+            "${SKIA_INCLUDE_PATH}/android"
+            "${SKIA_INCLUDE_PATH}/atlastext"
+            "${SKIA_INCLUDE_PATH}/c"
+            "${SKIA_INCLUDE_PATH}/codec"
+            "${SKIA_INCLUDE_PATH}/effects"
+            "${SKIA_INCLUDE_PATH}/encode"
+            "${SKIA_INCLUDE_PATH}/pathops"
+            "${SKIA_INCLUDE_PATH}/ports"
+            "${SKIA_INCLUDE_PATH}/private"
+            "${SKIA_INCLUDE_PATH}/svg"
+            "${SKIA_INCLUDE_PATH}/utils"
+            "${SKIA_INCLUDE_PATH}/views")
+
+target_link_libraries(hello_ar_native
+                      android
+                      log
+                      GLESv2
+                      arcore
+                      sk_skia)
diff --git a/platform_tools/android/apps/arcore/build.gradle b/platform_tools/android/apps/arcore/build.gradle
new file mode 100644
index 0000000000..0e82ab8831
--- /dev/null
+++ b/platform_tools/android/apps/arcore/build.gradle
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+apply plugin: 'com.android.application'
+
+/*
+The arcore aar library contains the native shared libraries.  These are
+extracted before building to a temporary directory.
+ */
+def arcore_libpath = "${buildDir}/arcore-native"
+
+// Create a configuration to mark which aars to extract .so files from
+configurations { natives }
+
+android {
+    sourceSets.main.jni.srcDirs = [] //disable automatic ndk-build call
+    sourceSets.main.jniLibs.srcDir "src/main/libs"
+    productFlavors { arm64 {} }
+
+    setupSkiaLibraryBuild(project, applicationVariants, "libarcore")
+
+    compileSdkVersion 27
+    defaultConfig {
+        applicationId "org.skia.viewer"
+        // 24 is the minimum since ARCore only works with 24 and higher.
+        minSdkVersion 24
+        targetSdkVersion 27
+        versionCode 1
+        versionName "1.0"
+
+        externalNativeBuild {
+            cmake {
+                cppFlags "-std=c++11", "-Wall"
+                arguments "-DANDROID_STL=c++_static",
+                        "-DARCORE_LIBPATH=${arcore_libpath}/jni",
+                        "-DARCORE_INCLUDE=${project.rootDir}/../../libraries/include",
+                        "-DSKIA_INCLUDE_PATH=${project.rootDir}/../../../include"
+            }
+        }
+        ndk {
+            abiFilters "arm64-v8a"
+        }
+    }
+    flavorDimensions "base"
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+
+}
+
+dependencies {
+    // ARCore library
+    implementation 'com.google.ar:core:1.2.0'
+    natives 'com.google.ar:core:1.2.0'
+
+    implementation 'com.android.support:appcompat-v7:27.0.2'
+    implementation 'com.android.support:design:27.0.2'
+}
+
+// Extracts the shared libraries from aars in the natives configuration.
+// This is done so that NDK builds can access these libraries.
+task extractNativeLibraries() {
+    doFirst {
+        configurations.natives.files.each { f ->
+            copy {
+                from zipTree(f)
+                into arcore_libpath
+                include "jni/**/*"
+            }
+        }
+    }
+}
+
+
+tasks.whenTaskAdded {
+    task-> if (task.name.contains("external") && !task.name.contains("Clean")) {
+        task.dependsOn(extractNativeLibraries)
+
+        //make sure skia lib is built and copied in the correct directory before building arcore
+        tasks.whenTaskAdded {
+            t-> if (t.name.contains("CopySkiaLib")) {
+                task.dependsOn(t)
+            }
+        }
+    }
+}
+
diff --git a/platform_tools/android/apps/arcore/src/main/AndroidManifest.xml b/platform_tools/android/apps/arcore/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..975dc2592d
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.skia.arcore">
+
+  <uses-permission android:name="android.permission.CAMERA"/>
+  <!-- This tag indicates that this application requires ARCore.  This results in the application
+       only being visible in the Google Play Store on devices that support ARCore. -->
+  <uses-feature android:name="android.hardware.camera.ar" android:required="true"/>
+  <uses-feature android:glEsVersion="0x00020000" android:required="true" />
+
+  <application
+      android:allowBackup="true"
+      android:icon="@drawable/ic_launcher"
+      android:label="@string/app_name"
+      android:theme="@style/Theme.AppCompat.Light.NoActionBar"
+      android:usesCleartextTraffic="false">
+    <!-- This tag indicates that this application requires ARCore.  This results in the Google Play
+          Store downloading and installing ARCore along with the application. -->
+    <meta-data android:name="com.google.ar.core" android:value="required" />
+
+    <activity
+        android:name=".HelloArActivity"
+        android:label="@string/app_name"
+        android:configChanges="orientation|screenSize"
+        android:exported="true"
+        android:theme="@style/Theme.AppCompat.DayNight.NoActionBar"
+
+        android:screenOrientation="locked">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN"/>
+        <category android:name="android.intent.category.LAUNCHER"/>
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>
diff --git a/platform_tools/android/apps/arcore/src/main/assets/models/trigrid.png b/platform_tools/android/apps/arcore/src/main/assets/models/trigrid.png
new file mode 100644
index 0000000000..d85eedf72c
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/assets/models/trigrid.png
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/anchor_wrapper.cc b/platform_tools/android/apps/arcore/src/main/cpp/anchor_wrapper.cc
new file mode 100644
index 0000000000..832a8b001b
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/anchor_wrapper.cc
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include "hello_ar_application.h"
+#include "arcore_c_api.h"
+#include "anchor_wrapper.h"
+
+namespace hello_ar {
+
+    AnchorWrapper::AnchorWrapper(ArAnchor *anchor) : anchor(anchor) {}
+
+    const ArAnchor* AnchorWrapper::GetArAnchor() {
+        return anchor;
+    }
+    DrawableType AnchorWrapper::GetDrawableType() {
+        return drawableType;
+    }
+
+    void AnchorWrapper::SetArAnchor(ArAnchor* anchor) {
+        this->anchor = anchor;
+    }
+    void AnchorWrapper::SetDrawableType(DrawableType drawableType) {
+        this->drawableType = drawableType;
+    }
+
+
+
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/anchor_wrapper.h b/platform_tools/android/apps/arcore/src/main/cpp/anchor_wrapper.h
new file mode 100644
index 0000000000..ff05e57010
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/anchor_wrapper.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLO_AR_ANCHOR_WRAPPER_H_
+#define C_ARCORE_HELLO_AR_ANCHOR_WRAPPER_H_
+#include "arcore_c_api.h"
+
+namespace hello_ar {
+    enum DrawableType {
+        TEXT = 0, CIRCLE = 1, RECT = 2
+    };
+
+    class AnchorWrapper {
+    public:
+        AnchorWrapper(ArAnchor* anchor);
+
+        const ArAnchor* GetArAnchor();
+        DrawableType GetDrawableType();
+        bool GetInEditMode();
+
+        void SetArAnchor(ArAnchor* anchor);
+        void SetDrawableType(DrawableType drawableType);
+        void SetInEditMode(bool inEditMode);
+
+    private:
+        ArAnchor* anchor;
+        DrawableType drawableType;
+        bool inEditMode = false;
+    };
+}  // namespace hello_ar
+
+#endif
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/background_renderer.cc b/platform_tools/android/apps/arcore/src/main/cpp/background_renderer.cc
new file mode 100644
index 0000000000..ea7a7c7eb1
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/background_renderer.cc
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+// This modules handles drawing the passthrough camera image into the OpenGL
+// scene.
+
+#include <type_traits>
+
+#include "background_renderer.h"
+
+namespace hello_ar {
+    namespace {
+// Positions of the quad vertices in clip space (X, Y, Z).
+        const GLfloat kVertices[] = {
+                -1.0f, -1.0f, 0.0f, +1.0f, -1.0f, 0.0f,
+                -1.0f, +1.0f, 0.0f, +1.0f, +1.0f, 0.0f,
+        };
+
+// UVs of the quad vertices (S, T)
+        const GLfloat kUvs[] = {
+                0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
+        };
+
+        constexpr char kVertexShader[] = R"(
+    attribute vec4 vertex;
+    attribute vec2 textureCoords;
+    varying vec2 v_textureCoords;
+    void main() {
+      v_textureCoords = textureCoords;
+      gl_Position = vertex;
+    })";
+
+        constexpr char kFragmentShader[] = R"(
+    #extension GL_OES_EGL_image_external : require
+    precision mediump float;
+    uniform samplerExternalOES texture;
+    varying vec2 v_textureCoords;
+    void main() {
+      gl_FragColor = texture2D(texture, v_textureCoords);
+    })";
+
+    }  // namespace
+
+    void BackgroundRenderer::InitializeGlContent() {
+        shader_program_ = util::CreateProgram(kVertexShader, kFragmentShader);
+
+        if (!shader_program_) {
+            LOGE("Could not create program.");
+        }
+
+        glGenTextures(1, &texture_id_);
+        glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_id_);
+        glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        uniform_texture_ = glGetUniformLocation(shader_program_, "texture");
+        attribute_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+        attribute_uvs_ = glGetAttribLocation(shader_program_, "textureCoords");
+    }
+
+    void BackgroundRenderer::Draw(const ArSession *session, const ArFrame *frame) {
+        static_assert(std::extent<decltype(kUvs)>::value == kNumVertices * 2,
+                      "Incorrect kUvs length");
+        static_assert(std::extent<decltype(kVertices)>::value == kNumVertices * 3,
+                      "Incorrect kVertices length");
+
+        // If display rotation changed (also includes view size change), we need to
+        // re-query the uv coordinates for the on-screen portion of the camera image.
+        int32_t geometry_changed = 0;
+        ArFrame_getDisplayGeometryChanged(session, frame, &geometry_changed);
+        if (geometry_changed != 0 || !uvs_initialized_) {
+            ArFrame_transformDisplayUvCoords(session, frame, kNumVertices * 2, kUvs,
+                                             transformed_uvs_);
+            uvs_initialized_ = true;
+        }
+        glUseProgram(shader_program_);
+        glDepthMask(GL_FALSE);
+
+        glUniform1i(uniform_texture_, 1);
+        glActiveTexture(GL_TEXTURE1);
+        glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_id_);
+
+        glEnableVertexAttribArray(attribute_vertices_);
+        glVertexAttribPointer(attribute_vertices_, 3, GL_FLOAT, GL_FALSE, 0,
+                              kVertices);
+
+        glEnableVertexAttribArray(attribute_uvs_);
+        glVertexAttribPointer(attribute_uvs_, 2, GL_FLOAT, GL_FALSE, 0,
+                              transformed_uvs_);
+
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+        glUseProgram(0);
+        glDepthMask(GL_TRUE);
+        util::CheckGlError("BackgroundRenderer::Draw() error");
+    }
+
+    GLuint BackgroundRenderer::GetTextureId() const { return texture_id_; }
+
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/background_renderer.h b/platform_tools/android/apps/arcore/src/main/cpp/background_renderer.h
new file mode 100644
index 0000000000..0e4f701f44
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/background_renderer.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLO_AR_BACKGROUND_RENDERER_H_
+#define C_ARCORE_HELLO_AR_BACKGROUND_RENDERER_H_
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <cstdlib>
+
+#include "arcore_c_api.h"
+#include "util.h"
+
+namespace hello_ar {
+
+// This class renders the passthrough camera image into the OpenGL frame.
+    class BackgroundRenderer {
+    public:
+        BackgroundRenderer() = default;
+
+        ~BackgroundRenderer() = default;
+
+        // Sets up OpenGL state.  Must be called on the OpenGL thread and before any
+        // other methods below.
+        void InitializeGlContent();
+
+        // Draws the background image.  This methods must be called for every ArFrame
+        // returned by ArSession_update() to catch display geometry change events.
+        void Draw(const ArSession *session, const ArFrame *frame);
+
+        // Returns the generated texture name for the GL_TEXTURE_EXTERNAL_OES target.
+        GLuint GetTextureId() const;
+
+    private:
+        static constexpr int kNumVertices = 4;
+
+        GLuint shader_program_;
+        GLuint texture_id_;
+
+        GLuint attribute_vertices_;
+        GLuint attribute_uvs_;
+        GLuint uniform_texture_;
+
+        float transformed_uvs_[kNumVertices * 2];
+        bool uvs_initialized_ = false;
+    };
+}  // namespace hello_ar
+#endif  // C_ARCORE_HELLO_AR_BACKGROUND_RENDERER_H_
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/glm.h b/platform_tools/android/apps/arcore/src/main/cpp/glm.h
new file mode 100644
index 0000000000..cf2a8440b8
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/glm.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+#ifndef C_ARCORE_HELLOE_AR_GLM_H_
+#define C_ARCORE_HELLOE_AR_GLM_H_
+
+#define GLM_FORCE_RADIANS 1
+#include "glm.hpp"
+#include "gtc/matrix_transform.hpp"
+#include "gtc/type_ptr.hpp"
+#include "gtx/quaternion.hpp"
+
+#endif
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/hello_ar_application.cc b/platform_tools/android/apps/arcore/src/main/cpp/hello_ar_application.cc
new file mode 100644
index 0000000000..6e050f373c
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/hello_ar_application.cc
@@ -0,0 +1,987 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include "hello_ar_application.h"
+#include <gtx/string_cast.hpp>
+
+#include "anchor_wrapper.h"
+#include "plane_renderer.h"
+#include "pending_anchor.h"
+#include "util.h"
+#include "SkCanvas.h"
+#include "GrContext.h"
+#include "gl/GrGLTypes.h"
+#include "SkSurface.h"
+#include "SkTypeface.h"
+#include "SkFontStyle.h"
+#include "GrBackendSurface.h"
+#include "SkMatrix44.h"
+#include "SkMatrix.h"
+#include "SkTextBlob.h"
+#include "glm.h"
+#include "SkPoint3.h"
+#include "Sk3D.h"
+#include <math.h>       /* acos */
+#include "SkShaper.h"
+#include "Skottie.h"
+#include "SkAnimTimer.h"
+#include "Resources.h"
+#include "SkStream.h"
+
+namespace hello_ar {
+    namespace {
+        constexpr size_t kMaxNumberOfAndroidsToRender = 1;
+        constexpr int32_t kPlaneColorRgbaSize = 16;
+
+        const glm::vec3 kWhite = {255, 255, 255};
+
+        constexpr std::array<uint32_t, kPlaneColorRgbaSize> kPlaneColorRgba = {
+                {0xFFFFFFFF, 0xF44336FF, 0xE91E63FF, 0x9C27B0FF, 0x673AB7FF, 0x3F51B5FF,
+                        0x2196F3FF, 0x03A9F4FF, 0x00BCD4FF, 0x009688FF, 0x4CAF50FF, 0x8BC34AFF,
+                        0xCDDC39FF, 0xFFEB3BFF, 0xFFC107FF, 0xFF9800FF}};
+
+        inline glm::vec3 GetRandomPlaneColor() {
+            const int32_t colorRgba = kPlaneColorRgba[std::rand() % kPlaneColorRgbaSize];
+            return glm::vec3(((colorRgba >> 24) & 0xff) / 255.0f,
+                             ((colorRgba >> 16) & 0xff) / 255.0f,
+                             ((colorRgba >> 8) & 0xff) / 255.0f);
+        }
+    }  // namespace
+
+    HelloArApplication::HelloArApplication(AAssetManager *asset_manager)
+            : asset_manager_(asset_manager) {
+        LOGI("OnCreate()");
+    }
+
+    HelloArApplication::~HelloArApplication() {
+        if (ar_session_ != nullptr) {
+            ArSession_destroy(ar_session_);
+            ArFrame_destroy(ar_frame_);
+        }
+    }
+
+    void HelloArApplication::OnPause() {
+        LOGI("OnPause()");
+        if (ar_session_ != nullptr) {
+            ArSession_pause(ar_session_);
+        }
+    }
+
+    void HelloArApplication::OnResume(void *env, void *context, void *activity) {
+        LOGI("OnResume()");
+
+        if (ar_session_ == nullptr) {
+            ArInstallStatus install_status;
+            // If install was not yet requested, that means that we are resuming the
+            // activity first time because of explicit user interaction (such as
+            // launching the application)
+            bool user_requested_install = !install_requested_;
+
+            // === ATTENTION!  ATTENTION!  ATTENTION! ===
+            // This method can and will fail in user-facing situations.  Your
+            // application must handle these cases at least somewhat gracefully.  See
+            // HelloAR Java sample code for reasonable behavior.
+            CHECK(ArCoreApk_requestInstall(env, activity, user_requested_install,
+                                           &install_status) == AR_SUCCESS);
+
+            switch (install_status) {
+                case AR_INSTALL_STATUS_INSTALLED:
+                    break;
+                case AR_INSTALL_STATUS_INSTALL_REQUESTED:
+                    install_requested_ = true;
+                    return;
+            }
+
+            // === ATTENTION!  ATTENTION!  ATTENTION! ===
+            // This method can and will fail in user-facing situations.  Your
+            // application must handle these cases at least somewhat gracefully.  See
+            // HelloAR Java sample code for reasonable behavior.
+            CHECK(ArSession_create(env, context, &ar_session_) == AR_SUCCESS);
+            CHECK(ar_session_);
+
+            ArFrame_create(ar_session_, &ar_frame_);
+            CHECK(ar_frame_);
+
+            ArSession_setDisplayGeometry(ar_session_, display_rotation_, width_,
+                                         height_);
+        }
+
+        const ArStatus status = ArSession_resume(ar_session_);
+        CHECK(status == AR_SUCCESS);
+    }
+
+    void HelloArApplication::OnSurfaceCreated() {
+        LOGI("OnSurfaceCreated()");
+
+        background_renderer_.InitializeGlContent();
+        point_cloud_renderer_.InitializeGlContent();
+        plane_renderer_.InitializeGlContent(asset_manager_);
+    }
+
+    void HelloArApplication::OnDisplayGeometryChanged(int display_rotation,
+                                                      int width, int height) {
+        LOGI("OnSurfaceChanged(%d, %d)", width, height);
+        glViewport(0, 0, width, height);
+        display_rotation_ = display_rotation;
+        width_ = width;
+        height_ = height;
+
+        if (ar_session_ != nullptr) {
+            ArSession_setDisplayGeometry(ar_session_, display_rotation, width, height);;
+        }
+    }
+
+    void HelloArApplication::OnObjectRotationChanged(int rotation) {
+        LOGI("OnObjectRotationChanged(%d)", rotation);
+        currentObjectRotation = rotation;
+    }
+
+    void HelloArApplication::OnAction(float value) {
+        LOGI("OnAction(%.6f)", value);
+        currentValue = value;
+    }
+
+    void DrawText(SkCanvas *canvas, SkPaint *paint, const char text[]) {
+        float spacing = 0.05;
+        for (int i = 0; i < sizeof(text) / sizeof(text[0]); i++) {
+            const char letter[] = {text[i]};
+            size_t byteLength = strlen(static_cast<const char *>(letter));
+            canvas->drawText(letter, byteLength, spacing * i, 0, *paint);
+        }
+    }
+
+    void DrawAxes(SkCanvas *canvas, SkMatrix44 m) {
+        SkPaint p;
+        p.setStrokeWidth(10);
+        SkPoint3 src[4] = {
+                {0,   0,   0},
+                {0.2, 0,   0},
+                {0,   0.2, 0},
+                {0,   0,   0.2},
+        };
+        SkPoint dst[4];
+        Sk3MapPts(dst, m, src, 4);
+
+        const char str[] = "XYZ";
+        p.setColor(SK_ColorRED);
+        canvas->drawLine(dst[0], dst[1], p);
+
+        p.setColor(SK_ColorGREEN);
+        canvas->drawLine(dst[0], dst[2], p);
+
+        p.setColor(SK_ColorBLUE);
+        canvas->drawLine(dst[0], dst[3], p);
+    }
+
+    void DrawVector(SkCanvas *canvas, SkMatrix44 m, glm::vec3 begin, glm::vec3 end, SkColor c) {
+        SkPaint p;
+        p.setStrokeWidth(15);
+        SkPoint3 src[2] = {
+                {begin.x, begin.y, begin.z},
+                {end.x,   end.y,   end.z}
+        };
+        SkPoint dst[2];
+        Sk3MapPts(dst, m, src, 2);
+
+        const char str[] = "XYZ";
+        p.setColor(c);
+        canvas->drawLine(dst[0], dst[1], p);
+    }
+
+    void DrawBoundingBox(SkCanvas* canvas) {
+        SkPaint paint;
+        paint.setColor(SK_ColorYELLOW);
+        SkIRect bounds = canvas->getDeviceClipBounds();
+        SkRect b = SkRect::Make(bounds);
+
+        canvas->drawRect(b, paint);
+    }
+
+    void HelloArApplication::OnDrawFrame() {
+        grContext = GrContext::MakeGL();
+
+        GrBackendRenderTarget target;
+        sk_sp<SkSurface> surface = nullptr;
+        GrGLFramebufferInfo framebuffer_info;
+        framebuffer_info.fFBOID = 0;
+        framebuffer_info.fFormat = 0x8058;
+
+
+        glClearColor(0.9f, 0.9f, 0.9f, 1.0f);
+        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+        glEnable(GL_CULL_FACE);
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        if (ar_session_ == nullptr) return;
+
+        ArSession_setCameraTextureName(ar_session_,
+                                       background_renderer_.GetTextureId());
+
+        // Update session to get current frame and render camera background.
+        if (ArSession_update(ar_session_, ar_frame_) != AR_SUCCESS) {
+            LOGE("HelloArApplication::OnDrawFrame ArSession_update error");
+        }
+
+        // GET CAMERA INFO
+        ArCamera *ar_camera;
+        ArFrame_acquireCamera(ar_session_, ar_frame_, &ar_camera);
+
+        glm::mat4 view_mat;
+        glm::mat4 projection_mat;
+        ArCamera_getViewMatrix(ar_session_, ar_camera, glm::value_ptr(view_mat));
+        ArCamera_getProjectionMatrix(ar_session_, ar_camera,
+                /*near=*/0.1f, /*far=*/100.f,
+                                     glm::value_ptr(projection_mat));
+
+        ArTrackingState camera_tracking_state;
+        ArCamera_getTrackingState(ar_session_, ar_camera, &camera_tracking_state);
+        ArCamera_release(ar_camera);
+
+        background_renderer_.Draw(ar_session_, ar_frame_);
+
+        // If the camera isn't tracking don't bother rendering other objects.
+        if (camera_tracking_state != AR_TRACKING_STATE_TRACKING) {
+            return;
+        }
+
+        // Get light estimation value.
+        ArLightEstimate *ar_light_estimate;
+        ArLightEstimateState ar_light_estimate_state;
+        ArLightEstimate_create(ar_session_, &ar_light_estimate);
+
+        ArFrame_getLightEstimate(ar_session_, ar_frame_, ar_light_estimate);
+        ArLightEstimate_getState(ar_session_, ar_light_estimate,
+                                 &ar_light_estimate_state);
+
+        // Set light intensity to default. Intensity value ranges from 0.0f to 1.0f.
+        // The first three components are color scaling factors.
+        // The last one is the average pixel intensity in gamma space.
+        float color_correction[4] = {1.f, 1.f, 1.f, 1.f};
+        if (ar_light_estimate_state == AR_LIGHT_ESTIMATE_STATE_VALID) {
+            ArLightEstimate_getColorCorrection(ar_session_, ar_light_estimate,
+                                               color_correction);
+        }
+
+        ArLightEstimate_destroy(ar_light_estimate);
+        ar_light_estimate = nullptr;
+        SkMatrix44 skProj;
+        SkMatrix44 skView;
+        SkMatrix skViewport;
+
+        skProj = util::GlmMatToSkMat(projection_mat);
+        skView = util::GlmMatToSkMat(view_mat);
+        skViewport.setScale(width_ / 2, -height_ / 2);
+        skViewport.postTranslate(width_ / 2, height_ / 2);
+        target = GrBackendRenderTarget(width_, height_, 0, 0, framebuffer_info);
+        surface = SkSurface::MakeFromBackendRenderTarget(grContext.get(),
+                                                         target,
+                                                         kBottomLeft_GrSurfaceOrigin,
+                                                         kRGBA_8888_SkColorType,
+                                                         nullptr, nullptr);
+
+        // Render Andy objects.
+        std::vector<SkMatrix44> models;
+        //glm::mat4 model_mat(1.0f);
+        for (const auto &obj_iter : tracked_obj_set_) {
+            ArTrackingState tracking_state = AR_TRACKING_STATE_STOPPED;
+            ArAnchor_getTrackingState(ar_session_, obj_iter, &tracking_state);
+            if (tracking_state == AR_TRACKING_STATE_TRACKING) {
+                // Render object only if the tracking state is AR_TRACKING_STATE_TRACKING.
+                //util::GetTransformMatrixFromAnchor(ar_session_, obj_iter, &model_mat);
+                //DRAW ANDY
+                //andy_renderer_.Draw(glm::mat4(1), glm::mat4(1), model_mat, color_correction);
+
+                //PREPARE SKIA MATS
+
+                SkMatrix44 skModel;
+
+                switch (currentObjectRotation) {
+                    case 0: {
+                        auto iter = anchor_skmat4_axis_aligned_map_.find(obj_iter);
+                        if (iter != anchor_skmat4_axis_aligned_map_.end()) {
+                            skModel = iter->second;
+                            models.push_back(skModel);
+                        }
+                    }
+                        break;
+                    case 1: {
+                        auto iter = anchor_skmat4_camera_aligned_map_.find(obj_iter);
+                        if (iter != anchor_skmat4_camera_aligned_map_.end()) {
+                            skModel = iter->second;
+                            models.push_back(skModel);
+                        }
+                    }
+                        break;
+                    case 2: {
+                        auto iter = anchor_skmat4_snap_aligned_map_.find(obj_iter);
+                        if (iter != anchor_skmat4_snap_aligned_map_.end()) {
+                            skModel = iter->second;
+                            models.push_back(skModel);
+                        }
+                    }
+                        break;
+                    default: {
+                        auto iter = anchor_skmat4_axis_aligned_map_.find(obj_iter);
+                        if (iter != anchor_skmat4_axis_aligned_map_.end()) {
+                            skModel = iter->second;
+                            models.push_back(skModel);
+                        }
+                    }
+                        break;
+                }
+
+            }
+        }
+
+        // Update and render planes.
+        ArTrackableList *plane_list = nullptr;
+        ArTrackableList_create(ar_session_, &plane_list);
+        CHECK(plane_list != nullptr);
+
+        ArTrackableType plane_tracked_type = AR_TRACKABLE_PLANE;
+        ArSession_getAllTrackables(ar_session_, plane_tracked_type, plane_list);
+
+        int32_t plane_list_size = 0;
+        ArTrackableList_getSize(ar_session_, plane_list, &plane_list_size);
+        plane_count_ = plane_list_size;
+
+        for (int i = 0; i < plane_list_size; ++i) {
+            ArTrackable *ar_trackable = nullptr;
+            ArTrackableList_acquireItem(ar_session_, plane_list, i, &ar_trackable);
+            ArPlane *ar_plane = ArAsPlane(ar_trackable);
+            ArTrackingState out_tracking_state;
+            ArTrackable_getTrackingState(ar_session_, ar_trackable,
+                                         &out_tracking_state);
+
+            ArPlane *subsume_plane;
+            ArPlane_acquireSubsumedBy(ar_session_, ar_plane, &subsume_plane);
+            if (subsume_plane != nullptr) {
+                ArTrackable_release(ArAsTrackable(subsume_plane));
+                continue;
+            }
+
+            if (ArTrackingState::AR_TRACKING_STATE_TRACKING != out_tracking_state) {
+                continue;
+            }
+
+            ArTrackingState plane_tracking_state;
+            ArTrackable_getTrackingState(ar_session_, ArAsTrackable(ar_plane),
+                                         &plane_tracking_state);
+            if (plane_tracking_state == AR_TRACKING_STATE_TRACKING) {
+                const auto iter = plane_color_map_.find(ar_plane);
+                glm::vec3 color;
+                if (iter != plane_color_map_.end()) {
+                    color = iter->second;
+
+                    // If this is an already observed trackable release it so it doesn't
+                    // leave aof placing objects on surfaces (n additional reference dangling.
+                    ArTrackable_release(ar_trackable);
+                } else {
+                    // The first plane is always white.
+                    if (!first_plane_has_been_found_) {
+                        first_plane_has_been_found_ = true;
+                        color = kWhite;
+                    } else {
+                        color = GetRandomPlaneColor();
+                    }
+                    plane_color_map_.insert({ar_plane, color});
+                }
+
+                plane_renderer_.Draw(projection_mat, view_mat, ar_session_, ar_plane,
+                                     color);
+            }
+        }
+
+        ArTrackableList_destroy(plane_list);
+        plane_list = nullptr;
+
+        // Update and render point cloud.
+        ArPointCloud *ar_point_cloud = nullptr;
+        ArStatus point_cloud_status =
+                ArFrame_acquirePointCloud(ar_session_, ar_frame_, &ar_point_cloud);
+        if (point_cloud_status == AR_SUCCESS) {
+            point_cloud_renderer_.Draw(projection_mat * view_mat, ar_session_,
+                                       ar_point_cloud);
+            ArPointCloud_release(ar_point_cloud);
+        }
+        SkMatrix44 i = SkMatrix44::kIdentity_Constructor;
+
+        if (surface != nullptr) {
+            SkCanvas *canvas = surface->getCanvas();
+            SkAutoCanvasRestore acr(canvas, true);
+            SkMatrix44 vpv = skViewport * skProj * skView;
+            for(SkMatrix44 skModel: models) {
+                SkMatrix44 i = SkMatrix44::kIdentity_Constructor;
+                canvas->setMatrix(i);
+                SkMatrix44 mvpv = skViewport * skProj * skView * skModel;
+
+                //Draw XYZ axes
+                DrawAxes(canvas, mvpv);
+                //Drawing camera orientation
+            /*	DrawVector(canvas, vpv, begins[0], ends[0], SK_ColorMAGENTA);
+                DrawVector(canvas, vpv, begins[0], ends[1], SK_ColorYELLOW);
+                DrawVector(canvas, vpv, begins[0], ends[2], SK_ColorCYAN);*/
+
+                canvas->concat(mvpv);
+                SkPaint paint;
+
+                //Draw Circle
+                paint.setColor(0x80700000);
+                canvas->drawCircle(0, 0, 0.1, paint);
+
+                //Draw Text
+                paint.setColor(SK_ColorBLUE);
+                if (currentValue != 0) {
+                    paint.setTextSize(currentValue);
+                } else {
+                    paint.setTextSize(0.1);
+                }
+
+                paint.setAntiAlias(true);
+                const char text[] = "SkAR";
+                size_t byteLength = strlen(static_cast<const char *>(text));
+                SkShaper shaper(nullptr);
+                SkTextBlobBuilder builder;
+                SkPoint p = SkPoint::Make(0, 0);
+                shaper.shape(&builder, paint, text, byteLength, true, p, 10);
+                canvas->drawTextBlob(builder.make(), 0, 0, paint);
+
+                //DrawBoundingBox(canvas);
+            }
+            canvas->flush();
+        }
+    }
+
+
+    bool HelloArApplication::OnTouchedFirst(float x, float y, int drawMode) {
+        LOGI("Entered OnTouchedFirst");
+        if (pendingAnchor != nullptr) {
+            delete pendingAnchor;
+        }
+        SkPoint p = SkPoint::Make(x,y);
+        pendingAnchor = new PendingAnchor(p);
+        bool editAnchor = false;
+
+        if (ar_frame_ != nullptr && ar_session_ != nullptr) {
+            ArHitResultList *hit_result_list = nullptr;
+            ArHitResultList_create(ar_session_, &hit_result_list);
+            CHECK(hit_result_list);
+            ArFrame_hitTest(ar_session_, ar_frame_, x, y, hit_result_list);
+
+            int32_t hit_result_list_size = 0;
+            ArHitResultList_getSize(ar_session_, hit_result_list, &hit_result_list_size);
+            ArHitResult *ar_hit_result = nullptr;
+            ArPose *out_pose = nullptr;
+            ArPlane* hitPlane = nullptr;
+            for (int32_t i = 0; i < hit_result_list_size; ++i) {
+                ArHitResult *ar_hit = nullptr;
+                ArPose *created_out_pose = nullptr;
+                ArHitResult_create(ar_session_, &ar_hit);
+                ArHitResultList_getItem(ar_session_, hit_result_list, i, ar_hit);
+
+                if (ar_hit == nullptr) {
+                    LOGE("HelloArApplication::OnTouched ArHitResultList_getItem error");
+                    return editAnchor;
+                }
+
+                ArTrackable *ar_trackable = nullptr;
+                ArHitResult_acquireTrackable(ar_session_, ar_hit, &ar_trackable);
+                ArTrackableType ar_trackable_type = AR_TRACKABLE_NOT_VALID;
+                ArTrackable_getType(ar_session_, ar_trackable, &ar_trackable_type);
+                // Creates an anchor if a plane or an oriented point was hit.
+                if (AR_TRACKABLE_PLANE == ar_trackable_type) {
+                    ArPose *hit_pose = nullptr;
+                    ArPose_create(ar_session_, nullptr, &hit_pose);
+                    ArHitResult_getHitPose(ar_session_, ar_hit, hit_pose);
+                    int32_t in_polygon = 0;
+                    ArPlane *ar_plane = ArAsPlane(ar_trackable);
+                    ArPlane_isPoseInPolygon(ar_session_, ar_plane, hit_pose, &in_polygon);
+
+                    {
+                        // Use hit pose and camera pose to check if hittest is from the
+                        // back of the plane, if it is, no need to create the anchor.
+                        ArPose *camera_pose = nullptr;
+                        ArPose_create(ar_session_, nullptr, &camera_pose);
+                        ArCamera *ar_camera;
+                        ArFrame_acquireCamera(ar_session_, ar_frame_, &ar_camera);
+                        ArCamera_getPose(ar_session_, ar_camera, camera_pose);
+                        float normal_distance_to_plane = util::CalculateDistanceToPlane(
+                                ar_session_, *hit_pose, *camera_pose);
+
+                        if (!in_polygon || normal_distance_to_plane < 0) {
+                            ArPose_destroy(camera_pose);
+                            continue;
+                        }
+                        ArPose_destroy(camera_pose);
+                        ArCamera_release(ar_camera);
+                    }
+
+                    //Raw pose of hit location
+                    float out_hit_raw[] = {0, 0, 0, 0, 0, 0, 0};
+                    ArPose_getPoseRaw(ar_session_, hit_pose, out_hit_raw);
+                    ArPose_destroy(hit_pose);
+
+                    //Position of anchor
+                    glm::vec4 pendingAnchorPos(out_hit_raw[4], out_hit_raw[5], out_hit_raw[6], 1);
+                    pendingAnchor->SetContainingPlane(ar_plane);
+
+                    //Check if plane contains approx the same anchor
+                    auto planeAnchors = plane_anchors_map_.find(ar_plane);
+                    if (planeAnchors != plane_anchors_map_.end()) {
+                        //other anchors existed on this plane
+                        std::vector<ArAnchor*> anchors = planeAnchors->second;
+                        int i = 0;
+                        LOGI("Size of anchor list: %d", (int) anchors.size());
+                        for(ArAnchor* const& anchor: anchors) {
+                            //Get anchor's pose
+                            i++;
+                            LOGI("CHECKING: Anchor #%d", i);
+                            ArPose *anchor_pose = nullptr;
+                            ArPose_create(ar_session_, nullptr, &anchor_pose);
+                            ArAnchor_getPose(ar_session_, anchor, anchor_pose);
+                            float out_anchor_raw[] = {0, 0, 0, 0, 0, 0, 0};
+                            ArPose_getPoseRaw(ar_session_, anchor_pose, out_anchor_raw);
+                            ArPose_destroy(anchor_pose);
+                            glm::vec4 oldAnchorPos(out_anchor_raw[4], out_anchor_raw[5], out_anchor_raw[6], 1);
+                            oldAnchorPos = oldAnchorPos - pendingAnchorPos;
+                            float distance = util::Magnitude(glm::vec3(oldAnchorPos));
+                            if (distance < 0.1f) {
+                                LOGI("TouchFirst: Editing old anchor!");
+                                editAnchor = true;
+                                pendingAnchor->SetArAnchor(anchor);
+                                pendingAnchor->SetEditMode(true);
+
+                                ArHitResult_destroy(ar_hit);
+                                ArHitResultList_destroy(hit_result_list);
+                                LOGI("TouchFirst: Edit %d", editAnchor);
+                                return editAnchor;
+                            }
+                        }
+                    }
+
+                    //actual hit result, and containing plane
+                    ar_hit_result = ar_hit;
+                    hitPlane = ar_plane;
+
+                    //new anchor pos
+                    float wanted_raw_pose[] = {0, 0, 0, 0, out_hit_raw[4], out_hit_raw[5], out_hit_raw[6]};
+                    ArPose_create(ar_session_, wanted_raw_pose, &created_out_pose);
+                    out_pose = created_out_pose;
+                    break;
+                }
+            }
+
+
+            if (ar_hit_result) {
+                LOGI("TouchFirst: Adding new anchor!");
+                ArAnchor *anchor = nullptr;
+                pendingAnchor->SetEditMode(false);
+
+                if (ArSession_acquireNewAnchor(ar_session_, out_pose, &anchor) != AR_SUCCESS) {
+                    LOGE("HelloArApplication::OnTouched ArHitResult_acquireNewAnchor error");
+                    LOGI("TouchFirst: Failed to acquire new anchor");
+                    delete hitPlane;
+                    delete pendingAnchor;
+                    pendingAnchor = nullptr;
+                    LOGI("TouchFirst: Edit %d", editAnchor);
+                    return editAnchor;
+                }
+                pendingAnchor->SetArAnchor(anchor);
+
+                ArHitResult_destroy(ar_hit_result);
+                ArHitResultList_destroy(hit_result_list);
+                ArPose_destroy(out_pose);
+                hit_result_list = nullptr;
+                LOGI("TouchFirst: Edit %d", editAnchor);
+                return editAnchor;
+            }
+
+            LOGI("TouchFirst: didn't hit anything");
+            delete hitPlane;
+            delete pendingAnchor;
+            pendingAnchor = nullptr;
+            LOGI("TouchFirst: Edit %d", editAnchor);
+            return editAnchor;
+        }
+    }
+
+    void HelloArApplication::AddAnchor(ArAnchor* anchor, ArPlane* containingPlane) {
+        //delete anchor from matrices maps
+        //releasing the anchor if it is not tracking anymore
+        ArTrackingState tracking_state = AR_TRACKING_STATE_STOPPED;
+        ArAnchor_getTrackingState(ar_session_, anchor, &tracking_state);
+        if (tracking_state != AR_TRACKING_STATE_TRACKING) {
+            RemoveAnchor(anchor);
+            return;
+        }
+
+        //releasing the first anchor if we exceeded maximum number of objects to be rendered
+        if (tracked_obj_set_.size() >= kMaxNumberOfAndroidsToRender) {
+            RemoveAnchor(tracked_obj_set_[0]);
+        }
+
+        //updating the containing plane with a new anchor
+        auto planeAnchors = plane_anchors_map_.find(containingPlane);
+        if (planeAnchors != plane_anchors_map_.end()) {
+            //other anchors existed on this plane
+            LOGI("TouchFinal: ADDING TO OLD ANCHORS");
+            std::vector<ArAnchor*> anchors = planeAnchors->second;
+            anchors.push_back(anchor);
+            plane_anchors_map_[containingPlane] = anchors;
+            anchor_plane_map_.insert({anchor, containingPlane});
+        } else {
+            LOGI("TouchFinal: NEW SET OF ANCHORS");
+            std::vector<ArAnchor*> anchors;
+            anchors.push_back(anchor);
+            plane_anchors_map_.insert({containingPlane, anchors});
+            anchor_plane_map_.insert({anchor, containingPlane});
+        }
+
+        tracked_obj_set_.push_back(anchor);
+    }
+
+    void HelloArApplication::OnTouchTranslate(float x, float y) {
+        LOGI("Entered On Edit Touched");
+        ArAnchor *anchor = pendingAnchor->GetArAnchor();
+        glm::mat4 matrix = util::SkMatToGlmMat(
+                anchor_skmat4_axis_aligned_map_.find(anchor)->second);
+
+        if (ar_frame_ != nullptr && ar_session_ != nullptr) {
+            ArHitResultList *hit_result_list = nullptr;
+            ArHitResultList_create(ar_session_, &hit_result_list);
+            CHECK(hit_result_list);
+            ArFrame_hitTest(ar_session_, ar_frame_, x, y, hit_result_list);
+
+            int32_t hit_result_list_size = 0;
+            ArHitResultList_getSize(ar_session_, hit_result_list, &hit_result_list_size);
+            ArHitResult *ar_hit_result = nullptr;
+            ArPose *out_pose = nullptr;
+            ArPlane *hitPlane = nullptr;
+            for (int32_t i = 0; i < hit_result_list_size; ++i) {
+                ArHitResult *ar_hit = nullptr;
+                ArPose *created_out_pose = nullptr;
+                ArHitResult_create(ar_session_, &ar_hit);
+                ArHitResultList_getItem(ar_session_, hit_result_list, i, ar_hit);
+
+                if (ar_hit == nullptr) {
+                    LOGE("HelloArApplication::OnTouched ArHitResultList_getItem error");
+                    return;
+                }
+
+                ArTrackable *ar_trackable = nullptr;
+                ArHitResult_acquireTrackable(ar_session_, ar_hit, &ar_trackable);
+                ArTrackableType ar_trackable_type = AR_TRACKABLE_NOT_VALID;
+                ArTrackable_getType(ar_session_, ar_trackable, &ar_trackable_type);
+                // Creates an anchor if a plane or an oriented point was hit.
+                if (AR_TRACKABLE_PLANE == ar_trackable_type) {
+                    ArPose *hit_pose = nullptr;
+                    ArPose_create(ar_session_, nullptr, &hit_pose);
+                    ArHitResult_getHitPose(ar_session_, ar_hit, hit_pose);
+                    int32_t in_polygon = 0;
+                    ArPlane *ar_plane = ArAsPlane(ar_trackable);
+                    ArPlane_isPoseInPolygon(ar_session_, ar_plane, hit_pose, &in_polygon);
+
+                    {
+                        // Use hit pose and camera pose to check if hittest is from the
+                        // back of the plane, if it is, no need to create the anchor.
+                        ArPose *camera_pose = nullptr;
+                        ArPose_create(ar_session_, nullptr, &camera_pose);
+                        ArCamera *ar_camera;
+                        ArFrame_acquireCamera(ar_session_, ar_frame_, &ar_camera);
+                        ArCamera_getPose(ar_session_, ar_camera, camera_pose);
+                        float normal_distance_to_plane = util::CalculateDistanceToPlane(
+                                ar_session_, *hit_pose, *camera_pose);
+
+                        if (!in_polygon || normal_distance_to_plane < 0) {
+                            ArPose_destroy(camera_pose);
+                            continue;
+                        }
+                        ArPose_destroy(camera_pose);
+                        ArCamera_release(ar_camera);
+                    }
+
+                    //Raw pose of hit location
+                    float out_hit_raw[] = {0, 0, 0, 0, 0, 0, 0};
+                    ArPose_getPoseRaw(ar_session_, hit_pose, out_hit_raw);
+                    ArPose_destroy(hit_pose);
+
+                    //Translate by new amount
+                    glm::vec4 newPos(out_hit_raw[4], out_hit_raw[5], out_hit_raw[6], 1);
+                    glm::vec4 oldPos = pendingAnchor->GetAnchorPos(ar_session_);
+                    glm::vec3 movement = glm::vec3(newPos - oldPos);
+
+
+                    //CAMERA SETTINGS
+                    glm::mat4 backToOrigin(1);
+                    backToOrigin = glm::translate(backToOrigin, -glm::vec3(oldPos));
+                    glm::mat4 backToPlane(1);
+                    backToPlane = glm::translate(backToPlane, glm::vec3(oldPos));
+
+                    //Axes of Skia object: start with XYZ, totate to get X(-Z)Y, paste on plane, go back to origin --> plane orientation but on origin
+                    glm::vec3 objX = glm::normalize(glm::vec3(
+                            backToOrigin * matrix *
+                            glm::vec4(1, 0, 0, 1))); //X still X
+                    glm::vec3 objY = glm::normalize(glm::vec3(
+                            backToOrigin * matrix *
+                            glm::vec4(0, 1, 0, 1))); //Y is now Z
+                    glm::vec3 objZ = glm::normalize(glm::vec3(
+                            backToOrigin * matrix *
+                            glm::vec4(0, 0, 1, 1))); //Z is now Y
+
+
+                    glm::mat4 translate(1);
+                    translate = glm::translate(translate, movement);
+                    matrix = translate * matrix;
+                    RemoveAnchor(anchor);
+
+
+
+                    //new anchor pos
+                    float wanted_raw_pose[] = {0, 0, 0, 0, out_hit_raw[4], out_hit_raw[5],
+                                               out_hit_raw[6]};
+                    ArPose_create(ar_session_, wanted_raw_pose, &created_out_pose);
+                    out_pose = created_out_pose;
+                    ar_hit_result = ar_hit;
+                    break;
+                }
+            }
+
+            if (ar_hit_result) {
+                LOGI("TouchFirst: Adding new anchor!");
+                ArAnchor *anchor = nullptr;
+                pendingAnchor->SetEditMode(false);
+
+                if (ArSession_acquireNewAnchor(ar_session_, out_pose, &anchor) != AR_SUCCESS) {
+                    LOGE("HelloArApplication::OnTouched ArHitResult_acquireNewAnchor error");
+                    LOGI("TouchFirst: Failed to acquire new anchor");
+                    delete hitPlane;
+                    delete pendingAnchor;
+                    pendingAnchor = nullptr;
+                    return;
+                }
+                pendingAnchor->SetArAnchor(anchor);
+                anchor_skmat4_axis_aligned_map_[anchor] = util::GlmMatToSkMat(matrix);
+
+                //Add anchor
+                AddAnchor(anchor, pendingAnchor->GetContainingPlane());
+
+
+                ArHitResult_destroy(ar_hit_result);
+                ArHitResultList_destroy(hit_result_list);
+                ArPose_destroy(out_pose);
+                hit_result_list = nullptr;
+                return;
+            }
+        }
+    }
+
+    void HelloArApplication::RemoveAnchor(ArAnchor* anchor) {
+        //delete anchor from matrices maps
+        anchor_skmat4_axis_aligned_map_.erase(anchor);
+        anchor_skmat4_camera_aligned_map_.erase(anchor);
+        anchor_skmat4_snap_aligned_map_.erase(anchor);
+
+        auto containingPlaneIter = anchor_plane_map_.find(anchor);
+        if (containingPlaneIter != anchor_plane_map_.end()) {
+            ArPlane*  containingPlane = containingPlaneIter->second;
+            auto planeAnchors = plane_anchors_map_.find(containingPlane);
+            if (planeAnchors != plane_anchors_map_.end()) {
+                //delete this anchor from the list of anchors associated with its plane
+                std::vector<ArAnchor*> anchors = planeAnchors->second;
+                anchors.erase(std::remove(anchors.begin(), anchors.end(), anchor), anchors.end());
+                plane_anchors_map_[planeAnchors->first] = anchors;
+
+                //delete anchor from map of anchor to plane
+                anchor_plane_map_.erase(anchor);
+            }
+        }
+        //delete anchor from list of tracked objects
+        tracked_obj_set_.erase(std::remove(tracked_obj_set_.begin(), tracked_obj_set_.end(), anchor), tracked_obj_set_.end());
+        ArAnchor_release(anchor);
+    }
+
+    void HelloArApplication::UpdateMatrixMaps(ArAnchor* anchorKey, glm::mat4 aaMat, glm::mat4 caMat, glm::mat4 snapMat) {
+        anchor_skmat4_axis_aligned_map_.insert({anchorKey, util::GlmMatToSkMat(aaMat)});
+        anchor_skmat4_camera_aligned_map_.insert({anchorKey, util::GlmMatToSkMat(caMat)});
+        anchor_skmat4_snap_aligned_map_.insert({anchorKey, util::GlmMatToSkMat(snapMat)});
+    }
+
+    void SetSkiaInitialRotation(glm::mat4& initRotation) {
+        initRotation = glm::rotate(initRotation, SK_ScalarPI / 2, glm::vec3(1, 0, 0));
+    }
+
+    void SetSkiaObjectAxes(glm::vec3& x, glm::vec3& y, glm::vec3& z, glm::mat4 transform) {
+        x = glm::normalize(glm::vec3(transform * glm::vec4(1, 0, 0, 1))); //X still X
+        y = glm::normalize(glm::vec3(transform  * glm::vec4(0, 1, 0, 1))); //Y is now Z
+        z = glm::normalize(glm::vec3(transform  * glm::vec4(0, 0, 1, 1))); //Z is now Y
+    }
+
+    void SetCameraAlignedRotation(glm::mat4& rotateTowardsCamera, float& rotationDirection, const glm::vec3& toProject, const glm::vec3& skiaY, const glm::vec3& skiaZ) {
+        glm::vec3 hitLookProj = -util::ProjectOntoPlane(toProject, skiaZ);
+        float angleRad = util::AngleRad(skiaY, hitLookProj);
+        glm::vec3 cross = glm::normalize(glm::cross(skiaY, hitLookProj));
+
+        //outs
+        rotationDirection = util::Dot(cross, skiaZ);
+        rotateTowardsCamera = glm::rotate(rotateTowardsCamera, angleRad, rotationDirection * skiaZ);
+    }
+
+    struct CameraAlignmentInfo {
+        glm::vec3& skiaY, skiaZ;
+        glm::mat4& preRot, postRot;
+
+        CameraAlignmentInfo(glm::vec3& skiaY, glm::vec3& skiaZ, glm::mat4 preRot, glm::mat4 postRot)
+                : skiaY(skiaY), skiaZ(skiaZ), preRot(preRot), postRot(postRot) {}
+    };
+
+    void SetCameraAlignedVertical(glm::mat4& caMat, const glm::mat4& camRot, const CameraAlignmentInfo& camAlignInfo) {
+        //Camera axes
+        glm::vec3 xCamera = glm::vec3(glm::vec4(1, 0, 0, 1) * camRot);
+        glm::vec3 yCamera = glm::vec3(glm::vec4(0, 1, 0, 1) * camRot);
+        glm::vec3 zCamera = glm::vec3(glm::vec4(0, 0, -1, 1) * camRot);
+
+        //Get matrix that rotates object from plane towards the wanted angle
+        glm::mat4 rotateTowardsCamera(1);
+        float rotationDirection = 1;
+        SetCameraAlignedRotation(rotateTowardsCamera, rotationDirection, yCamera, camAlignInfo.skiaY, camAlignInfo.skiaZ);
+
+        //LogOrientation(dot, angleRad, "Vertical/Wall");
+        glm::mat4 flip(1);
+        flip = glm::rotate(flip, SK_ScalarPI, rotationDirection * camAlignInfo.skiaZ);
+        caMat = camAlignInfo.postRot * flip * rotateTowardsCamera * camAlignInfo.preRot;
+    }
+
+    void SetCameraAlignedHorizontal(glm::mat4& caMat, ArPlaneType planeType, const glm::vec3 hitLook, const CameraAlignmentInfo& camAlignInfo) {
+        //Ceiling or Floor: follow hit location
+        //Get matrix that rotates object from plane towards the wanted angle
+        glm::mat4 rotateTowardsCamera(1);
+        float rotationDirection = 1;
+        SetCameraAlignedRotation(rotateTowardsCamera, rotationDirection, hitLook, camAlignInfo.skiaY, camAlignInfo.skiaZ);
+
+        if (planeType == ArPlaneType::AR_PLANE_HORIZONTAL_DOWNWARD_FACING) {
+            //ceiling
+            //LogOrientation(dot, angleRad, "Ceiling");
+            glm::mat4 flip(1);
+            flip = glm::rotate(flip, SK_ScalarPI, rotationDirection * camAlignInfo.skiaZ);
+            caMat = camAlignInfo.postRot * flip * rotateTowardsCamera * camAlignInfo.preRot;
+        } else {
+            //floor or tabletop
+            //LogOrientation(dot, angleRad, "Floor");
+            caMat = camAlignInfo.postRot * rotateTowardsCamera * camAlignInfo.preRot;
+        }
+    }
+
+
+
+    void HelloArApplication::SetCameraAlignedMatrix(glm::mat4& caMat, glm::vec3 hitPos, glm::mat4& planeModel, const glm::mat4& initRotation) {
+        //Translation matrices: from plane to origin, and from origin to plane
+        glm::mat4 backToOrigin(1);
+        backToOrigin = glm::translate(backToOrigin, -hitPos);
+        glm::mat4 backToPlane(1);
+        backToPlane = glm::translate(backToPlane, hitPos);
+
+        //Axes of Skia object: start with XYZ, totate to get X(-Z)Y, paste on plane, go back to origin --> plane orientation but on origin
+        glm::vec3 skiaX, skiaY, skiaZ;
+        SetSkiaObjectAxes(skiaX, skiaY, skiaZ, backToOrigin * planeModel * initRotation);
+
+        //Get camera position & rotation
+        glm::vec3 cameraPos;
+        glm::mat4 cameraRotationMatrix;
+        util::GetCameraInfo(ar_session_, ar_frame_, cameraPos, cameraRotationMatrix);
+
+        //Set matrix depending on type of surface
+        ArPlaneType planeType = AR_PLANE_VERTICAL;
+        ArPlane_getType(ar_session_, pendingAnchor->GetContainingPlane(), &planeType);
+
+        //Set CamerAlignmentInfo
+        CameraAlignmentInfo camAlignInfo(skiaY, skiaZ, backToOrigin * planeModel * initRotation, backToPlane);
+
+        if (planeType == ArPlaneType::AR_PLANE_VERTICAL) {
+            //Wall: follow phone orientation
+            SetCameraAlignedVertical(caMat, cameraRotationMatrix, camAlignInfo);
+        } else {
+            //Ceiling or Floor: follow hit location
+            glm::vec3 hitLook(hitPos - cameraPos);
+            SetCameraAlignedHorizontal(caMat, planeType, hitLook, camAlignInfo);
+        }
+    }
+
+
+    void HelloArApplication::SetModelMatrices(glm::mat4& aaMat, glm::mat4& caMat, glm::mat4& snapMat, const glm::mat4& planeModel) {
+        //Brings Skia world to ARCore world
+        glm::mat4 initRotation(1);
+        SetSkiaInitialRotation(initRotation);
+
+        //Copy plane model for editing
+        glm::mat4 copyPlaneModel(planeModel);
+
+        //Set snap matrix
+        //snapMat = copyPlaneModel * initRotation;
+
+        //Set axis-aligned matrix
+        glm::vec4 anchorPos = pendingAnchor->GetAnchorPos(ar_session_);
+        copyPlaneModel[3] = anchorPos;
+        aaMat = planeModel * initRotation;
+
+        //Set camera-aligned matrix
+        //SetCameraAlignedMatrix(caMat, glm::vec3(anchorPos), copyPlaneModel, initRotation);
+    }
+
+    void GetPlaneModelMatrix(glm::mat4& planeModel, ArSession* arSession, ArPlane* arPlane) {
+        ArPose *plane_pose = nullptr;
+        ArPose_create(arSession, nullptr, &plane_pose);
+        ArPlane_getCenterPose(arSession, arPlane, plane_pose);
+        util::GetTransformMatrixFromPose(arSession, plane_pose, &planeModel);
+        ArPose_destroy(plane_pose);
+    }
+
+    void HelloArApplication::OnTouchedFinal(int type) {
+        LOGI("Entered OnTouchedFinal");
+        if (pendingAnchor == nullptr) {
+            LOGI("WARNING: Entered OnTouchedFinal but no pending anchor..");
+            return;
+        }
+
+        if (pendingAnchor->GetEditMode()) {
+            LOGI("WARNING: Editing old anchor in OnTouchedFinal!");
+        }
+
+        //Get necessary pending anchor info
+        ArPlane* containingPlane = pendingAnchor->GetContainingPlane();
+        glm::vec4 pendingAnchorPos = pendingAnchor->GetAnchorPos(ar_session_);
+        ArAnchor* actualAnchor = pendingAnchor->GetArAnchor();
+
+        //Plane model matrix
+        glm::mat4 planeModel(1);
+        GetPlaneModelMatrix(planeModel, ar_session_, containingPlane);
+
+        //Setup skia object model matrices
+        glm::mat4 matrixAxisAligned(1);
+        glm::mat4 matrixCameraAligned(1);
+        glm::mat4 matrixSnapAligned(1);
+        SetModelMatrices(matrixAxisAligned, matrixCameraAligned, matrixSnapAligned, planeModel);
+
+        //Update anchor -> model matrix datastructures
+        UpdateMatrixMaps(actualAnchor, matrixAxisAligned, matrixCameraAligned, matrixSnapAligned);
+
+        //Add anchor to aux datastructures
+        AddAnchor(actualAnchor, containingPlane);
+    }
+
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/hello_ar_application.h b/platform_tools/android/apps/arcore/src/main/cpp/hello_ar_application.h
new file mode 100644
index 0000000000..2ebec7ed65
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/hello_ar_application.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLOE_AR_HELLO_AR_APPLICATION_H_
+#define C_ARCORE_HELLOE_AR_HELLO_AR_APPLICATION_H_
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <android/asset_manager.h>
+#include <jni.h>
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <GrContext.h>
+#include <gl/GrGLTypes.h>
+#include <GrBackendSurface.h>
+#include <SkSurface.h>
+#include <Skottie.h>
+
+#include "arcore_c_api.h"
+#include "background_renderer.h"
+#include "glm.h"
+#include "plane_renderer.h"
+#include "point_cloud_renderer.h"
+#include "util.h"
+#include "pending_anchor.h"
+
+namespace hello_ar {
+
+// HelloArApplication handles all application logics.
+    class HelloArApplication {
+    public:
+        // Constructor and deconstructor.
+        HelloArApplication() = default;
+
+        HelloArApplication(AAssetManager *asset_manager);
+
+        ~HelloArApplication();
+
+        SkMatrix SkiaRenderer(const glm::mat4 &proj, const glm::mat4 &view, const glm::mat4 &model);
+
+        // OnPause is called on the UI thread from the Activity's onPause method.
+        void OnPause();
+
+        // OnResume is called on the UI thread from the Activity's onResume method.
+        void OnResume(void *env, void *context, void *activity);
+
+        // OnSurfaceCreated is called on the OpenGL thread when GLSurfaceView
+        // is created.
+        void OnSurfaceCreated();
+
+        // OnDisplayGeometryChanged is called on the OpenGL thread when the
+        // render surface size or display rotation changes.
+        //
+        // @param display_rotation: current display rotation.
+        // @param width: width of the changed surface view.
+        // @param height: height of the changed surface view.
+        void OnDisplayGeometryChanged(int display_rotation, int width, int height);
+
+        void OnObjectRotationChanged(int rotation);
+
+        void OnAction(float value);
+
+        // OnDrawFrame is called on the OpenGL thread to render the next frame.
+        void OnDrawFrame();
+
+        bool OnTouchedFirst(float x, float y, int drawMode);
+
+        void OnTouchTranslate(float x, float y);
+
+        void OnEditTouched(float x, float y);
+
+        void OnTouchedFinal(int type);
+
+        void RemoveAnchor(ArAnchor* anchor);
+
+        void AddAnchor(ArAnchor* anchor, ArPlane* containingPlane);
+
+        void UpdateMatrixMaps(ArAnchor* anchorKey, glm::mat4 aaMat, glm::mat4 caMat, glm::mat4 snapMat);
+
+        void SetModelMatrices(glm::mat4& aaMat, glm::mat4& caMat, glm::mat4& snapMat, const glm::mat4& planeModel);
+
+        void SetCameraAlignedMatrix(glm::mat4& caMat, glm::vec3 hitPos, glm::mat4& planeModel, const glm::mat4& initRotation);
+
+        // Returns true if any planes have been detected.  Used for hiding the
+        // "searching for planes" snackbar.
+        bool HasDetectedPlanes() const { return plane_count_ > 0; }
+
+        glm::mat4
+        ComputeCameraAlignedMatrix(ArPlane *arPlane, glm::mat4 planeModel, glm::mat4 initRotation,
+                                   glm::vec4 anchorPos,
+                                   glm::vec3 cameraPos, glm::vec3 hitPos,
+                                   float cameraDisplayOutRaw[]);
+
+    private:
+        ArSession *ar_session_ = nullptr;
+        ArFrame *ar_frame_ = nullptr;
+
+        PendingAnchor* pendingAnchor = nullptr;
+
+        //SKIA VARS
+        sk_sp<GrContext> grContext;
+        sk_sp<skottie::Animation> fAnim;
+        SkScalar fAnimT = 0;
+
+        bool install_requested_ = false;
+        int width_ = 1;
+        int height_ = 1;
+        int display_rotation_ = 0;
+
+        int currentObjectRotation = 0;
+        float currentValue = 0;
+
+        std::vector<glm::vec3> begins;
+        std::vector<glm::vec3> ends;
+
+        AAssetManager *const asset_manager_;
+
+        // The anchors at which we are drawing android models
+        std::vector<ArAnchor *> tracked_obj_set_;
+
+        // Stores the randomly-selected color each plane is drawn with
+        std::unordered_map<ArPlane *, glm::vec3> plane_color_map_;
+
+        std::unordered_map<ArAnchor *, SkMatrix44> anchor_skmat4_axis_aligned_map_;
+        std::unordered_map<ArAnchor *, SkMatrix44> anchor_skmat4_camera_aligned_map_;
+        std::unordered_map<ArAnchor *, SkMatrix44> anchor_skmat4_snap_aligned_map_;
+
+        std::unordered_map<ArPlane *, std::vector<ArAnchor*>> plane_anchors_map_;
+        std::unordered_map<ArAnchor *, ArPlane*> anchor_plane_map_;
+
+        // The first plane is always rendered in white, if this is true then a plane
+        // at some point has been found.
+        bool first_plane_has_been_found_ = false;
+
+        PointCloudRenderer point_cloud_renderer_;
+        BackgroundRenderer background_renderer_;
+        PlaneRenderer plane_renderer_;
+
+        int32_t plane_count_ = 0;
+    };
+}  // namespace hello_ar
+
+#endif  // C_ARCORE_HELLOE_AR_HELLO_AR_APPLICATION_H_
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/jni_interface.cc b/platform_tools/android/apps/arcore/src/main/cpp/jni_interface.cc
new file mode 100644
index 0000000000..01cbff2236
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/jni_interface.cc
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include <android/asset_manager.h>
+#include <android/asset_manager_jni.h>
+#include <jni.h>
+
+#include "hello_ar_application.h"
+
+#define JNI_METHOD(return_type, method_name) \
+  JNIEXPORT return_type JNICALL              \
+      Java_org_skia_arcore_JniInterface_##method_name
+
+extern "C" {
+
+namespace {
+// maintain a reference to the JVM so we can use it later.
+    static JavaVM *g_vm = nullptr;
+
+    inline jlong jptr(hello_ar::HelloArApplication *native_hello_ar_application) {
+        return reinterpret_cast<intptr_t>(native_hello_ar_application);
+    }
+
+    inline hello_ar::HelloArApplication *native(jlong ptr) {
+        return reinterpret_cast<hello_ar::HelloArApplication *>(ptr);
+    }
+
+}  // namespace
+
+jint JNI_OnLoad(JavaVM *vm, void *) {
+    g_vm = vm;
+    return JNI_VERSION_1_6;
+}
+
+JNI_METHOD(jlong, createNativeApplication)
+(JNIEnv *env, jclass, jobject j_asset_manager) {
+    AAssetManager *asset_manager = AAssetManager_fromJava(env, j_asset_manager);
+    return jptr(new hello_ar::HelloArApplication(asset_manager));
+}
+
+JNI_METHOD(void, destroyNativeApplication)
+(JNIEnv *, jclass, jlong native_application) {
+    delete native(native_application);
+}
+
+JNI_METHOD(void, onPause)
+(JNIEnv *, jclass, jlong native_application) {
+    native(native_application)->OnPause();
+}
+
+JNI_METHOD(void, onResume)
+(JNIEnv *env, jclass, jlong native_application, jobject context,
+ jobject activity) {
+    native(native_application)->OnResume(env, context, activity);
+}
+
+JNI_METHOD(void, onGlSurfaceCreated)
+(JNIEnv *, jclass, jlong native_application) {
+    native(native_application)->OnSurfaceCreated();
+}
+
+JNI_METHOD(void, onDisplayGeometryChanged)
+(JNIEnv *, jobject, jlong native_application, int display_rotation, int width,
+ int height) {
+    native(native_application)
+            ->OnDisplayGeometryChanged(display_rotation, width, height);
+}
+
+JNI_METHOD(void, onObjectRotationChanged)
+(JNIEnv *, jobject, jlong native_application, int rotation) {
+    native(native_application)
+            ->OnObjectRotationChanged(rotation);
+}
+
+JNI_METHOD(void, onAction)
+(JNIEnv *, jobject, jlong native_application, jfloat value) {
+    native(native_application)->OnAction(value);
+}
+
+JNI_METHOD(void, onGlSurfaceDrawFrame)
+(JNIEnv *, jclass, jlong native_application) {
+    native(native_application)->OnDrawFrame();
+}
+
+JNI_METHOD(void, onTouchTranslate)
+(JNIEnv *, jclass, jlong native_application, jfloat x, jfloat y) {
+    return native(native_application)->OnTouchTranslate(x, y);
+}
+
+JNI_METHOD(bool, onTouchedFirst)
+(JNIEnv *, jclass, jlong native_application, jfloat x, jfloat y, int drawMode) {
+    return native(native_application)->OnTouchedFirst(x, y, drawMode);
+}
+
+JNI_METHOD(void, onTouchedFinal)
+(JNIEnv *, jclass, jlong native_application, int type) {
+    native(native_application)->OnTouchedFinal(type);
+}
+
+JNI_METHOD(jboolean, hasDetectedPlanes)
+(JNIEnv *, jclass, jlong native_application) {
+    return static_cast<jboolean>(
+            native(native_application)->HasDetectedPlanes() ? JNI_TRUE : JNI_FALSE);
+}
+
+JNIEnv *GetJniEnv() {
+    JNIEnv *env;
+    jint result = g_vm->AttachCurrentThread(&env, nullptr);
+    return result == JNI_OK ? env : nullptr;
+}
+
+jclass FindClass(const char *classname) {
+    JNIEnv *env = GetJniEnv();
+    return env->FindClass(classname);
+}
+
+}  // extern "C"
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/jni_interface.h b/platform_tools/android/apps/arcore/src/main/cpp/jni_interface.h
new file mode 100644
index 0000000000..fe19cfcb85
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/jni_interface.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLOE_AR_JNI_INTERFACE_H_
+#define C_ARCORE_HELLOE_AR_JNI_INTERFACE_H_
+
+#include <jni.h>
+/**
+ * Helper functions to provide access to Java from C via JNI.
+ */
+extern "C" {
+
+// Helper function used to access the jni environment on the current thread.
+// In this sample, no consideration is made for detaching the thread when the
+// thread exits. This can cause memory leaks, so production applications should
+// detach when the thread no longer needs access to the JVM.
+JNIEnv *GetJniEnv();
+
+jclass FindClass(const char *classname);
+}  // extern "C"
+#endif
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/pending_anchor.cc b/platform_tools/android/apps/arcore/src/main/cpp/pending_anchor.cc
new file mode 100644
index 0000000000..f6a9c67b9e
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/pending_anchor.cc
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include "hello_ar_application.h"
+#include "plane_renderer.h"
+#include "util.h"
+#include "SkCanvas.h"
+
+namespace hello_ar {
+    PendingAnchor::PendingAnchor(SkPoint touchLocation) : touchLocation(touchLocation) {}
+
+    PendingAnchor::~PendingAnchor() {}
+
+    SkPoint PendingAnchor::GetTouchLocation() {
+        return touchLocation;
+    }
+
+    bool PendingAnchor::GetEditMode() {
+        return editMode;
+    }
+
+    ArPlane* PendingAnchor::GetContainingPlane() {
+        return containingPlane;
+    }
+
+    glm::vec4 PendingAnchor::GetAnchorPos(ArSession* arSession) {
+        float poseRaw[] = {0, 0, 0, 0, 0, 0, 0};
+        ArPose* anchorPose = nullptr;
+        ArPose_create(arSession, poseRaw, &anchorPose);
+        ArAnchor_getPose(arSession, this->anchor, anchorPose);
+        ArPose_getPoseRaw(arSession, anchorPose, poseRaw);
+        ArPose_destroy(anchorPose);
+        glm::vec4 anchorPos = glm::vec4(poseRaw[4], poseRaw[5], poseRaw[6], 1);
+        return anchorPos;
+    }
+
+    ArAnchor* PendingAnchor::GetArAnchor() {
+        return anchor;
+    }
+
+    void PendingAnchor::SetArAnchor(ArAnchor* anchor) {
+        this->anchor = anchor;
+    }
+
+    void PendingAnchor::SetEditMode(bool editMode) {
+        this->editMode = editMode;
+    }
+
+    void PendingAnchor::SetContainingPlane(ArPlane* plane) {
+        this->containingPlane = plane;
+    }
+
+
+
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/pending_anchor.h b/platform_tools/android/apps/arcore/src/main/cpp/pending_anchor.h
new file mode 100644
index 0000000000..2694b678d0
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/pending_anchor.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLO_AR_PENDING_ANCHOR_H_
+#define C_ARCORE_HELLO_AR_PENDING_ANCHOR_H_
+
+#include <gl/GrGLTypes.h>
+#include <GrBackendSurface.h>
+
+#include "arcore_c_api.h"
+#include "glm.h"
+
+namespace hello_ar {
+    class PendingAnchor {
+    public:
+        PendingAnchor(SkPoint touchLocation);
+        ~PendingAnchor();
+
+        SkPoint GetTouchLocation();
+        bool GetEditMode();
+        ArPlane* GetContainingPlane();
+        glm::vec4 GetAnchorPos(ArSession* arSession);
+        ArAnchor* GetArAnchor();
+
+        void SetArAnchor(ArAnchor* anchor);
+        void SetEditMode(bool editMode);
+        void SetContainingPlane(ArPlane* plane);
+
+    private:
+        SkPoint touchLocation;
+        bool editMode = false;
+        ArAnchor* anchor;
+        ArPlane* containingPlane;
+    };
+}  // namespace hello_ar
+
+#endif
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/plane_renderer.cc b/platform_tools/android/apps/arcore/src/main/cpp/plane_renderer.cc
new file mode 100644
index 0000000000..50d8f8be59
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/plane_renderer.cc
@@ -0,0 +1,220 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include "plane_renderer.h"
+#include "util.h"
+
+namespace hello_ar {
+    namespace {
+        constexpr char kVertexShader[] = R"(
+    precision highp float;
+    precision highp int;
+    attribute vec3 vertex;
+    varying vec2 v_textureCoords;
+    varying float v_alpha;
+
+    uniform mat4 mvp;
+    uniform mat4 model_mat;
+    uniform vec3 normal;
+
+    void main() {
+      // Vertex Z value is used as the alpha in this shader.
+      v_alpha = vertex.z;
+
+      vec4 local_pos = vec4(vertex.x, 0.0, vertex.y, 1.0);
+      gl_Position = mvp * local_pos;
+      vec4 world_pos = model_mat * local_pos;
+
+      // Construct two vectors that are orthogonal to the normal.
+      // This arbitrary choice is not co-linear with either horizontal
+      // or vertical plane normals.
+      const vec3 arbitrary = vec3(1.0, 1.0, 0.0);
+      vec3 vec_u = normalize(cross(normal, arbitrary));
+      vec3 vec_v = normalize(cross(normal, vec_u));
+
+      // Project vertices in world frame onto vec_u and vec_v.
+      v_textureCoords = vec2(
+         dot(world_pos.xyz, vec_u), dot(world_pos.xyz, vec_v));
+    })";
+
+        constexpr char kFragmentShader[] = R"(
+    precision highp float;
+    precision highp int;
+    uniform sampler2D texture;
+    uniform vec3 color;
+    varying vec2 v_textureCoords;
+    varying float v_alpha;
+    void main() {
+      float r = texture2D(texture, v_textureCoords).r;
+      gl_FragColor = vec4(color.xyz, r * v_alpha);
+    })";
+    }  // namespace
+
+    void PlaneRenderer::InitializeGlContent(AAssetManager *asset_manager) {
+        shader_program_ = util::CreateProgram(kVertexShader, kFragmentShader);
+
+        if (!shader_program_) {
+            LOGE("Could not create program.");
+        }
+
+        uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+        uniform_texture_ = glGetUniformLocation(shader_program_, "texture");
+        uniform_model_mat_ = glGetUniformLocation(shader_program_, "model_mat");
+        uniform_normal_vec_ = glGetUniformLocation(shader_program_, "normal");
+        uniform_color_ = glGetUniformLocation(shader_program_, "color");
+        attri_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+
+        glGenTextures(1, &texture_id_);
+        glBindTexture(GL_TEXTURE_2D, texture_id_);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                        GL_LINEAR_MIPMAP_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        if (!util::LoadPngFromAssetManager(GL_TEXTURE_2D, "models/trigrid.png")) {
+            LOGE("Could not load png texture for planes.");
+        }
+
+        glGenerateMipmap(GL_TEXTURE_2D);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+        util::CheckGlError("plane_renderer::InitializeGlContent()");
+    }
+
+    void PlaneRenderer::Draw(const glm::mat4 &projection_mat,
+                             const glm::mat4 &view_mat, const ArSession *ar_session,
+                             const ArPlane *ar_plane, const glm::vec3 &color) {
+        if (!shader_program_) {
+            LOGE("shader_program is null.");
+            return;
+        }
+
+        UpdateForPlane(ar_session, ar_plane);
+
+        glUseProgram(shader_program_);
+        glDepthMask(GL_FALSE);
+
+        glActiveTexture(GL_TEXTURE0);
+        glUniform1i(uniform_texture_, 0);
+        glBindTexture(GL_TEXTURE_2D, texture_id_);
+
+        // Compose final mvp matrix for this plane renderer.
+        glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE,
+                           glm::value_ptr(projection_mat * view_mat * model_mat_));
+
+        glUniformMatrix4fv(uniform_model_mat_, 1, GL_FALSE,
+                           glm::value_ptr(model_mat_));
+        glUniform3f(uniform_normal_vec_, normal_vec_.x, normal_vec_.y, normal_vec_.z);
+        glUniform3f(uniform_color_, color.x, color.y, color.z);
+
+        glEnableVertexAttribArray(attri_vertices_);
+        glVertexAttribPointer(attri_vertices_, 3, GL_FLOAT, GL_FALSE, 0,
+                              vertices_.data());
+
+        glDrawElements(GL_TRIANGLES, triangles_.size(), GL_UNSIGNED_SHORT,
+                       triangles_.data());
+
+        glUseProgram(0);
+        glDepthMask(GL_TRUE);
+        util::CheckGlError("plane_renderer::Draw()");
+    }
+
+    void PlaneRenderer::UpdateForPlane(const ArSession *ar_session,
+                                       const ArPlane *ar_plane) {
+        // The following code generates a triangle mesh filling a convex polygon,
+        // including a feathered edge for blending.
+        //
+        // The indices shown in the diagram are used in comments below.
+        // _______________     0_______________1
+        // |             |      |4___________5|
+        // |             |      | |         | |
+        // |             | =>   | |         | |
+        // |             |      | |         | |
+        // |             |      |7-----------6|
+        // ---------------     3---------------2
+
+        vertices_.clear();
+        triangles_.clear();
+
+        int32_t polygon_length;
+        ArPlane_getPolygonSize(ar_session, ar_plane, &polygon_length);
+
+        if (polygon_length == 0) {
+            LOGE("PlaneRenderer::UpdatePlane, no valid plane polygon is found");
+            return;
+        }
+
+        const int32_t vertices_size = polygon_length / 2;
+        std::vector<glm::vec2> raw_vertices(vertices_size);
+        ArPlane_getPolygon(ar_session, ar_plane,
+                           glm::value_ptr(raw_vertices.front()));
+
+        // Fill vertex 0 to 3. Note that the vertex.xy are used for x and z
+        // position. vertex.z is used for alpha. The outter polygon's alpha
+        // is 0.
+        for (int32_t i = 0; i < vertices_size; ++i) {
+            vertices_.push_back(glm::vec3(raw_vertices[i].x, raw_vertices[i].y, 0.0f));
+        }
+
+        util::ScopedArPose scopedArPose(ar_session);
+        ArPlane_getCenterPose(ar_session, ar_plane, scopedArPose.GetArPose());
+        ArPose_getMatrix(ar_session, scopedArPose.GetArPose(),
+                         glm::value_ptr(model_mat_));
+        normal_vec_ = util::GetPlaneNormal(ar_session, *scopedArPose.GetArPose());
+
+        // Feather distance 0.2 meters.
+        const float kFeatherLength = 0.2f;
+        // Feather scale over the distance between plane center and vertices.
+        const float kFeatherScale = 0.2f;
+
+        // Fill vertex 4 to 7, with alpha set to 1.
+        for (int32_t i = 0; i < vertices_size; ++i) {
+            // Vector from plane center to current point.
+            glm::vec2 v = raw_vertices[i];
+            const float scale =
+                    1.0f - std::min((kFeatherLength / glm::length(v)), kFeatherScale);
+            const glm::vec2 result_v = scale * v;
+
+            vertices_.push_back(glm::vec3(result_v.x, result_v.y, 1.0f));
+        }
+
+        const int32_t vertices_length = vertices_.size();
+        const int32_t half_vertices_length = vertices_length / 2;
+
+        // Generate triangle (4, 5, 6) and (4, 6, 7).
+        for (int i = half_vertices_length + 1; i < vertices_length - 1; ++i) {
+            triangles_.push_back(half_vertices_length);
+            triangles_.push_back(i);
+            triangles_.push_back(i + 1);
+        }
+
+        // Generate triangle (0, 1, 4), (4, 1, 5), (5, 1, 2), (5, 2, 6),
+        // (6, 2, 3), (6, 3, 7), (7, 3, 0), (7, 0, 4)
+        for (int i = 0; i < half_vertices_length; ++i) {
+            triangles_.push_back(i);
+            triangles_.push_back((i + 1) % half_vertices_length);
+            triangles_.push_back(i + half_vertices_length);
+
+            triangles_.push_back(i + half_vertices_length);
+            triangles_.push_back((i + 1) % half_vertices_length);
+            triangles_.push_back((i + half_vertices_length + 1) % half_vertices_length +
+                                 half_vertices_length);
+        }
+    }
+
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/plane_renderer.h b/platform_tools/android/apps/arcore/src/main/cpp/plane_renderer.h
new file mode 100644
index 0000000000..c1f75f2a70
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/plane_renderer.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLOE_AR_PLANE_RENDERER_H_
+#define C_ARCORE_HELLOE_AR_PLANE_RENDERER_H_
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <android/asset_manager.h>
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+#include "arcore_c_api.h"
+#include "glm.h"
+
+namespace hello_ar {
+
+// PlaneRenderer renders ARCore plane type.
+    class PlaneRenderer {
+    public:
+        PlaneRenderer() = default;
+
+        ~PlaneRenderer() = default;
+
+        // Sets up OpenGL state used by the plane renderer.  Must be called on the
+        // OpenGL thread.
+        void InitializeGlContent(AAssetManager *asset_manager);
+
+        // Draws the provided plane.
+        void Draw(const glm::mat4 &projection_mat, const glm::mat4 &view_mat,
+                  const ArSession *ar_session, const ArPlane *ar_plane,
+                  const glm::vec3 &color);
+
+    private:
+        void UpdateForPlane(const ArSession *ar_session, const ArPlane *ar_plane);
+
+        std::vector<glm::vec3> vertices_;
+        std::vector<GLushort> triangles_;
+        glm::mat4 model_mat_ = glm::mat4(1.0f);
+        glm::vec3 normal_vec_ = glm::vec3(0.0f);
+
+        GLuint texture_id_;
+
+        GLuint shader_program_;
+        GLint attri_vertices_;
+        GLint uniform_mvp_mat_;
+        GLint uniform_texture_;
+        GLint uniform_model_mat_;
+        GLint uniform_normal_vec_;
+        GLint uniform_color_;
+    };
+}  // namespace hello_ar
+
+#endif  // C_ARCORE_HELLOE_AR_PLANE_RENDERER_H_
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/point_cloud_renderer.cc b/platform_tools/android/apps/arcore/src/main/cpp/point_cloud_renderer.cc
new file mode 100644
index 0000000000..c9ab6930d7
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/point_cloud_renderer.cc
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include "point_cloud_renderer.h"
+#include "util.h"
+
+namespace hello_ar {
+    namespace {
+        constexpr char kVertexShader[] = R"(
+    attribute vec4 vertex;
+    uniform mat4 mvp;
+    void main() {
+      gl_PointSize = 5.0;
+      // Pointcloud vertex's w component is confidence value.
+      // Not used in renderer.
+      gl_Position = mvp * vec4(vertex.xyz, 1.0);
+    })";
+
+        constexpr char kFragmentShader[] = R"(
+    precision lowp float;
+    void main() {
+      gl_FragColor = vec4(0.1215, 0.7372, 0.8235, 1.0);
+    })";
+    }  // namespace
+
+    void PointCloudRenderer::InitializeGlContent() {
+        shader_program_ = util::CreateProgram(kVertexShader, kFragmentShader);
+
+        CHECK(shader_program_);
+
+        attribute_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+        uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+
+        util::CheckGlError("point_cloud_renderer::InitializeGlContent()");
+    }
+
+    void PointCloudRenderer::Draw(glm::mat4 mvp_matrix, ArSession *ar_session,
+                                  ArPointCloud *ar_point_cloud) const {
+        CHECK(shader_program_);
+
+        glUseProgram(shader_program_);
+
+        int32_t number_of_points = 0;
+        ArPointCloud_getNumberOfPoints(ar_session, ar_point_cloud, &number_of_points);
+        if (number_of_points <= 0) {
+            return;
+        }
+
+        const float *point_cloud_data;
+        ArPointCloud_getData(ar_session, ar_point_cloud, &point_cloud_data);
+
+        glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_matrix));
+
+        glEnableVertexAttribArray(attribute_vertices_);
+        glVertexAttribPointer(attribute_vertices_, 4, GL_FLOAT, GL_FALSE, 0,
+                              point_cloud_data);
+
+        glDrawArrays(GL_POINTS, 0, number_of_points);
+
+        glUseProgram(0);
+        util::CheckGlError("PointCloudRenderer::Draw");
+    }
+
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/point_cloud_renderer.h b/platform_tools/android/apps/arcore/src/main/cpp/point_cloud_renderer.h
new file mode 100644
index 0000000000..95f70e5eb7
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/point_cloud_renderer.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLOE_AR_POINT_CLOUD_RENDERER_H_
+#define C_ARCORE_HELLOE_AR_POINT_CLOUD_RENDERER_H_
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <cstdlib>
+#include <vector>
+
+#include "arcore_c_api.h"
+#include "glm.h"
+
+namespace hello_ar {
+
+    class PointCloudRenderer {
+    public:
+        // Default constructor of PointCloudRenderer.
+        PointCloudRenderer() = default;
+
+        // Default deconstructor of PointCloudRenderer.
+        ~PointCloudRenderer() = default;
+
+        // Initialize the GL content, needs to be called on GL thread.
+        void InitializeGlContent();
+
+        // Render the AR point cloud.
+        //
+        // @param mvp_matrix, the model view projection matrix of point cloud.
+        // @param ar_session, the session that is used to query point cloud points
+        //     from ar_point_cloud.
+        // @param ar_point_cloud, point cloud data to for rendering.
+        void Draw(glm::mat4 mvp_matrix, ArSession *ar_session,
+                  ArPointCloud *ar_point_cloud) const;
+
+    private:
+        GLuint shader_program_;
+        GLint attribute_vertices_;
+        GLint uniform_mvp_mat_;
+    };
+}  // namespace hello_ar
+
+#endif  // C_ARCORE_HELLOE_AR_POINT_CLOUD_RENDERER_H_
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/util.cc b/platform_tools/android/apps/arcore/src/main/cpp/util.cc
new file mode 100644
index 0000000000..d18719fbb4
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/util.cc
@@ -0,0 +1,329 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+#include "util.h"
+
+#include <unistd.h>
+#include <sstream>
+#include <string>
+#include <SkMatrix44.h>
+#include <gtx/string_cast.inl>
+
+#include "jni_interface.h"
+
+namespace hello_ar {
+    namespace util {
+
+        void CheckGlError(const char *operation) {
+            bool anyError = false;
+            for (GLint error = glGetError(); error; error = glGetError()) {
+                LOGE("after %s() glError (0x%x)\n", operation, error);
+                anyError = true;
+            }
+            if (anyError) {
+                abort();
+            }
+        }
+
+        // Convenience function used in CreateProgram below.
+        static GLuint LoadShader(GLenum shader_type, const char *shader_source) {
+            GLuint shader = glCreateShader(shader_type);
+            if (!shader) {
+                return shader;
+            }
+
+            glShaderSource(shader, 1, &shader_source, nullptr);
+            glCompileShader(shader);
+            GLint compiled = 0;
+            glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+
+            if (!compiled) {
+                GLint info_len = 0;
+
+                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
+                if (!info_len) {
+                    return shader;
+                }
+
+                char *buf = reinterpret_cast<char *>(malloc(info_len));
+                if (!buf) {
+                    return shader;
+                }
+
+                glGetShaderInfoLog(shader, info_len, nullptr, buf);
+                LOGE("hello_ar::util::Could not compile shader %d:\n%s\n", shader_type,
+                     buf);
+                free(buf);
+                glDeleteShader(shader);
+                shader = 0;
+            }
+
+            return shader;
+        }
+
+        GLuint CreateProgram(const char *vertex_source, const char *fragment_source) {
+            GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vertex_source);
+            if (!vertexShader) {
+                return 0;
+            }
+
+            GLuint fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
+            if (!fragment_shader) {
+                return 0;
+            }
+
+            GLuint program = glCreateProgram();
+            if (program) {
+                glAttachShader(program, vertexShader);
+                CheckGlError("hello_ar::util::glAttachShader");
+                glAttachShader(program, fragment_shader);
+                CheckGlError("hello_ar::util::glAttachShader");
+                glLinkProgram(program);
+                GLint link_status = GL_FALSE;
+                glGetProgramiv(program, GL_LINK_STATUS, &link_status);
+                if (link_status != GL_TRUE) {
+                    GLint buf_length = 0;
+                    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &buf_length);
+                    if (buf_length) {
+                        char *buf = reinterpret_cast<char *>(malloc(buf_length));
+                        if (buf) {
+                            glGetProgramInfoLog(program, buf_length, nullptr, buf);
+                            LOGE("hello_ar::util::Could not link program:\n%s\n", buf);
+                            free(buf);
+                        }
+                    }
+                    glDeleteProgram(program);
+                    program = 0;
+                }
+            }
+            return program;
+        }
+
+        bool LoadPngFromAssetManager(int target, const std::string &path) {
+            JNIEnv *env = GetJniEnv();
+
+            // Put all the JNI values in a structure that is statically initalized on the
+            // first call to this method.  This makes it thread safe in the unlikely case
+            // of multiple threads calling this method.
+            static struct JNIData {
+                jclass helper_class;
+                jmethodID load_image_method;
+                jmethodID load_texture_method;
+            } jniIds = [env]() -> JNIData {
+                constexpr char kHelperClassName[] =
+                        "org/skia/arcore/JniInterface";
+                constexpr char kLoadImageMethodName[] = "loadImage";
+                constexpr char kLoadImageMethodSignature[] =
+                        "(Ljava/lang/String;)Landroid/graphics/Bitmap;";
+                constexpr char kLoadTextureMethodName[] = "loadTexture";
+                constexpr char kLoadTextureMethodSignature[] =
+                        "(ILandroid/graphics/Bitmap;)V";
+                jclass helper_class = FindClass(kHelperClassName);
+                if (helper_class) {
+                    helper_class = static_cast<jclass>(env->NewGlobalRef(helper_class));
+                    jmethodID load_image_method = env->GetStaticMethodID(
+                            helper_class, kLoadImageMethodName, kLoadImageMethodSignature);
+                    jmethodID load_texture_method = env->GetStaticMethodID(
+                            helper_class, kLoadTextureMethodName, kLoadTextureMethodSignature);
+                    return {helper_class, load_image_method, load_texture_method};
+                }
+                LOGE("hello_ar::util::Could not find Java helper class %s",
+                     kHelperClassName);
+                return {};
+            }();
+
+            if (!jniIds.helper_class) {
+                return false;
+            }
+
+            jstring j_path = env->NewStringUTF(path.c_str());
+
+            jobject image_obj = env->CallStaticObjectMethod(
+                    jniIds.helper_class, jniIds.load_image_method, j_path);
+
+            if (j_path) {
+                env->DeleteLocalRef(j_path);
+            }
+
+            env->CallStaticVoidMethod(jniIds.helper_class, jniIds.load_texture_method,
+                                      target, image_obj);
+            return true;
+        }
+
+        void GetTransformMatrixFromPose(ArSession *ar_session,
+                                        const ArPose *ar_pose,
+                                        glm::mat4 *out_model_mat) {
+            if (out_model_mat == nullptr) {
+                LOGE("util::GetTransformMatrixFromPose model_mat is null.");
+                return;
+            }
+            ArPose_getMatrix(ar_session, ar_pose,
+                             glm::value_ptr(*out_model_mat));
+        }
+
+        glm::vec3 GetPlaneNormal(const ArSession *ar_session,
+                                 const ArPose &plane_pose) {
+            float plane_pose_raw[7] = {0.f};
+            ArPose_getPoseRaw(ar_session, &plane_pose, plane_pose_raw);
+            glm::quat plane_quaternion(plane_pose_raw[3], plane_pose_raw[0],
+                                       plane_pose_raw[1], plane_pose_raw[2]);
+            // Get normal vector, normal is defined to be positive Y-position in local
+            // frame.
+            return glm::rotate(plane_quaternion, glm::vec3(0., 1.f, 0.));
+        }
+
+        float CalculateDistanceToPlane(const ArSession *ar_session,
+                                       const ArPose &plane_pose,
+                                       const ArPose &camera_pose) {
+            float plane_pose_raw[7] = {0.f};
+            ArPose_getPoseRaw(ar_session, &plane_pose, plane_pose_raw);
+            glm::vec3 plane_position(plane_pose_raw[4], plane_pose_raw[5],
+                                     plane_pose_raw[6]);
+            glm::vec3 normal = GetPlaneNormal(ar_session, plane_pose);
+
+            float camera_pose_raw[7] = {0.f};
+            ArPose_getPoseRaw(ar_session, &camera_pose, camera_pose_raw);
+            glm::vec3 camera_P_plane(camera_pose_raw[4] - plane_position.x,
+                                     camera_pose_raw[5] - plane_position.y,
+                                     camera_pose_raw[6] - plane_position.z);
+            return glm::dot(normal, camera_P_plane);
+        }
+
+        glm::mat4 GetCameraRotationMatrix(float cameraOutRaw[]) {
+            glm::mat4 cameraRotation(1);
+            glm::quat cameraQuat = glm::quat(cameraOutRaw[0], cameraOutRaw[1], cameraOutRaw[2],
+                                             cameraOutRaw[3]);
+            cameraRotation = glm::toMat4(cameraQuat);
+            glm::vec4 temp = cameraRotation[0];
+            cameraRotation[0] = cameraRotation[2];
+            cameraRotation[2] = temp;
+            return cameraRotation;
+        }
+
+        void GetCameraInfo(ArSession* arSession, ArFrame* arFrame, glm::vec3& cameraPos, glm::mat4& cameraRotation) {
+            //Acquire camera
+            ArCamera *ar_camera;
+            ArFrame_acquireCamera(arSession, arFrame, &ar_camera);
+
+            //Get camera pose
+            ArPose *camera_pose = nullptr;
+            ArPose_create(arSession, nullptr, &camera_pose);
+            ArCamera_getDisplayOrientedPose(arSession, ar_camera, camera_pose);
+
+            //Get camera raw info
+            float outCameraRaw[] = {0, 0, 0, 0, 0, 0, 0};
+            ArPose_getPoseRaw(arSession, camera_pose, outCameraRaw);
+            ArPose_destroy(camera_pose);
+
+            //Write to out variables
+            cameraPos = glm::vec3(outCameraRaw[4], outCameraRaw[5], outCameraRaw[6]);
+            cameraRotation = util::GetCameraRotationMatrix(outCameraRaw);
+
+            //Release camera
+            ArCamera_release(ar_camera);
+        }
+
+        SkMatrix44 GlmMatToSkMat(const glm::mat4 m) {
+            SkMatrix44 skMat = SkMatrix44::kIdentity_Constructor;
+            for (int i = 0; i < 4; i++) {
+                for (int j = 0; j < 4; j++) {
+                    skMat.set(j, i, m[i][j]);
+                }
+            }
+            return skMat;
+        }
+
+        glm::mat4 SkMatToGlmMat(const SkMatrix44 m) {
+            glm::mat4 glmMat(1);
+            for (int i = 0; i < 4; i++) {
+                for (int j = 0; j < 4; j++) {
+                    glmMat[i][j] = m.get(j, i);
+                }
+            }
+            return glmMat;
+        }
+
+        void Log4x4Matrix(float raw_matrix[16]) {
+            LOGI(
+                    "%f, %f, %f, %f\n"
+                            "%f, %f, %f, %f\n"
+                            "%f, %f, %f, %f\n"
+                            "%f, %f, %f, %f\n",
+                    raw_matrix[0], raw_matrix[1], raw_matrix[2], raw_matrix[3], raw_matrix[4],
+                    raw_matrix[5], raw_matrix[6], raw_matrix[7], raw_matrix[8], raw_matrix[9],
+                    raw_matrix[10], raw_matrix[11], raw_matrix[12], raw_matrix[13],
+                    raw_matrix[14], raw_matrix[15]);
+        }
+
+        void LogGlmMat(glm::mat4 m, char *type) {
+            std::string str = glm::to_string(m);
+            LOGE("glm Matrix - %s: %s\n", type, str.c_str());
+        }
+
+        void LogSkMat44(SkMatrix44 m, char *type) {
+            LOGE("SkMatrix - %s: [%g, %g, %g, %g] || [%g, %g, %g, %g] || [%g, %g, %g, %g] || [%g, %g, %g, %g] \n",
+                 type,
+                 m.get(0, 0), m.get(1, 0), m.get(2, 0), m.get(3, 0),
+                 m.get(0, 1), m.get(1, 1), m.get(2, 1), m.get(3, 1),
+                 m.get(0, 2), m.get(1, 2), m.get(2, 2), m.get(3, 2),
+                 m.get(0, 3), m.get(1, 3), m.get(2, 3), m.get(3, 3)
+            );
+        }
+
+        void LogSkMat(SkMatrix m, char *type) {
+            LOGE("SkMatrix - %s: [%g, %g, %g] || [%g, %g, %g] || [%g, %g, %g] \n", type,
+                 m.get(0), m.get(3), m.get(6),
+                 m.get(1), m.get(4), m.get(7),
+                 m.get(2), m.get(5), m.get(8)
+            );
+        }
+
+        void LogOrientation(float rotationDirection, float angleRad, char *type) {
+            LOGI("Plane orientation: %s", type);
+            LOGI("Cross dotted with zDir:", rotationDirection);
+            if (rotationDirection == -1) {
+                LOGI("Counter Clockwise %.6f degrees rotation: ", glm::degrees(angleRad));
+            } else {
+                LOGI("Clockwise %.6f degrees rotation: ", glm::degrees(angleRad));
+            }
+        }
+
+        float Dot(glm::vec3 u, glm::vec3 v) {
+            float result = u.x * v.x + u.y * v.y + u.z * v.z;
+            return result;
+        }
+
+        float Magnitude(glm::vec3 u) {
+            float result = u.x * u.x + u.y * u.y + u.z * u.z;
+            return sqrt(result);
+        }
+
+        float AngleRad(glm::vec3 u, glm::vec3 v) {
+            float dot = util::Dot(u, v);
+            float scale = (util::Magnitude(u) * util::Magnitude(v));
+            float cosine = dot / scale;
+            float acosine = acos(cosine);
+            return acosine;
+        }
+
+        glm::vec3 ProjectOntoPlane(glm::vec3 in, glm::vec3 normal) {
+            float dot = util::Dot(in, normal);
+            float multiplier = dot / (util::Magnitude(normal) * util::Magnitude(normal));
+            glm::vec3 out = in - multiplier * normal;
+            return out;
+        }
+
+    }  // namespace util
+}  // namespace hello_ar
diff --git a/platform_tools/android/apps/arcore/src/main/cpp/util.h b/platform_tools/android/apps/arcore/src/main/cpp/util.h
new file mode 100644
index 0000000000..88bc2f91a8
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/cpp/util.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef C_ARCORE_HELLOE_AR_UTIL_H_
+#define C_ARCORE_HELLOE_AR_UTIL_H_
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <android/asset_manager.h>
+#include <android/log.h>
+#include <errno.h>
+#include <jni.h>
+#include <cstdint>
+#include <cstdlib>
+#include <vector>
+#include <SkMatrix44.h>
+
+#include "arcore_c_api.h"
+#include "glm.h"
+
+#ifndef LOGI
+#define LOGI(...) \
+  __android_log_print(ANDROID_LOG_INFO, "hello_ar_example_c", __VA_ARGS__)
+#endif  // LOGI
+
+#ifndef LOGE
+#define LOGE(...) \
+  __android_log_print(ANDROID_LOG_ERROR, "hello_ar_example_c", __VA_ARGS__)
+#endif  // LOGE
+
+#ifndef CHECK
+#define CHECK(condition)                                                   \
+  if (!(condition)) {                                                      \
+    LOGE("*** CHECK FAILED at %s:%d: %s", __FILE__, __LINE__, #condition); \
+    abort();                                                               \
+  }
+#endif  // CHECK
+
+namespace hello_ar {
+    // Utilities
+    namespace util {
+
+        // Provides a scoped allocated instance of Anchor.
+        // Can be treated as an ArAnchor*.
+        class ScopedArPose {
+        public:
+            explicit ScopedArPose(const ArSession *session) {
+                ArPose_create(session, nullptr, &pose_);
+            }
+
+            ~ScopedArPose() { ArPose_destroy(pose_); }
+
+            ArPose *GetArPose() { return pose_; }
+
+            // Delete copy constructors.
+            ScopedArPose(const ScopedArPose &) = delete;
+
+            void operator=(const ScopedArPose &) = delete;
+
+        private:
+            ArPose *pose_;
+        };
+
+        /* GL Utils */
+        // Check GL error, and abort if an error is encountered.
+        //
+        // @param operation, the name of the GL function call.
+        void CheckGlError(const char *operation);
+
+        // Create a shader program ID.
+        //
+        // @param vertex_source, the vertex shader source.
+        // @param fragment_source, the fragment shader source.
+        // @return
+        GLuint CreateProgram(const char *vertex_source, const char *fragment_source);
+
+        // Load png file from assets folder and then assign it to the OpenGL target.
+        // This method must be called from the renderer thread since it will result in
+        // OpenGL calls to assign the image to the texture target.
+        //
+        // @param target, openGL texture target to load the image into.
+        // @param path, path to the file, relative to the assets folder.
+        // @return true if png is loaded correctly, otherwise false.
+        bool LoadPngFromAssetManager(int target, const std::string &path);
+
+
+        /* ARCore utils */
+        void GetTransformMatrixFromPose(ArSession *ar_session, const ArPose *ar_pose, glm::mat4 *out_model_mat);
+
+        // Get the plane's normal from center pose.
+        glm::vec3 GetPlaneNormal(const ArSession *ar_session, const ArPose &plane_pose);
+
+        // Calculate the normal distance to plane from cameraPose, the given planePose
+        // should have y axis parallel to plane's normal, for example plane's center
+        // pose or hit test pose.
+        float CalculateDistanceToPlane(const ArSession *ar_session, const ArPose &plane_pose, const ArPose &camera_pose);
+
+        // Outputs the camera rotation using display orientation
+        glm::mat4 GetCameraRotationMatrix(float cameraOutRaw[]);
+
+        // Computes camera position and orientation (using GetCameraRotationMatrix)
+        void GetCameraInfo(ArSession* arSession, ArFrame* arFrame, glm::vec3& cameraPos, glm::mat4& cameraRotation);
+
+        /* Matrix conversion */
+        SkMatrix44 GlmMatToSkMat(const glm::mat4 m);
+        glm::mat4 SkMatToGlmMat(const SkMatrix44 m);
+
+        /* Logging utils */
+        //Row major output
+        void Log4x4Matrix(float raw_matrix[16]);
+
+        //Column major output
+        void LogGlmMat(glm::mat4 m, char *type);
+        void LogSkMat44(SkMatrix44 m, char *type);
+        void LogSkMat(SkMatrix m, char *type);
+        void LogOrientation(float rotationDirection, float angleRad, char *type);
+
+        /* Vector ops */
+        float Dot(glm::vec3 u, glm::vec3 v);
+        float Magnitude(glm::vec3 u);
+        float AngleRad(glm::vec3 u, glm::vec3 v);
+        glm::vec3 ProjectOntoPlane(glm::vec3 in, glm::vec3 normal);
+    }  // namespace util
+}  // namespace hello_ar
+
+#endif  // C_ARCORE_HELLOE_AR_UTIL_H_
diff --git a/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/CameraPermissionHelper.java b/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/CameraPermissionHelper.java
new file mode 100644
index 0000000000..3499ec00f3
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/CameraPermissionHelper.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * 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.
+ */
+package org.skia.arcore;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.provider.Settings;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.content.ContextCompat;
+
+/**
+ * Helper to ask camera permission.
+ */
+public class CameraPermissionHelper {
+    private static final String CAMERA_PERMISSION = Manifest.permission.CAMERA;
+    private static final int CAMERA_PERMISSION_CODE = 0;
+
+    /**
+     * Check to see we have the necessary permissions for this app.
+     */
+    public static boolean hasCameraPermission(Activity activity) {
+        return ContextCompat.checkSelfPermission(activity, CAMERA_PERMISSION)
+                == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /**
+     * Check to see we have the necessary permissions for this app, and ask for them if we don't.
+     */
+    public static void requestCameraPermission(Activity activity) {
+        ActivityCompat.requestPermissions(
+                activity, new String[]{CAMERA_PERMISSION}, CAMERA_PERMISSION_CODE);
+    }
+
+    /**
+     * Check to see if we need to show the rationale for this permission.
+     */
+    public static boolean shouldShowRequestPermissionRationale(Activity activity) {
+        return ActivityCompat.shouldShowRequestPermissionRationale(activity, CAMERA_PERMISSION);
+    }
+
+    /**
+     * Launch Application Setting to grant permission.
+     */
+    public static void launchPermissionSettings(Activity activity) {
+        Intent intent = new Intent();
+        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        intent.setData(Uri.fromParts("package", activity.getPackageName(), null));
+        activity.startActivity(intent);
+    }
+}
diff --git a/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/HelloArActivity.java b/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/HelloArActivity.java
new file mode 100644
index 0000000000..73651f51c6
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/HelloArActivity.java
@@ -0,0 +1,364 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+
+package org.skia.arcore;
+
+import android.app.Activity;
+import android.content.Context;
+import android.hardware.display.DisplayManager;
+import android.opengl.GLES20;
+import android.opengl.GLSurfaceView;
+import android.os.Bundle;
+import android.os.Handler;
+import android.support.design.widget.Snackbar;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+import android.util.Log;
+import android.view.ActionMode;
+import android.view.ContextMenu;
+import android.view.GestureDetector;
+import android.view.Gravity;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.EditText;
+import android.widget.PopupMenu;
+import android.widget.Toast;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * This is a simple example that shows how to create an augmented reality (AR) application using the
+ * ARCore C API.
+ */
+public class HelloArActivity extends AppCompatActivity
+        implements GLSurfaceView.Renderer, DisplayManager.DisplayListener {
+    private static final String TAG = HelloArActivity.class.getSimpleName();
+    private static final int SNACKBAR_UPDATE_INTERVAL_MILLIS = 1000; // In milliseconds.
+
+    private GLSurfaceView mSurfaceView;
+    private Activity activity = null;
+    private boolean mViewportChanged = false;
+    private int mViewportWidth;
+    private int mViewportHeight;
+    private View contextView = null;
+    private int mCurrentObjectRotation = 0;
+    private float mCurrentValue = 0;
+    private float X = 0;
+    private float Y = 0;
+
+    private boolean toEdit = false;
+
+    // Opaque native pointer to the native application instance.
+    private long mNativeApplication;
+    private GestureDetector mGestureDetector;
+
+    private Snackbar mLoadingMessageSnackbar;
+    private Handler mPlaneStatusCheckingHandler;
+    private final Runnable mPlaneStatusCheckingRunnable =
+            new Runnable() {
+                @Override
+                public void run() {
+                    // The runnable is executed on main UI thread.
+                    try {
+                        if (JniInterface.hasDetectedPlanes(mNativeApplication)) {
+                            if (mLoadingMessageSnackbar != null) {
+                                mLoadingMessageSnackbar.dismiss();
+                            }
+                            mLoadingMessageSnackbar = null;
+                        } else {
+                            mPlaneStatusCheckingHandler.postDelayed(
+                                    mPlaneStatusCheckingRunnable, SNACKBAR_UPDATE_INTERVAL_MILLIS);
+                        }
+                    } catch (Exception e) {
+                        Log.e(TAG, e.getMessage());
+                    }
+                }
+            };
+    private int mDrawMode = -1;
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        Toolbar myToolbar = (Toolbar) findViewById(R.id.my_toolbar);
+        setSupportActionBar(myToolbar);
+
+        activity = this;
+
+        //hide notifications bar
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
+                WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+        mSurfaceView = (GLSurfaceView) findViewById(R.id.surfaceview);
+
+        mGestureDetector =
+                new GestureDetector(
+                        this,
+                        new GestureDetector.SimpleOnGestureListener() {
+                            @Override
+                            public boolean onSingleTapUp(final MotionEvent e) {
+                                toEdit = JniInterface.onTouchedFirst(mNativeApplication, e.getX(), e.getY(), mDrawMode);
+
+                                Log.i(TAG, "toEdit: " + toEdit);
+                                X = e.getX();
+                                Y = e.getY();
+                                contextView.showContextMenu(e.getX(), e.getY());
+                                return true;
+                            }
+
+                            @Override
+                            public boolean onScroll (MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+                                Log.i(TAG, "Scrolling!");
+                                JniInterface.onTouchTranslate(mNativeApplication, e2.getX(), e2.getY());
+                                return true;
+                            }
+
+                            @Override
+                            public boolean onDown(MotionEvent e) {
+                                return true;
+                            }
+                        });
+
+        mSurfaceView.setOnTouchListener(
+                new View.OnTouchListener() {
+                    @Override
+                    public boolean onTouch(View v, MotionEvent event) {
+                        return mGestureDetector.onTouchEvent(event);
+                    }
+                });
+
+        // Set up renderer.
+        mSurfaceView.setPreserveEGLContextOnPause(true);
+        mSurfaceView.setEGLContextClientVersion(2);
+        mSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0); // Alpha used for plane blending.
+        mSurfaceView.setRenderer(this);
+        mSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
+
+        JniInterface.assetManager = getAssets();
+        mNativeApplication = JniInterface.createNativeApplication(getAssets());
+
+        mPlaneStatusCheckingHandler = new Handler();
+
+        //Floating context menu
+        contextView = findViewById(R.id.menuView);
+        this.registerForContextMenu(contextView);
+        View.OnLongClickListener listener = new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View v) {
+                activity.closeContextMenu();
+                return false;
+            }
+        };
+        contextView.setOnLongClickListener(listener);
+    }
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo)
+    {
+        super.onCreateContextMenu(menu, v, menuInfo);
+
+        if (!toEdit) {
+            MenuInflater inflater = getMenuInflater();
+            inflater.inflate(R.menu.draw_menu, menu);
+            menu.setHeaderTitle("Draw Options");
+        }
+
+        v.setClickable(false);
+        v.setFocusable(false);
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
+        switch (item.getItemId()) {
+            case R.id.draw_text:
+                JniInterface.onTouchedFinal(mNativeApplication, 0);
+                return true;
+            case R.id.draw_circle:
+                JniInterface.onTouchedFinal(mNativeApplication, 1);
+                return true;
+            case R.id.draw_rect:
+                JniInterface.onTouchedFinal(mNativeApplication, 2);
+                return true;
+            case R.id.edit_size:
+                return true;
+            case R.id.edit_text:
+                return true;
+            default:
+                return super.onContextItemSelected(item);
+        }
+    }
+
+    public boolean onCreateOptionsMenu(Menu menu) {
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.rotation_mode, menu);
+        return true;
+    }
+
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.rotation_axis_aligned:
+                mCurrentObjectRotation = 0;
+                break;
+            case R.id.rotation_camera_aligned:
+                mCurrentObjectRotation = 1;
+                break;
+            case R.id.rotation_snap_aligned:
+                mCurrentObjectRotation = 2;
+                break;
+            case R.id.action:
+                mCurrentValue = 180;
+                JniInterface.onAction(mNativeApplication, mCurrentValue);
+                return true;
+            default:
+                return true;
+        }
+        JniInterface.onObjectRotationChanged(mNativeApplication, mCurrentObjectRotation);
+        return true;
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        // ARCore requires camera permissions to operate. If we did not yet obtain runtime
+        // permission on Android M and above, now is a good time to ask the user for it.
+        if (!CameraPermissionHelper.hasCameraPermission(this)) {
+            CameraPermissionHelper.requestCameraPermission(this);
+            return;
+        }
+
+        JniInterface.onResume(mNativeApplication, getApplicationContext(), this);
+        mSurfaceView.onResume();
+
+        mLoadingMessageSnackbar =
+                Snackbar.make(
+                        HelloArActivity.this.findViewById(android.R.id.content),
+                        "Searching for surfaces...",
+                        Snackbar.LENGTH_INDEFINITE);
+        // Set the snackbar background to light transparent black color.
+        mLoadingMessageSnackbar.getView().setBackgroundColor(0xbf323232);
+        mLoadingMessageSnackbar.show();
+        mPlaneStatusCheckingHandler.postDelayed(
+                mPlaneStatusCheckingRunnable, SNACKBAR_UPDATE_INTERVAL_MILLIS);
+
+        // Listen to display changed events to detect 180° rotation, which does not cause a config
+        // change or view resize.
+        getSystemService(DisplayManager.class).registerDisplayListener(this, null);
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        mSurfaceView.onPause();
+        JniInterface.onPause(mNativeApplication);
+
+        mPlaneStatusCheckingHandler.removeCallbacks(mPlaneStatusCheckingRunnable);
+
+        getSystemService(DisplayManager.class).unregisterDisplayListener(this);
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+
+        // Synchronized to avoid racing onDrawFrame.
+        synchronized (this) {
+            JniInterface.destroyNativeApplication(mNativeApplication);
+            mNativeApplication = 0;
+        }
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        if (hasFocus) {
+            // Standard Android full-screen functionality.
+            getWindow()
+                    .getDecorView()
+                    .setSystemUiVisibility(
+                            View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                                    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                                    | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                                    | View.SYSTEM_UI_FLAG_FULLSCREEN
+                                    | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
+            getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+        }
+    }
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        GLES20.glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+        JniInterface.onGlSurfaceCreated(mNativeApplication);
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        mViewportWidth = width;
+        mViewportHeight = height;
+        mViewportChanged = true;
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        // Synchronized to avoid racing onDestroy.
+        synchronized (this) {
+            if (mNativeApplication == 0) {
+                return;
+            }
+            if (mViewportChanged) {
+                int displayRotation = getWindowManager().getDefaultDisplay().getRotation();
+                JniInterface.onDisplayGeometryChanged(
+                        mNativeApplication, displayRotation, mViewportWidth, mViewportHeight);
+                mViewportChanged = false;
+            }
+            JniInterface.onGlSurfaceDrawFrame(mNativeApplication);
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] results) {
+        if (!CameraPermissionHelper.hasCameraPermission(this)) {
+            Toast.makeText(this, "Camera permission is needed to run this application", Toast.LENGTH_LONG)
+                    .show();
+            if (!CameraPermissionHelper.shouldShowRequestPermissionRationale(this)) {
+                // Permission denied with checking "Do not ask again".
+                CameraPermissionHelper.launchPermissionSettings(this);
+            }
+            finish();
+        }
+    }
+
+    // DisplayListener methods
+    @Override
+    public void onDisplayAdded(int displayId) {
+    }
+
+    @Override
+    public void onDisplayRemoved(int displayId) {
+    }
+
+    @Override
+    public void onDisplayChanged(int displayId) {
+        mViewportChanged = true;
+    }
+}
diff --git a/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/JniInterface.java b/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/JniInterface.java
new file mode 100644
index 0000000000..1592bb2a4e
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/java/org/skia/arcore/JniInterface.java
@@ -0,0 +1,82 @@
+package org.skia.arcore;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.opengl.GLUtils;
+import android.util.Log;
+
+import java.io.IOException;
+
+/**
+ * JNI interface to native layer.
+ */
+public class JniInterface {
+    static {
+        System.loadLibrary("hello_ar_native");
+    }
+
+    private static final String TAG = "JniInterface";
+    static AssetManager assetManager;
+
+    public static native long createNativeApplication(AssetManager assetManager);
+
+    public static native void destroyNativeApplication(long nativeApplication);
+
+    public static native void onPause(long nativeApplication);
+
+    public static native void onResume(long nativeApplication, Context context, Activity activity);
+
+    /**
+     * Allocate OpenGL resources for rendering.
+     */
+    public static native void onGlSurfaceCreated(long nativeApplication);
+
+    /**
+     * Called on the OpenGL thread before onGlSurfaceDrawFrame when the view port width, height, or
+     * display rotation may have changed.
+     */
+    public static native void onDisplayGeometryChanged(
+            long nativeApplication, int displayRotation, int width, int height);
+
+    public static native void onObjectRotationChanged(long nativeApplication, int rotation);
+
+    public static native void onAction(long nativeApplication, float value);
+
+    /**
+     * Main render loop, called on the OpenGL thread.
+     */
+    public static native void onGlSurfaceDrawFrame(long nativeApplication);
+
+    /**
+     * OnTouch event, called on the OpenGL thread.
+     */
+
+    public static native void onTouchTranslate(long nativeApplication, float x, float y);
+
+    public static native boolean onTouchedFirst(long nativeApplication, float x, float y, int drawMode);
+
+    public static native void onTouchedFinal(long nativeApplication, int type);
+
+
+    /**
+     * Get plane count in current session. Used to disable the "searching for surfaces" snackbar.
+     */
+    public static native boolean hasDetectedPlanes(long nativeApplication);
+
+    public static Bitmap loadImage(String imageName) {
+
+        try {
+            return BitmapFactory.decodeStream(assetManager.open(imageName));
+        } catch (IOException e) {
+            Log.e(TAG, "Cannot open image " + imageName);
+            return null;
+        }
+    }
+
+    public static void loadTexture(int target, Bitmap bitmap) {
+        GLUtils.texImage2D(target, 0, bitmap, 0);
+    }
+}
diff --git a/platform_tools/android/apps/arcore/src/main/res/drawable-xxhdpi/ic_launcher.png b/platform_tools/android/apps/arcore/src/main/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..3f691da039
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/drawable-xxhdpi/ic_launcher.png
diff --git a/platform_tools/android/apps/arcore/src/main/res/layout-xlarge-land/activity_main.xml b/platform_tools/android/apps/arcore/src/main/res/layout-xlarge-land/activity_main.xml
new file mode 100644
index 0000000000..49457c9802
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/layout-xlarge-land/activity_main.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="horizontal"
+    android:layout_width="match_parent"
+    android:background="@android:color/darker_gray"
+    android:layout_height="match_parent">
+
+    <!-- The navigation drawer that's always open -->
+    <ListView android:id="@+id/leftDrawer"
+        android:layout_width="240dp"
+        android:layout_height="match_parent"
+        android:layout_gravity="start"
+        android:choiceMode="singleChoice"
+        android:divider="@android:color/transparent"
+        android:dividerHeight="0dp"
+        android:layout_marginRight="5dp"
+        android:background="@android:color/background_light"/>
+
+    <!-- The main content view -->
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <!-- We use mainLayout for recreating SurfaceView -->
+        <LinearLayout
+            android:id="@+id/mainLayout"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent">
+            <SurfaceView
+                android:id="@+id/surfaceView"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:layout_centerVertical="true"
+                android:layout_centerHorizontal="true" />
+        </LinearLayout>
+    </RelativeLayout>
+
+</LinearLayout>
+
diff --git a/platform_tools/android/apps/arcore/src/main/res/layout/activity_main.xml b/platform_tools/android/apps/arcore/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000000..c3f1e2a3a2
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/layout/activity_main.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/drawerLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <!-- The main content view -->
+
+    <FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+        <View
+            android:layout_gravity="center"
+            android:id="@+id/menuView"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"/>
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:orientation="vertical">
+            <android.support.v7.widget.Toolbar
+                android:id="@+id/my_toolbar"
+                android:layout_width="match_parent"
+                android:layout_height="?attr/actionBarSize"
+                android:background="?attr/colorPrimary"
+                android:elevation="4dp"
+                android:theme="@style/ThemeOverlay.AppCompat.ActionBar"
+                app:popupTheme="@style/ThemeOverlay.AppCompat.Light"/>
+            <EditText
+                android:id="@+id/text_box"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:focusable="false"
+                android:clickable="false"
+                android:visibility="gone"/>
+            <android.opengl.GLSurfaceView
+                android:id="@+id/surfaceview"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:layout_gravity="bottom" />
+
+        </LinearLayout>
+
+
+
+    </FrameLayout>
+
+</android.support.v4.widget.DrawerLayout>
+
diff --git a/platform_tools/android/apps/arcore/src/main/res/layout/state_item.xml b/platform_tools/android/apps/arcore/src/main/res/layout/state_item.xml
new file mode 100644
index 0000000000..7a7d539d43
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/layout/state_item.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical" android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:weightSum="1">
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="10dp"
+        android:layout_marginLeft="10dp"
+        android:layout_marginBottom="0dp"
+        android:textAppearance="?android:attr/textAppearanceLarge"
+        android:text="Name:"
+        android:id="@+id/nameText" />
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="10dp"
+        android:layout_marginLeft="10dp"
+        android:layout_marginTop="0dp"
+        android:textAppearance="?android:attr/textAppearanceMedium"
+        android:text="Value"
+        android:id="@+id/valueText" />
+
+    <Spinner
+        android:id="@+id/optionSpinner"
+        android:paddingTop="0dp"
+        android:paddingBottom="0dp"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+    </Spinner>
+
+</LinearLayout>
diff --git a/platform_tools/android/apps/arcore/src/main/res/menu/draw_menu.xml b/platform_tools/android/apps/arcore/src/main/res/menu/draw_menu.xml
new file mode 100644
index 0000000000..92851804bd
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/menu/draw_menu.xml
@@ -0,0 +1,15 @@
+<menu	xmlns:android="http://schemas.android.com/apk/res/android">
+	<item
+		android:id="@+id/draw_text"
+		android:title="Draw Text" />
+	<item
+		android:id="@+id/draw_shape"
+		android:title="Draw Shape" >
+		<menu>
+			<item android:id="@+id/draw_circle"
+				android:title="Circle" />
+			<item android:id="@+id/draw_rect"
+				android:title="Rectangle" />
+		</menu>
+	</item>
+</menu>
\ No newline at end of file
diff --git a/platform_tools/android/apps/arcore/src/main/res/menu/edit_menu.xml b/platform_tools/android/apps/arcore/src/main/res/menu/edit_menu.xml
new file mode 100644
index 0000000000..25f6a1dc02
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/menu/edit_menu.xml
@@ -0,0 +1,8 @@
+<menu	xmlns:android="http://schemas.android.com/apk/res/android">
+	<item
+		android:id="@+id/edit_size"
+		android:title="Size" />
+	<item
+		android:id="@+id/edit_text"
+		android:title="Text" />
+</menu>
\ No newline at end of file
diff --git a/platform_tools/android/apps/arcore/src/main/res/menu/rotation_mode.xml b/platform_tools/android/apps/arcore/src/main/res/menu/rotation_mode.xml
new file mode 100644
index 0000000000..bcee4f0fb9
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/menu/rotation_mode.xml
@@ -0,0 +1,11 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+	<item android:id="@+id/rotation_axis_aligned"
+		android:title="Plane Axis-Aligned"/>
+	<item android:id="@+id/rotation_camera_aligned"
+		android:title="Camera-Aligned"/>
+	<item android:id="@+id/rotation_snap_aligned"
+		android:title="Snap-Aligned"/>
+
+	<item android:id="@+id/action"
+		android:title="Do Action"/>
+</menu>
\ No newline at end of file
diff --git a/platform_tools/android/apps/arcore/src/main/res/menu/title.xml b/platform_tools/android/apps/arcore/src/main/res/menu/title.xml
new file mode 100644
index 0000000000..57d04ef143
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/menu/title.xml
@@ -0,0 +1,12 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android" >
+
+    <item
+        android:id="@+id/action_left"
+        android:icon="@android:drawable/ic_media_previous"
+        android:showAsAction="always"/>
+
+    <item android:id="@+id/action_right"
+        android:icon="@android:drawable/ic_media_next"
+        android:showAsAction="always"/>
+
+</menu>
diff --git a/platform_tools/android/apps/arcore/src/main/res/values/integers.xml b/platform_tools/android/apps/arcore/src/main/res/values/integers.xml
new file mode 100644
index 0000000000..d3da8e7ca5
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/values/integers.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <integer name="value_tag_key">1</integer>
+</resources>
\ No newline at end of file
diff --git a/platform_tools/android/apps/arcore/src/main/res/values/strings.xml b/platform_tools/android/apps/arcore/src/main/res/values/strings.xml
new file mode 100644
index 0000000000..8b7a8ad740
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/values/strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright 2017 Google Inc.
+
+   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.
+-->
+<resources>
+  <string name="app_name">HelloAR C</string>
+</resources>
diff --git a/platform_tools/android/apps/arcore/src/main/res/values/styles.xml b/platform_tools/android/apps/arcore/src/main/res/values/styles.xml
new file mode 100644
index 0000000000..3a71bd32b5
--- /dev/null
+++ b/platform_tools/android/apps/arcore/src/main/res/values/styles.xml
@@ -0,0 +1,35 @@
+<!--
+   Copyright 2017 Google Inc.
+
+   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.
+-->
+<resources>
+
+  <!--
+      Base application theme, dependent on API level. This theme is replaced
+      by AppBaseTheme from res/values-vXX/styles.xml on newer devices.
+  -->
+  <style name="AppBaseTheme" parent="android:Theme.Light">
+    <!--
+        Theme customizations available in newer API levels can go in
+        res/values-vXX/styles.xml, while customizations related to
+        backward-compatibility can go here.
+    -->
+  </style>
+
+  <!-- Application theme. -->
+  <style name="AppTheme" parent="AppBaseTheme">
+    <!-- All customizations that are NOT specific to a particular API-level can go here. -->
+  </style>
+
+</resources>
diff --git a/platform_tools/android/apps/build.gradle b/platform_tools/android/apps/build.gradle
index 9f285e5b06..64e730897f 100644
--- a/platform_tools/android/apps/build.gradle
+++ b/platform_tools/android/apps/build.gradle
@@ -3,10 +3,11 @@
 
 buildscript {
     repositories {
+        google()
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.2.3'
+        classpath 'com.android.tools.build:gradle:3.0.1'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -15,6 +16,7 @@ buildscript {
 
 allprojects {
     repositories {
+        google()
         jcenter()
     }
 }
@@ -105,5 +107,6 @@ def constructBuildCommand(project, variant, appName) {
     }
 
     String out_dir = getVariantOutDir(project, variant).skiaOut
+
     return "${depotToolsDir}/ninja -C $out_dir $appName"
 }
diff --git a/platform_tools/android/apps/gradle/wrapper/gradle-wrapper.properties b/platform_tools/android/apps/gradle/wrapper/gradle-wrapper.properties
index 9326d8c394..68afb72efc 100644
--- a/platform_tools/android/apps/gradle/wrapper/gradle-wrapper.properties
+++ b/platform_tools/android/apps/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip
\ No newline at end of file
diff --git a/platform_tools/android/apps/settings.gradle b/platform_tools/android/apps/settings.gradle
index a8c2cb3fb4..148e1ac2af 100644
--- a/platform_tools/android/apps/settings.gradle
+++ b/platform_tools/android/apps/settings.gradle
@@ -1,2 +1,3 @@
 include ':viewer'
 include ':skqp'
+include ':arcore' //must build out directory first: bin/gn gen out/arm64 --args='ndk="NDKPATH" target_cpu="ABI" is_component_build=true'
diff --git a/platform_tools/android/apps/skqp/build.gradle b/platform_tools/android/apps/skqp/build.gradle
index e368a66ef6..2c54751b3a 100644
--- a/platform_tools/android/apps/skqp/build.gradle
+++ b/platform_tools/android/apps/skqp/build.gradle
@@ -22,6 +22,7 @@ android {
         versionName "1.0"
         signingConfig signingConfigs.debug
     }
+    flavorDimensions "base"
     sourceSets.main.jni.srcDirs = []
     sourceSets.main.jniLibs.srcDir "src/main/libs"
     productFlavors { universal{}; arm {}; arm64 {}; x86 {}; x64 {}; arm64vulkan{}; }
diff --git a/platform_tools/android/apps/viewer/build.gradle b/platform_tools/android/apps/viewer/build.gradle
index 630544d0bb..6ec51c857d 100644
--- a/platform_tools/android/apps/viewer/build.gradle
+++ b/platform_tools/android/apps/viewer/build.gradle
@@ -22,6 +22,7 @@ android {
         versionName "1.0"
         signingConfig signingConfigs.debug
     }
+    flavorDimensions "base"
     sourceSets.main.jni.srcDirs = [] //disable automatic ndk-build call
     sourceSets.main.jniLibs.srcDir "src/main/libs"
     productFlavors { universal{}; arm {}; arm64 {}; x86 {}; x64 {}; arm64vulkan{}; }
diff --git a/platform_tools/libraries/include/arcore_c_api.h b/platform_tools/libraries/include/arcore_c_api.h
new file mode 100644
index 0000000000..cecd117fa3
--- /dev/null
+++ b/platform_tools/libraries/include/arcore_c_api.h
@@ -0,0 +1,2255 @@
+/*
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+#ifndef ARCORE_C_API_H_
+#define ARCORE_C_API_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+/// @defgroup concepts Concepts
+/// High-Level concepts of ARCore
+///
+/// @section ownership Object ownership
+///
+/// ARCore has two categories of objects: "value types" and "reference types".
+///
+/// - Value types are owned by application. They are created and destroyed using
+///   the @c create / @c destroy methods, and are populated by ARCore using
+///   methods with @c get in the method name.
+///
+/// - Reference types are owned by ARCore. A reference is acquired by one of the
+///   @c acquire methods.  For each call to the @c acquire method, the
+///   application must call the matching @c release method. Note that even if
+///   last reference is released, ARCore may continue to hold a reference to the
+///   object at ARCore's discretion.
+///
+/// Reference types are further split into:
+///
+/// - Long-lived objects. These objects persist across frames, possibly for the
+///   life span of the application or session. Acquire may fail if ARCore is in
+///   an incorrect state, e.g. not tracking. Acquire from list always succeeds,
+///   as the object already exists.
+///
+/// - Transient large data. These objects are usually acquired per-frame and are
+///   a limited resource. The @c acquire call may fail if the resource is
+///   exhausted (too many are currently held), deadline exceeded (the target of
+///   the acquire was already released), or the resource is not yet available.
+///
+/// Note: Lists are value types (owned by application), but can hold references
+/// to long-lived objects. This means that the references held by a list are not
+/// released until either the list is destroyed, or is re-populated by another
+/// api call.
+///
+/// For example, ::ArAnchorList, which is a value type, will hold references to
+/// Anchors, which are long-lived objects.
+///
+/// @section spaces Poses and Coordinate Spaces
+///
+/// An @c ArPose describes an rigid transformation from one coordinate space to
+/// another. As provided from all ARCore APIs, Poses always describe the
+/// transformation from object's local coordinate space to the <b>world
+/// coordinate space</b> (see below). That is, Poses from ARCore APIs can be
+/// thought of as equivalent to OpenGL model matrices.
+///
+/// The transformation is defined using a quaternion rotation about the origin
+/// followed by a translation.
+///
+/// The coordinate system is right-handed, like OpenGL conventions.
+///
+/// Translation units are meters.
+///
+/// @section worldcoordinates World Coordinate Space
+///
+/// As ARCore's understanding of the environment changes, it adjusts its model
+/// of the world to keep things consistent. When this happens, the numerical
+/// location (coordinates) of the camera and anchors can change significantly to
+/// maintain appropriate relative positions of the physical locations they
+/// represent.
+///
+/// These changes mean that every frame should be considered to be in a
+/// completely unique world coordinate space. The numerical coordinates of
+/// anchors and the camera should never be used outside the rendering frame
+/// during which they were retrieved. If a position needs to be considered
+/// beyond the scope of a single rendering frame, either an anchor should be
+/// created or a position relative to a nearby existing anchor should be used.
+
+/// @defgroup common Common Definitions
+/// Shared types and constants
+
+/// @defgroup anchor Anchor
+/// Describes a fixed location and orientation in the real world.
+
+/// @defgroup arcoreapk ArCoreApk
+/// Management of the ARCore service APK
+
+/// @defgroup augmented_image AugmentedImage
+/// An image being detected and tracked by ARCore.
+
+/// @defgroup augmented_image_database AugmentedImageDatabase
+/// Database containing a list of images to be detected and tracked by ARCore.
+
+/// @defgroup camera Camera
+/// Provides information about the camera that is used to capture images.
+
+/// @defgroup cloud Cloud Anchors
+/// The cloud state and configuration of an Anchor and the AR Session.
+
+/// @defgroup config Configuration
+/// Session configuration.
+
+/// @defgroup frame Frame
+/// Per-frame state.
+
+/// @defgroup hit HitResult
+/// Defines an intersection between a ray and estimated real-world geometry.
+
+/// @defgroup image ImageMetadata
+/// Provides access to metadata from the camera image capture result.
+
+/// @defgroup light LightEstimate
+/// Holds information about the estimated lighting of the real scene.
+
+/// @defgroup plane Plane
+/// Describes the current best knowledge of a real-world planar surface.
+
+/// @defgroup point Point
+/// Represents a point in space that ARCore is tracking.
+
+/// @defgroup pointcloud PointCloud
+/// Contains a set of observed 3D points and confidence values.
+
+/// @defgroup pose Pose
+/// Represents an immutable rigid transformation from one coordinate
+/// space to another.
+
+/// @defgroup session Session
+/// Session management.
+
+/// @defgroup trackable Trackable
+/// Something that can be tracked and that Anchors can be attached to.
+
+/// @defgroup cpp_helpers C++ helper functions
+
+/// @addtogroup config
+/// @{
+
+/// An opaque session configuration object (@ref ownership "value type").
+///
+/// Create with ArConfig_create()<br>
+/// Release with ArConfig_destroy()
+typedef struct ArConfig_ ArConfig;
+
+/// @}
+
+/// @addtogroup session
+/// @{
+
+/// The ArCore session (@ref ownership "value type").
+///
+/// Create with ArSession_create()<br>
+/// Release with ArSession_destroy()
+typedef struct ArSession_ ArSession;
+
+/// @}
+
+/// @addtogroup pose
+/// @{
+
+/// A structured rigid transformation (@ref ownership "value type").
+///
+/// Allocate with ArPose_create()<br>
+/// Release with ArPose_destroy()
+typedef struct ArPose_ ArPose;
+
+/// @}
+
+// Camera.
+
+/// @addtogroup camera
+/// @{
+
+/// The virtual and physical camera
+/// (@ref ownership "reference type, long-lived").
+///
+/// Acquire with ArFrame_acquireCamera()<br>
+/// Release with ArCamera_release()
+typedef struct ArCamera_ ArCamera;
+
+/// @}
+
+// Frame and frame objects.
+
+/// @addtogroup frame
+/// @{
+
+/// The world state resulting from an update (@ref ownership "value type").
+///
+/// Allocate with ArFrame_create()<br>
+/// Populate with ArSession_update()<br>
+/// Release with ArFrame_destroy()
+typedef struct ArFrame_ ArFrame;
+
+/// @}
+
+// LightEstimate.
+
+/// @addtogroup light
+/// @{
+
+/// An estimate of the real-world lighting (@ref ownership "value type").
+///
+/// Allocate with ArLightEstimate_create()<br>
+/// Populate with ArFrame_getLightEstimate()<br>
+/// Release with ArLightEstimate_destroy()
+typedef struct ArLightEstimate_ ArLightEstimate;
+
+/// @}
+
+// PointCloud.
+
+/// @addtogroup pointcloud
+/// @{
+
+/// A cloud of tracked 3D visual feature points
+/// (@ref ownership "reference type, large data").
+///
+/// Acquire with ArFrame_acquirePointCloud()<br>
+/// Release with ArPointCloud_release()
+typedef struct ArPointCloud_ ArPointCloud;
+
+/// @}
+
+// ImageMetadata.
+
+/// @addtogroup image
+/// @{
+
+/// Camera capture metadata (@ref ownership "reference type, large data").
+///
+/// Acquire with ArFrame_acquireImageMetadata()<br>
+/// Release with ArImageMetadata_release()
+typedef struct ArImageMetadata_ ArImageMetadata;
+
+/// Accessing CPU image from the tracking camera
+/// (@ref ownership "reference type, large data").
+///
+/// Acquire with ArFrame_acquireCameraImage()<br>
+/// Convert to NDK AImage with ArImage_getNdkImage()<br>
+/// Release with ArImage_release().
+typedef struct ArImage_ ArImage;
+
+/// Forward declaring the AImage struct from Android NDK, which is used
+/// in ArImage_getNdkImage().
+typedef struct AImage AImage;
+/// @}
+
+// Trackables.
+
+/// @addtogroup trackable
+/// @{
+
+/// Trackable base type (@ref ownership "reference type, long-lived").
+typedef struct ArTrackable_ ArTrackable;
+
+/// A list of ArTrackables (@ref ownership "value type").
+///
+/// Allocate with ArTrackableList_create()<br>
+/// Release with ArTrackableList_destroy()
+typedef struct ArTrackableList_ ArTrackableList;
+
+/// @}
+
+// Plane
+
+/// @addtogroup plane
+/// @{
+
+/// A detected planar surface (@ref ownership "reference type, long-lived").
+///
+/// Trackable type: #AR_TRACKABLE_PLANE <br>
+/// Release with: ArTrackable_release()
+typedef struct ArPlane_ ArPlane;
+
+/// @}
+
+// Point
+
+/// @addtogroup point
+/// @{
+
+/// An arbitrary point in space (@ref ownership "reference type, long-lived").
+///
+/// Trackable type: #AR_TRACKABLE_POINT <br>
+/// Release with: ArTrackable_release()
+typedef struct ArPoint_ ArPoint;
+
+/// @}
+
+// Augmented Image
+
+/// @addtogroup augmented_image
+/// @{
+
+/// An image that has been detected and tracked (@ref ownership "reference type,
+/// long-lived").
+///
+/// Trackable type: #AR_TRACKABLE_AUGMENTED_IMAGE <br>
+/// Release with: ArTrackable_release()
+typedef struct ArAugmentedImage_ ArAugmentedImage;
+
+/// @}
+
+// Augmented Image Database
+/// @addtogroup augmented_image_database
+/// @{
+
+/// A database of images to be detected and tracked by ARCore (@ref ownership
+/// "value type").
+///
+/// An image database supports up to 1000 images. A database can be generated by
+/// the `arcoreimg` command-line database generation tool provided in the SDK,
+/// or dynamically created at runtime by adding individual images.
+///
+/// Only one image database can be active in a session. Any images in the
+/// currently active image database that have a TRACKING/PAUSED state will
+/// immediately be set to the STOPPED state if a different or null image
+/// database is made active in the current session Config.
+///
+/// Create with ArAugmentedImageDatabase_create() or
+/// ArAugmentedImageDatabase_deserialize()<br>
+/// Release with: ArAugmentedImageDatabase_destroy()
+typedef struct ArAugmentedImageDatabase_ ArAugmentedImageDatabase;
+
+/// @}
+
+// Anchors.
+
+/// @addtogroup anchor
+/// @{
+
+/// A position in space attached to a trackable
+/// (@ref ownership "reference type, long-lived").
+///
+/// Create with ArSession_acquireNewAnchor() or
+///     ArHitResult_acquireNewAnchor()<br>
+/// Release with ArAnchor_release()
+typedef struct ArAnchor_ ArAnchor;
+
+/// A list of anchors (@ref ownership "value type").
+///
+/// Allocate with ArAnchorList_create()<br>
+/// Release with ArAnchorList_destroy()
+typedef struct ArAnchorList_ ArAnchorList;
+
+/// @}
+
+// Hit result functionality.
+
+/// @addtogroup hit
+/// @{
+
+/// A single trackable hit (@ref ownership "value type").
+///
+/// Allocate with ArHitResult_create()<br>
+/// Populate with ArHitResultList_getItem()<br>
+/// Release with ArHitResult_destroy()
+typedef struct ArHitResult_ ArHitResult;
+
+/// A list of hit test results (@ref ownership "value type").
+///
+/// Allocate with ArHitResultList_create()<br>
+/// Release with ArHitResultList_destroy()<br>
+typedef struct ArHitResultList_ ArHitResultList;
+
+/// @}
+
+/// @cond EXCLUDE_FROM_DOXYGEN
+
+// Forward declaring the ACameraMetadata struct from Android NDK, which is used
+// in ArImageMetadata_getNdkCameraMetadata
+typedef struct ACameraMetadata ACameraMetadata;
+
+/// @endcond
+
+/// @addtogroup cpp_helpers
+/// @{
+/// These methods expose allowable type conversions as C++ helper functions.
+/// This avoids having to explicitly @c reinterpret_cast in most cases.
+///
+/// Note: These methods only change the type of a pointer - they do not change
+/// the reference count of the referenced objects.
+///
+/// Note: There is no runtime checking that casts are correct. Call @ref
+/// ArTrackable_getType() beforehand to figure out the correct cast.
+
+#ifdef __cplusplus
+/// Upcasts to ArTrackable
+inline ArTrackable *ArAsTrackable(ArPlane *plane) {
+  return reinterpret_cast<ArTrackable *>(plane);
+}
+
+/// Upcasts to ArTrackable
+inline ArTrackable *ArAsTrackable(ArPoint *point) {
+  return reinterpret_cast<ArTrackable *>(point);
+}
+
+/// Upcasts to ArTrackable
+inline ArTrackable *ArAsTrackable(ArAugmentedImage *augmented_image) {
+  return reinterpret_cast<ArTrackable *>(augmented_image);
+}
+
+/// Downcasts to ArPlane.
+inline ArPlane *ArAsPlane(ArTrackable *trackable) {
+  return reinterpret_cast<ArPlane *>(trackable);
+}
+
+/// Downcasts to ArPoint.
+inline ArPoint *ArAsPoint(ArTrackable *trackable) {
+  return reinterpret_cast<ArPoint *>(trackable);
+}
+
+/// Downcasts to ArAugmentedImage.
+inline ArAugmentedImage *ArAsAugmentedImage(ArTrackable *trackable) {
+  return reinterpret_cast<ArAugmentedImage *>(trackable);
+}
+#endif
+/// @}
+
+// If compiling for C++11, use the 'enum underlying type' feature to enforce
+// size for ABI compatibility. In pre-C++11, use int32_t for fixed size.
+#if __cplusplus >= 201100
+#define AR_DEFINE_ENUM(_type) enum _type : int32_t
+#else
+#define AR_DEFINE_ENUM(_type) \
+  typedef int32_t _type;      \
+  enum
+#endif
+
+#if defined(__GNUC__) && !defined(AR_DEPRECATED_SUPPRESS)
+#define AR_DEPRECATED(_deprecation_string) \
+  __attribute__((deprecated(_deprecation_string)));
+#else
+#define AR_DEPRECATED(_deprecation_string)
+#endif
+
+/// @ingroup trackable
+/// Object types for heterogeneous query/update lists.
+AR_DEFINE_ENUM(ArTrackableType){
+    /// The base Trackable type. Can be passed to ArSession_getAllTrackables()
+    /// and ArFrame_getUpdatedTrackables() as the @c filter_type to get
+    /// all/updated Trackables of all types.
+    AR_TRACKABLE_BASE_TRACKABLE = 0x41520100,
+
+    /// The ::ArPlane subtype of Trackable.
+    AR_TRACKABLE_PLANE = 0x41520101,
+
+    /// The ::ArPoint subtype of Trackable.
+    AR_TRACKABLE_POINT = 0x41520102,
+
+    /// The ::ArAugmentedImage subtype of Trackable.
+    AR_TRACKABLE_AUGMENTED_IMAGE = 0x41520104,
+
+    /// An invalid Trackable type.
+    AR_TRACKABLE_NOT_VALID = 0};
+
+/// @ingroup common
+/// Return code indicating success or failure of a method.
+AR_DEFINE_ENUM(ArStatus){
+    /// The operation was successful.
+    AR_SUCCESS = 0,
+
+    /// One of the arguments was invalid, either null or not appropriate for the
+    /// operation requested.
+    AR_ERROR_INVALID_ARGUMENT = -1,
+
+    /// An internal error occurred that the application should not attempt to
+    /// recover from.
+    AR_ERROR_FATAL = -2,
+
+    /// An operation was attempted that requires the session be running, but the
+    /// session was paused.
+    AR_ERROR_SESSION_PAUSED = -3,
+
+    /// An operation was attempted that requires the session be paused, but the
+    /// session was running.
+    AR_ERROR_SESSION_NOT_PAUSED = -4,
+
+    /// An operation was attempted that the session be in the TRACKING state,
+    /// but the session was not.
+    AR_ERROR_NOT_TRACKING = -5,
+
+    /// A texture name was not set by calling ArSession_setCameraTextureName()
+    /// before the first call to ArSession_update()
+    AR_ERROR_TEXTURE_NOT_SET = -6,
+
+    /// An operation required GL context but one was not available.
+    AR_ERROR_MISSING_GL_CONTEXT = -7,
+
+    /// The configuration supplied to ArSession_configure() was unsupported.
+    /// To avoid this error, ensure that Session_checkSupported() returns true.
+    AR_ERROR_UNSUPPORTED_CONFIGURATION = -8,
+
+    /// The android camera permission has not been granted prior to calling
+    /// ArSession_resume()
+    AR_ERROR_CAMERA_PERMISSION_NOT_GRANTED = -9,
+
+    /// Acquire failed because the object being acquired is already released.
+    /// For example, this happens if the application holds an ::ArFrame beyond
+    /// the next call to ArSession_update(), and then tries to acquire its point
+    /// cloud.
+    AR_ERROR_DEADLINE_EXCEEDED = -10,
+
+    /// There are no available resources to complete the operation.  In cases of
+    /// @c acquire methods returning this error, This can be avoided by
+    /// releasing previously acquired objects before acquiring new ones.
+    AR_ERROR_RESOURCE_EXHAUSTED = -11,
+
+    /// Acquire failed because the data isn't available yet for the current
+    /// frame. For example, acquire the image metadata may fail with this error
+    /// because the camera hasn't fully started.
+    AR_ERROR_NOT_YET_AVAILABLE = -12,
+
+    /// The android camera has been reallocated to a higher priority app or is
+    /// otherwise unavailable.
+    AR_ERROR_CAMERA_NOT_AVAILABLE = -13,
+
+    /// The host/resolve function call failed because the Session is not
+    /// configured for cloud anchors.
+    AR_ERROR_CLOUD_ANCHORS_NOT_CONFIGURED = -14,
+
+    /// ArSession_configure() failed because the specified configuration
+    /// required the Android INTERNET permission, which the application did not
+    /// have.
+    AR_ERROR_INTERNET_PERMISSION_NOT_GRANTED = -15,
+
+    /// HostCloudAnchor() failed because the anchor is not a type of anchor that
+    /// is currently supported for hosting.
+    AR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_HOSTING = -16,
+
+    /// An image with insufficient quality (e.g. too few features) was attempted
+    /// to be added to the image database.
+    AR_ERROR_IMAGE_INSUFFICIENT_QUALITY = -17,
+
+    /// The data passed in for this operation was not in a valid format.
+    AR_ERROR_DATA_INVALID_FORMAT = -18,
+
+    /// The data passed in for this operation is not supported by this version
+    /// of the SDK.
+    AR_ERROR_DATA_UNSUPPORTED_VERSION = -19,
+
+    /// The ARCore APK is not installed on this device.
+    AR_UNAVAILABLE_ARCORE_NOT_INSTALLED = -100,
+
+    /// The device is not currently compatible with ARCore.
+    AR_UNAVAILABLE_DEVICE_NOT_COMPATIBLE = -101,
+
+    /// The ARCore APK currently installed on device is too old and needs to be
+    /// updated.
+    AR_UNAVAILABLE_APK_TOO_OLD = -103,
+
+    /// The ARCore APK currently installed no longer supports the ARCore SDK
+    /// that the application was built with.
+    AR_UNAVAILABLE_SDK_TOO_OLD = -104,
+
+    /// The user declined installation of the ARCore APK during this run of the
+    /// application and the current request was not marked as user-initiated.
+    AR_UNAVAILABLE_USER_DECLINED_INSTALLATION = -105};
+
+/// @ingroup common
+/// Describes the tracking state of a @c Trackable, an ::ArAnchor or the
+/// ::ArCamera.
+AR_DEFINE_ENUM(ArTrackingState){
+    /// The object is currently tracked and its pose is current.
+    AR_TRACKING_STATE_TRACKING = 0,
+
+    /// ARCore has paused tracking this object, but may resume tracking it in
+    /// the future. This can happen if device tracking is lost, if the user
+    /// enters a new space, or if the Session is currently paused. When in this
+    /// state, the positional properties of the object may be wildly inaccurate
+    /// and should not be used.
+    AR_TRACKING_STATE_PAUSED = 1,
+
+    /// ARCore has stopped tracking this Trackable and will never resume
+    /// tracking it.
+    AR_TRACKING_STATE_STOPPED = 2};
+
+/// @ingroup cloud
+/// Describes the current cloud state of an @c Anchor.
+AR_DEFINE_ENUM(ArCloudAnchorState){
+    /// The anchor is purely local. It has never been hosted using
+    /// hostCloudAnchor, and has not been acquired using acquireCloudAnchor.
+    AR_CLOUD_ANCHOR_STATE_NONE = 0,
+
+    /// A hosting/resolving task for the anchor is in progress. Once the task
+    /// completes in the background, the anchor will get a new cloud state after
+    /// the next update() call.
+    AR_CLOUD_ANCHOR_STATE_TASK_IN_PROGRESS = 1,
+
+    /// A hosting/resolving task for this anchor completed successfully.
+    AR_CLOUD_ANCHOR_STATE_SUCCESS = 2,
+
+    /// A hosting/resolving task for this anchor finished with an internal
+    /// error. The app should not attempt to recover from this error.
+    AR_CLOUD_ANCHOR_STATE_ERROR_INTERNAL = -1,
+
+    /// The app cannot communicate with the ARCore Cloud because of an invalid
+    /// or unauthorized API key in the manifest, or because there was no API key
+    /// present in the manifest.
+    AR_CLOUD_ANCHOR_STATE_ERROR_NOT_AUTHORIZED = -2,
+
+    /// The ARCore Cloud was unreachable. This can happen because of a number of
+    /// reasons. The request sent to the server could have timed out with no
+    /// response, there could be a bad network connection, DNS unavailability,
+    /// firewall issues, or anything that could affect the device's ability to
+    /// connect to the ARCore Cloud.
+    AR_CLOUD_ANCHOR_STATE_ERROR_SERVICE_UNAVAILABLE = -3,
+
+    /// The application has exhausted the request quota allotted to the given
+    /// API key. The developer should request additional quota for the ARCore
+    /// Cloud for their API key from the Google Developers Console.
+    AR_CLOUD_ANCHOR_STATE_ERROR_RESOURCE_EXHAUSTED = -4,
+
+    /// Hosting failed, because the server could not successfully process the
+    /// dataset for the given anchor. The developer should try again after the
+    /// device has gathered more data from the environment.
+    AR_CLOUD_ANCHOR_STATE_ERROR_HOSTING_DATASET_PROCESSING_FAILED = -5,
+
+    /// Resolving failed, because the ARCore Cloud could not find the provided
+    /// cloud anchor ID.
+    AR_CLOUD_ANCHOR_STATE_ERROR_CLOUD_ID_NOT_FOUND = -6,
+
+    /// The server could not match the visual features provided by ARCore
+    /// against the localization dataset of the requested cloud anchor ID. This
+    /// means that the anchor pose being requested was likely not created in the
+    /// user's surroundings.
+    AR_CLOUD_ANCHOR_STATE_ERROR_RESOLVING_LOCALIZATION_NO_MATCH = -7,
+
+    /// The anchor could not be resolved because the SDK used to host the anchor
+    /// was newer than and incompatible with the version being used to acquire
+    /// it.
+    AR_CLOUD_ANCHOR_STATE_ERROR_RESOLVING_SDK_VERSION_TOO_OLD = -8,
+
+    /// The anchor could not be acquired because the SDK used to host the anchor
+    /// was older than and incompatible with the version being used to acquire
+    /// it.
+    AR_CLOUD_ANCHOR_STATE_ERROR_RESOLVING_SDK_VERSION_TOO_NEW = -9};
+
+/// @ingroup arcoreapk
+/// Describes the current state of ARCore availability on the device.
+AR_DEFINE_ENUM(ArAvailability){
+    /// An internal error occurred while determining ARCore availability.
+    AR_AVAILABILITY_UNKNOWN_ERROR = 0,
+    /// ARCore is not installed, and a query has been issued to check if ARCore
+    /// is is supported.
+    AR_AVAILABILITY_UNKNOWN_CHECKING = 1,
+    /// ARCore is not installed, and the query to check if ARCore is supported
+    /// timed out. This may be due to the device being offline.
+    AR_AVAILABILITY_UNKNOWN_TIMED_OUT = 2,
+    /// ARCore is not supported on this device.
+    AR_AVAILABILITY_UNSUPPORTED_DEVICE_NOT_CAPABLE = 100,
+    /// The device and Android version are supported, but the ARCore APK is not
+    /// installed.
+    AR_AVAILABILITY_SUPPORTED_NOT_INSTALLED = 201,
+    /// The device and Android version are supported, and a version of the
+    /// ARCore APK is installed, but that ARCore APK version is too old.
+    AR_AVAILABILITY_SUPPORTED_APK_TOO_OLD = 202,
+    /// ARCore is supported, installed, and available to use.
+    AR_AVAILABILITY_SUPPORTED_INSTALLED = 203};
+
+/// @ingroup arcoreapk
+/// Indicates the outcome of a call to ArCoreApk_requestInstall().
+AR_DEFINE_ENUM(ArInstallStatus){
+    /// The requested resource is already installed.
+    AR_INSTALL_STATUS_INSTALLED = 0,
+    /// Installation of the resource was requested. The current activity will be
+    /// paused.
+    AR_INSTALL_STATUS_INSTALL_REQUESTED = 1};
+
+/// @ingroup arcoreapk
+/// Controls the behavior of the installation UI.
+AR_DEFINE_ENUM(ArInstallBehavior){
+    /// Hide the Cancel button during initial prompt and prevent user from
+    /// exiting via tap-outside.
+    ///
+    /// Note: The BACK button or tapping outside of any marketplace-provided
+    /// install dialog will still decline the installation.
+    AR_INSTALL_BEHAVIOR_REQUIRED = 0,
+    /// Include Cancel button in initial prompt and allow easily backing out
+    /// after installation has been initiated.
+    AR_INSTALL_BEHAVIOR_OPTIONAL = 1};
+
+/// @ingroup arcoreapk
+/// Controls the message displayed by the installation UI.
+AR_DEFINE_ENUM(ArInstallUserMessageType){
+    /// Display a localized message like "This application requires ARCore...".
+    AR_INSTALL_USER_MESSAGE_TYPE_APPLICATION = 0,
+    /// Display a localized message like "This feature requires ARCore...".
+    AR_INSTALL_USER_MESSAGE_TYPE_FEATURE = 1,
+    /// Application has explained why ARCore is required prior to calling
+    /// ArCoreApk_requestInstall(), skip user education dialog.
+    AR_INSTALL_USER_MESSAGE_TYPE_USER_ALREADY_INFORMED = 2};
+
+/// @ingroup config
+/// Select the behavior of the lighting estimation subsystem.
+AR_DEFINE_ENUM(ArLightEstimationMode){
+    /// Lighting estimation is disabled.
+    AR_LIGHT_ESTIMATION_MODE_DISABLED = 0,
+    /// Lighting estimation is enabled, generating a single-value intensity
+    /// estimate.
+    AR_LIGHT_ESTIMATION_MODE_AMBIENT_INTENSITY = 1};
+
+/// @ingroup config
+/// Select the behavior of the plane detection subsystem.
+AR_DEFINE_ENUM(ArPlaneFindingMode){
+    /// Plane detection is disabled.
+    AR_PLANE_FINDING_MODE_DISABLED = 0,
+    /// Detection of only horizontal planes is enabled.
+    AR_PLANE_FINDING_MODE_HORIZONTAL = 1,
+    /// Detection of only vertical planes is enabled.
+    AR_PLANE_FINDING_MODE_VERTICAL = 2,
+    /// Detection of horizontal and vertical planes is enabled.
+    AR_PLANE_FINDING_MODE_HORIZONTAL_AND_VERTICAL = 3};
+
+/// @ingroup config
+/// Selects the behavior of ArSession_update().
+AR_DEFINE_ENUM(ArUpdateMode){
+    /// @c update() will wait until a new camera image is available, or until
+    /// the built-in timeout (currently 66ms) is reached. On most
+    /// devices the camera is configured to capture 30 frames per second.
+    /// If the camera image does not arrive by the built-in timeout, then
+    /// @c update() will return the most recent ::ArFrame object.
+    AR_UPDATE_MODE_BLOCKING = 0,
+    /// @c update() will return immediately without blocking. If no new camera
+    /// image is available, then @c update() will return the most recent
+    /// ::ArFrame object.
+    AR_UPDATE_MODE_LATEST_CAMERA_IMAGE = 1};
+
+/// @ingroup plane
+/// Simple summary of the normal vector of a plane, for filtering purposes.
+AR_DEFINE_ENUM(ArPlaneType){
+    /// A horizontal plane facing upward (for example a floor or tabletop).
+    AR_PLANE_HORIZONTAL_UPWARD_FACING = 0,
+    /// A horizontal plane facing downward (for example a ceiling).
+    AR_PLANE_HORIZONTAL_DOWNWARD_FACING = 1,
+    /// A vertical plane (for example a wall).
+    AR_PLANE_VERTICAL = 2};
+
+/// @ingroup light
+/// Tracks the validity of a light estimate.
+AR_DEFINE_ENUM(ArLightEstimateState){
+    /// The light estimate is not valid this frame and should not be used for
+    /// rendering.
+    AR_LIGHT_ESTIMATE_STATE_NOT_VALID = 0,
+    /// The light estimate is valid this frame.
+    AR_LIGHT_ESTIMATE_STATE_VALID = 1};
+
+/// @ingroup point
+/// Indicates the orientation mode of the ::ArPoint.
+AR_DEFINE_ENUM(ArPointOrientationMode){
+    /// The orientation of the ::ArPoint is initialized to identity but may
+    /// adjust slightly over time.
+    AR_POINT_ORIENTATION_INITIALIZED_TO_IDENTITY = 0,
+    /// The orientation of the ::ArPoint will follow the behavior described in
+    /// ArHitResult_getHitPose().
+    AR_POINT_ORIENTATION_ESTIMATED_SURFACE_NORMAL = 1};
+
+/// @ingroup cloud
+/// Indicates the cloud configuration of the ::ArSession.
+AR_DEFINE_ENUM(ArCloudAnchorMode){
+    /// Anchor Hosting is disabled. This is the value set in the default
+    /// ::ArConfig.
+    AR_CLOUD_ANCHOR_MODE_DISABLED = 0,
+    /// Anchor Hosting is enabled. Setting this value and calling @c configure()
+    /// will require that the application have the Android INTERNET permission.
+    AR_CLOUD_ANCHOR_MODE_ENABLED = 1};
+
+#undef AR_DEFINE_ENUM
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Note: destroy methods do not take ArSession* to allow late destruction in
+// finalizers of garbage-collected languages such as Java.
+
+/// @addtogroup arcoreapk
+/// @{
+
+/// Determines if ARCore is supported on this device. This may initiate a query
+/// with a remote service to determine if the device is compatible, in which
+/// case it will return immediately with @c out_availability set to
+/// #AR_AVAILABILITY_UNKNOWN_CHECKING.
+///
+/// For ARCore-required apps (as indicated by the <a
+/// href="https://developers.google.com/ar/develop/c/enable-arcore#ar_required">manifest
+/// meta-data</a>) this method will assume device compatibility and will always
+/// immediately return one of #AR_AVAILABILITY_SUPPORTED_INSTALLED,
+/// #AR_AVAILABILITY_SUPPORTED_APK_TOO_OLD, or
+/// #AR_AVAILABILITY_SUPPORTED_NOT_INSTALLED.
+///
+/// Note: A result #AR_AVAILABILITY_SUPPORTED_INSTALLED only indicates presence
+/// of a suitably versioned ARCore APK. Session creation may still fail if the
+/// ARCore APK has been sideloaded onto an incompatible device.
+///
+/// May be called prior to ArSession_create().
+///
+/// @param[in] env The application's @c JNIEnv object
+/// @param[in] application_context A @c jobject referencing the application's
+///     Android @c Context.
+/// @param[out] out_availability A pointer to an ArAvailability to receive
+///     the result.
+void ArCoreApk_checkAvailability(void *env,
+                                 void *application_context,
+                                 ArAvailability *out_availability);
+
+/// Initiates installation of ARCore if needed. When your apllication launches
+/// or enters an AR mode, it should call this method with @c
+/// user_requested_install = 1.
+///
+/// If ARCore is installed and compatible, this function will set @c
+/// out_install_status to #AR_INSTALL_STATUS_INSTALLED.
+///
+/// If ARCore is not currently installed or the installed version not
+/// compatible, the function will set @c out_install_status to
+/// #AR_INSTALL_STATUS_INSTALL_REQUESTED and return immediately. Your current
+/// activity will then pause while the user is informed about the requierment of
+/// ARCore and offered the opportunity to install it.
+///
+/// When your activity resumes, you should call this method again, this time
+/// with @c user_requested_install = 0. This will either set
+/// @c out_install_status to #AR_INSTALL_STATUS_INSTALLED or return an error
+/// code indicating the reason that installation could not be completed.
+///
+/// ARCore-optional applications must ensure that ArCoreApk_checkAvailability()
+/// returns one of the <tt>AR_AVAILABILITY_SUPPORTED_...</tt> values before
+/// calling this method.
+///
+/// See <A
+/// href="https://github.com/google-ar/arcore-android-sdk/tree/master/samples">
+/// our sample code</A> for an example of how an ARCore-required application
+/// should use this function.
+///
+/// May be called prior to ArSession_create().
+///
+/// For more control over the message displayed and ease of exiting the process,
+/// see ArCoreApk_requestInstallCustom().
+///
+/// <b>Caution:</b> The value of <tt>*out_install_status</tt> should only be
+/// considered when #AR_SUCCESS is returned.  Otherwise this value must be
+/// ignored.
+///
+/// @param[in] env The application's @c JNIEnv object
+/// @param[in] application_activity A @c jobject referencing the application's
+///     current Android @c Activity.
+/// @param[in] user_requested_install if set, override the previous installation
+///     failure message and always show the installation interface.
+/// @param[out] out_install_status A pointer to an ArInstallStatus to receive
+///     the resulting install status, if successful.  Note: this value is only
+///     valid with the return value is #AR_SUCCESS.
+/// @return #AR_SUCCESS, or any of:
+/// - #AR_ERROR_FATAL if an error occurs while checking for or requesting
+///     installation
+/// - #AR_UNAVAILABLE_DEVICE_NOT_COMPATIBLE if ARCore is not supported
+///     on this device.
+/// - #AR_UNAVAILABLE_USER_DECLINED_INSTALLATION if the user previously declined
+///     installation.
+ArStatus ArCoreApk_requestInstall(void *env,
+                                  void *application_activity,
+                                  bool user_requested_install,
+                                  ArInstallStatus *out_install_status);
+
+/// Initiates installation of ARCore if required, with configurable behavior.
+///
+/// This is a more flexible version of ArCoreApk_requestInstall() allowing the
+/// application control over the initial informational dialog and ease of
+/// exiting or cancelling the installation.
+///
+/// See ArCoreApk_requestInstall() for details of use and behavior.
+///
+/// May be called prior to ArSession_create().
+///
+/// @param[in] env The application's @c JNIEnv object
+/// @param[in] application_activity A @c jobject referencing the application's
+///     current Android @c Activity.
+/// @param[in] user_requested_install if set, override the previous installation
+///     failure message and always show the installation interface.
+/// @param[in] install_behavior controls the presence of the cancel button at
+///     the user education screen and if tapping outside the education screen or
+///     install-in-progress screen causes them to dismiss.
+/// @param[in] message_type controls the text of the of message displayed
+///     before showing the install prompt, or disables display of this message.
+/// @param[out] out_install_status A pointer to an ArInstallStatus to receive
+///     the resulting install status, if successful.  Note: this value is only
+///     valid with the return value is #AR_SUCCESS.
+/// @return #AR_SUCCESS, or any of:
+/// - #AR_ERROR_FATAL if an error occurs while checking for or requesting
+///     installation
+/// - #AR_UNAVAILABLE_DEVICE_NOT_COMPATIBLE if ARCore is not supported
+///     on this device.
+/// - #AR_UNAVAILABLE_USER_DECLINED_INSTALLATION if the user previously declined
+///     installation.
+ArStatus ArCoreApk_requestInstallCustom(void *env,
+                                        void *application_activity,
+                                        int32_t user_requested_install,
+                                        ArInstallBehavior install_behavior,
+                                        ArInstallUserMessageType message_type,
+                                        ArInstallStatus *out_install_status);
+
+/// @}
+/// @addtogroup session
+/// @{
+
+/// Attempts to create a new ARCore session.
+///
+/// This is the entry point of ARCore.  This function MUST be the first ARCore
+/// call made by an application.
+///
+/// @param[in]  env                 The application's @c JNIEnv object
+/// @param[in]  application_context A @c jobject referencing the application's
+///     Android @c Context
+/// @param[out] out_session_pointer A pointer to an @c ArSession* to receive
+///     the address of the newly allocated session.
+/// @return #AR_SUCCESS or any of:
+/// - #AR_UNAVAILABLE_ARCORE_NOT_INSTALLED
+/// - #AR_UNAVAILABLE_DEVICE_NOT_COMPATIBLE
+/// - #AR_UNAVAILABLE_APK_TOO_OLD
+/// - #AR_UNAVAILABLE_SDK_TOO_OLD
+/// - #AR_ERROR_CAMERA_PERMISSION_NOT_GRANTED
+ArStatus ArSession_create(void *env,
+                          void *application_context,
+                          ArSession **out_session_pointer);
+
+/// @}
+
+// === ArConfig methods ===
+
+/// @addtogroup config
+/// @{
+
+/// Creates a new configuration object and initializes it to a sensible default
+/// configuration. Plane detection and lighting estimation are enabled, and
+/// blocking update is selected. This configuration is guaranteed to be
+/// supported on all devices that support ARCore.
+void ArConfig_create(const ArSession *session, ArConfig **out_config);
+
+/// Releases memory used by the provided configuration object.
+void ArConfig_destroy(ArConfig *config);
+
+/// Stores the currently configured lighting estimation mode into
+/// @c *light_estimation_mode.
+void ArConfig_getLightEstimationMode(
+    const ArSession *session,
+    const ArConfig *config,
+    ArLightEstimationMode *light_estimation_mode);
+
+/// Sets the lighting estimation mode that should be used. See
+/// ::ArLightEstimationMode for available options.
+void ArConfig_setLightEstimationMode(
+    const ArSession *session,
+    ArConfig *config,
+    ArLightEstimationMode light_estimation_mode);
+
+/// Stores the currently configured plane finding mode into
+/// @c *plane_finding_mode.
+void ArConfig_getPlaneFindingMode(const ArSession *session,
+                                  const ArConfig *config,
+                                  ArPlaneFindingMode *plane_finding_mode);
+
+/// Sets the plane finding mode that should be used. See
+/// ::ArPlaneFindingMode for available options.
+void ArConfig_setPlaneFindingMode(const ArSession *session,
+                                  ArConfig *config,
+                                  ArPlaneFindingMode plane_finding_mode);
+
+/// Stores the currently configured behavior of @ref ArSession_update() into
+/// @c *update_mode.
+void ArConfig_getUpdateMode(const ArSession *session,
+                            const ArConfig *config,
+                            ArUpdateMode *update_mode);
+
+/// Sets the behavior of @ref ArSession_update(). See
+/// ::ArUpdateMode for available options.
+void ArConfig_setUpdateMode(const ArSession *session,
+                            ArConfig *config,
+                            ArUpdateMode update_mode);
+
+/// Gets the current cloud anchor mode from the ::ArConfig.
+void ArConfig_getCloudAnchorMode(const ArSession *session,
+                                 const ArConfig *config,
+                                 ArCloudAnchorMode *out_cloud_anchor_mode);
+
+/// Sets the cloud configuration that should be used. See ::ArCloudAnchorMode
+/// for available options.
+void ArConfig_setCloudAnchorMode(const ArSession *session,
+                                 ArConfig *config,
+                                 ArCloudAnchorMode cloud_anchor_mode);
+
+/// Sets the image database in the session configuration.
+///
+/// Any images in the currently active image database that have a
+/// TRACKING/PAUSED state will immediately be set to the STOPPED state if a
+/// different or null image database is set.
+///
+/// This function makes a copy of the image database.
+void ArConfig_setAugmentedImageDatabase(
+    const ArSession *session,
+    ArConfig *config,
+    const ArAugmentedImageDatabase *augmented_image_database);
+
+/// Returns the image database from the session configuration.
+///
+/// This function returns a copy of the internally stored image database.
+void ArConfig_getAugmentedImageDatabase(
+    const ArSession *session,
+    const ArConfig *config,
+    ArAugmentedImageDatabase *out_augmented_image_database);
+
+/// @}
+
+// === ArSession methods ===
+
+/// @addtogroup session
+/// @{
+
+/// Releases resources used by an ARCore session.
+void ArSession_destroy(ArSession *session);
+
+/// Before release 1.2.0: Checks if the provided configuration is usable on the
+/// this device. If this method returns #AR_ERROR_UNSUPPORTED_CONFIGURATION,
+/// calls to ArSession_configure(Config) with this configuration will fail.
+///
+/// This function now always returns true. See documentation for each
+/// configuration entry to know which configuration options & combinations are
+/// supported.
+///
+/// @param[in] session The ARCore session
+/// @param[in] config  The configuration to test
+/// @return #AR_SUCCESS or:
+///  - #AR_ERROR_INVALID_ARGUMENT if any of the arguments are null.
+/// @deprecated in release 1.2.0. Please refer to the release notes
+/// (<a
+/// href="https://github.com/google-ar/arcore-android-sdk/releases/tag/v1.2.0">release
+/// notes 1.2.0</a>)
+///
+ArStatus ArSession_checkSupported(const ArSession *session,
+                                  const ArConfig *config)
+    AR_DEPRECATED(
+        "deprecated in release 1.2.0. Please see function documentation");
+
+/// Configures the session with the given config.
+/// Note: a session is always initially configured with the default config.
+/// This should be called if a configuration different than default is needed.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_FATAL
+/// - #AR_ERROR_UNSUPPORTED_CONFIGURATION
+ArStatus ArSession_configure(ArSession *session, const ArConfig *config);
+
+/// Starts or resumes the ARCore Session.
+///
+/// Typically this should be called from <a
+/// href="https://developer.android.com/reference/android/app/Activity.html#onResume()"
+/// ><tt>Activity.onResume()</tt></a>.
+///
+/// @returns #AR_SUCCESS or any of:
+/// - #AR_ERROR_FATAL
+/// - #AR_ERROR_CAMERA_PERMISSION_NOT_GRANTED
+/// - #AR_ERROR_CAMERA_NOT_AVAILABLE
+ArStatus ArSession_resume(ArSession *session);
+
+/// Pause the current session. This method will stop the camera feed and release
+/// resources. The session can be restarted again by calling ArSession_resume().
+///
+/// Typically this should be called from <a
+/// href="https://developer.android.com/reference/android/app/Activity.html#onPause()"
+/// ><tt>Activity.onPause()</tt></a>.
+///
+/// @returns #AR_SUCCESS or any of:
+/// - #AR_ERROR_FATAL
+ArStatus ArSession_pause(ArSession *session);
+
+/// Sets the OpenGL texture name (id) that will allow GPU access to the camera
+/// image. The provided ID should have been created with @c glGenTextures(). The
+/// resulting texture must be bound to the @c GL_TEXTURE_EXTERNAL_OES target for
+/// use. Shaders accessing this texture must use a @c samplerExternalOES
+/// sampler. See sample code for an example.
+void ArSession_setCameraTextureName(ArSession *session, uint32_t texture_id);
+
+/// Sets the aspect ratio, coordinate scaling, and display rotation. This data
+/// is used by UV conversion, projection matrix generation, and hit test logic.
+///
+/// Note: this function doesn't fail. If given invalid input, it logs a error
+/// and doesn't apply the changes.
+///
+/// @param[in] session   The ARCore session
+/// @param[in] rotation  Display rotation specified by @c android.view.Surface
+///     constants: @c ROTATION_0, @c ROTATION_90, @c ROTATION_180 and
+///     @c ROTATION_270
+/// @param[in] width     Width of the view, in pixels
+/// @param[in] height    Height of the view, in pixels
+void ArSession_setDisplayGeometry(ArSession *session,
+                                  int32_t rotation,
+                                  int32_t width,
+                                  int32_t height);
+
+/// Updates the state of the ARCore system. This includes: receiving a new
+/// camera frame, updating the location of the device, updating the location of
+/// tracking anchors, updating detected planes, etc.
+///
+/// This call may cause off-screen OpenGL activity. Because of this, to avoid
+/// unnecessary frame buffer flushes and reloads, this call should not be made
+/// in the middle of rendering a frame or offscreen buffer.
+///
+/// This call may update the pose of all created anchors and detected planes.
+/// The set of updated objects is accessible through
+/// ArFrame_getUpdatedTrackables().
+///
+/// @c update() in blocking mode (see ::ArUpdateMode) will wait until a
+/// new camera image is available, or until the built-in timeout
+/// (currently 66ms) is reached.
+/// If the camera image does not arrive by the built-in timeout, then
+/// @c update() will return the most recent ::ArFrame object. For some
+/// applications it may be important to know if a new frame was actually
+/// obtained (for example, to avoid redrawing if the camera did not produce a
+/// new frame). To do that, compare the current frame's timestamp, obtained via
+/// @c ArFrame_getTimestamp, with the previously recorded frame timestamp. If
+/// they are different, this is a new frame.
+///
+/// @param[in]    session   The ARCore session
+/// @param[inout] out_frame The Frame object to populate with the updated world
+///     state.  This frame must have been previously created using
+///     ArFrame_create().  The same ArFrame instance may be used when calling
+///     this repeatedly.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_FATAL
+/// - #AR_ERROR_SESSION_PAUSED
+/// - #AR_ERROR_TEXTURE_NOT_SET
+/// - #AR_ERROR_MISSING_GL_CONTEXT
+/// - #AR_ERROR_CAMERA_NOT_AVAILABLE - camera was removed during runtime.
+ArStatus ArSession_update(ArSession *session, ArFrame *out_frame);
+
+/// Defines a tracked location in the physical world.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_NOT_TRACKING
+/// - #AR_ERROR_SESSION_PAUSED
+/// - #AR_ERROR_RESOURCE_EXHAUSTED
+ArStatus ArSession_acquireNewAnchor(ArSession *session,
+                                    const ArPose *pose,
+                                    ArAnchor **out_anchor);
+
+/// Returns all known anchors, including those not currently tracked. Anchors
+/// forgotten by ARCore due to a call to ArAnchor_detach() or entering the
+/// #AR_TRACKING_STATE_STOPPED state will not be included.
+///
+/// @param[in]    session         The ARCore session
+/// @param[inout] out_anchor_list The list to fill.  This list must have already
+///     been allocated with ArAnchorList_create().  If previously used, the list
+///     will first be cleared.
+void ArSession_getAllAnchors(const ArSession *session,
+                             ArAnchorList *out_anchor_list);
+
+/// Returns the list of all known @ref trackable "trackables".  This includes
+/// ::ArPlane objects if plane detection is enabled, as well as ::ArPoint
+/// objects created as a side effect of calls to ArSession_acquireNewAnchor() or
+/// ArFrame_hitTest().
+///
+/// @param[in]    session            The ARCore session
+/// @param[in]    filter_type        The type(s) of trackables to return.  See
+///     ::ArTrackableType for legal values.
+/// @param[inout] out_trackable_list The list to fill.  This list must have
+///     already been allocated with ArTrackableList_create().  If previously
+///     used, the list will first be cleared.
+void ArSession_getAllTrackables(const ArSession *session,
+                                ArTrackableType filter_type,
+                                ArTrackableList *out_trackable_list);
+
+/// This will create a new cloud anchor using pose and other metadata from
+/// @c anchor.
+///
+/// If the function returns #AR_SUCCESS, the cloud state of @c out_cloud_anchor
+/// will be set to #AR_CLOUD_ANCHOR_STATE_TASK_IN_PROGRESS and the initial pose
+/// will be set to the pose of @c anchor. However, the new @c out_cloud_anchor
+/// is completely independent of @c anchor, and the poses may diverge over time.
+/// If the return value of this function is not #AR_SUCCESS, then
+/// @c out_cloud_anchor will be set to null.
+///
+/// @param[in]    session          The ARCore session
+/// @param[in]    anchor           The anchor to be hosted
+/// @param[inout] out_cloud_anchor The new cloud anchor
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_NOT_TRACKING
+/// - #AR_ERROR_SESSION_PAUSED
+/// - #AR_ERROR_CLOUD_ANCHORS_NOT_CONFIGURED
+/// - #AR_ERROR_RESOURCE_EXHAUSTED
+/// - #AR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_HOSTING
+ArStatus ArSession_hostAndAcquireNewCloudAnchor(ArSession *session,
+                                                const ArAnchor *anchor,
+                                                ArAnchor **out_cloud_anchor);
+
+/// This will create a new cloud anchor, and schedule a resolving task to
+/// resolve the anchor's pose using the given cloud anchor ID.
+///
+/// If this function returns #AR_SUCCESS, the cloud state of @c out_cloud_anchor
+/// will be #AR_CLOUD_STATE_TASK_IN_PROGRESS, and its tracking state will be
+/// #AR_TRACKING_STATE_PAUSED. This anchor will never start tracking until its
+/// pose has been successfully resolved. If the resolving task ends in an error,
+/// the tracking state will be set to #AR_TRACKING_STATE_STOPPED. If the return
+/// value is not #AR_SUCCESS, then @c out_cloud_anchor will be set to null.
+///
+/// @param[in]    session          The ARCore session
+/// @param[in]    cloud_anchor_id  The cloud ID of the anchor to be resolved
+/// @param[inout] out_cloud_anchor The new cloud anchor
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_NOT_TRACKING
+/// - #AR_ERROR_SESSION_PAUSED
+/// - #AR_ERROR_CLOUD_ANCHORS_NOT_CONFIGURED
+/// - #AR_ERROR_RESOURCE_EXHAUSTED
+ArStatus ArSession_resolveAndAcquireNewCloudAnchor(ArSession *session,
+                                                   const char *cloud_anchor_id,
+                                                   ArAnchor **out_cloud_anchor);
+
+/// @}
+
+// === ArPose methods ===
+
+/// @addtogroup pose
+/// @{
+
+/// Allocates and initializes a new pose object.  @c pose_raw points to an array
+/// of 7 floats, describing the rotation (quaternion) and translation of the
+/// pose in the same order as the first 7 elements of the Android
+/// @c Sensor.TYPE_POSE_6DOF values documented on <a
+/// href="https://developer.android.com/reference/android/hardware/SensorEvent.html#values"
+/// >@c SensorEvent.values() </a>
+///
+/// The order of the values is: qx, qy, qz, qw, tx, ty, tz.
+///
+/// If @c pose_raw is null, initializes with the identity pose.
+void ArPose_create(const ArSession *session,
+                   const float *pose_raw,
+                   ArPose **out_pose);
+
+/// Releases memory used by a pose object.
+void ArPose_destroy(ArPose *pose);
+
+/// Extracts the quaternion rotation and translation from a pose object.
+/// @param[in]  session       The ARCore session
+/// @param[in]  pose          The pose to extract
+/// @param[out] out_pose_raw  Pointer to an array of 7 floats, to be filled with
+///     the quaternion rotation and translation as described in ArPose_create().
+void ArPose_getPoseRaw(const ArSession *session,
+                       const ArPose *pose,
+                       float *out_pose_raw);
+
+/// Converts a pose into a 4x4 transformation matrix.
+/// @param[in]  session                  The ARCore session
+/// @param[in]  pose                     The pose to convert
+/// @param[out] out_matrix_col_major_4x4 Pointer to an array of 16 floats, to be
+///     filled with a column-major homogenous transformation matrix, as used by
+///     OpenGL.
+void ArPose_getMatrix(const ArSession *session,
+                      const ArPose *pose,
+                      float *out_matrix_col_major_4x4);
+
+/// @}
+
+// === ArCamera methods ===
+
+/// @addtogroup camera
+/// @{
+
+/// Sets @c out_pose to the pose of the user's device in the world coordinate
+/// space at the time of capture of the current camera texture. The position and
+/// orientation of the pose follow the device's physical camera (they are not
+/// affected by display orientation) and uses OpenGL camera conventions (+X
+/// right, +Y up, -Z in the direction the camera is looking).
+///
+/// Note: This pose is only useful when ArCamera_getTrackingState() returns
+/// #AR_TRACKING_STATE_TRACKING and otherwise should not be used.
+///
+/// @param[in]    session  The ARCore session
+/// @param[in]    camera   The session's camera (retrieved from any frame).
+/// @param[inout] out_pose An already-allocated ArPose object into which the
+///     pose will be stored.
+void ArCamera_getPose(const ArSession *session,
+                      const ArCamera *camera,
+                      ArPose *out_pose);
+
+/// Sets @c out_pose to the pose of the user's device in the world coordinate
+/// space at the time of capture of the current camera texture. The position of
+/// the pose is located at the device's camera, while the orientation
+/// approximately matches the orientation of the display (considering display
+/// rotation), using OpenGL camera conventions (+X right, +Y up, -Z in the
+/// direction the camera is looking).
+///
+/// Note: This pose is only useful when ArCamera_getTrackingState() returns
+/// #AR_TRACKING_STATE_TRACKING and otherwise should not be used.
+///
+/// See also: ArCamera_getViewMatrix()
+///
+/// @param[in]    session  The ARCore session
+/// @param[in]    camera   The session's camera (retrieved from any frame).
+/// @param[inout] out_pose An already-allocated ArPose object into which the
+///     pose will be stored.
+void ArCamera_getDisplayOrientedPose(const ArSession *session,
+                                     const ArCamera *camera,
+                                     ArPose *out_pose);
+
+/// Returns the view matrix for the camera for this frame. This matrix performs
+/// the inverse transfrom as the pose provided by
+/// ArCamera_getDisplayOrientedPose().
+///
+/// @param[in]    session           The ARCore session
+/// @param[in]    camera            The session's camera.
+/// @param[inout] out_col_major_4x4 Pointer to an array of 16 floats, to be
+///     filled with a column-major homogenous transformation matrix, as used by
+///     OpenGL.
+void ArCamera_getViewMatrix(const ArSession *session,
+                            const ArCamera *camera,
+                            float *out_col_major_4x4);
+
+/// Gets the current state of the pose of this camera. If this state is anything
+/// other than #AR_TRACKING_STATE_TRACKING the Camera's pose should not be
+/// considered useful.
+void ArCamera_getTrackingState(const ArSession *session,
+                               const ArCamera *camera,
+                               ArTrackingState *out_tracking_state);
+
+/// Computes a projection matrix for rendering virtual content on top of the
+/// camera image. Note that the projection matrix reflects the current display
+/// geometry and display rotation.
+///
+/// @param[in]    session            The ARCore session
+/// @param[in]    camera             The session's camera.
+/// @param[in]    near               Specifies the near clip plane, in meters
+/// @param[in]    far                Specifies the far clip plane, in meters
+/// @param[inout] dest_col_major_4x4 Pointer to an array of 16 floats, to
+///     be filled with a column-major homogenous transformation matrix, as used
+///     by OpenGL.
+void ArCamera_getProjectionMatrix(const ArSession *session,
+                                  const ArCamera *camera,
+                                  float near,
+                                  float far,
+                                  float *dest_col_major_4x4);
+
+/// Releases a reference to the camera.  This must match a call to
+/// ArFrame_acquireCamera().
+///
+/// This method may safely be called with @c nullptr - it will do nothing.
+void ArCamera_release(ArCamera *camera);
+
+/// @}
+
+// === ArFrame methods ===
+
+/// @addtogroup frame
+/// @{
+
+/// Allocates a new ArFrame object, storing the pointer into @c *out_frame.
+///
+/// Note: the same ArFrame can be used repeatedly when calling ArSession_update.
+void ArFrame_create(const ArSession *session, ArFrame **out_frame);
+
+/// Releases an ArFrame and any references it holds.
+void ArFrame_destroy(ArFrame *frame);
+
+/// Checks if the display rotation or viewport geometry changed since the
+/// previous call to ArSession_update(). The application should re-query
+/// ArCamera_getProjectionMatrix() and ArFrame_transformDisplayUvCoords()
+/// whenever this emits non-zero.
+void ArFrame_getDisplayGeometryChanged(const ArSession *session,
+                                       const ArFrame *frame,
+                                       int32_t *out_geometry_changed);
+
+/// Returns the timestamp in nanoseconds when this image was captured. This can
+/// be used to detect dropped frames or measure the camera frame rate. The time
+/// base of this value is specifically <b>not</b> defined, but it is likely
+/// similar to <tt>clock_gettime(CLOCK_BOOTTIME)</tt>.
+void ArFrame_getTimestamp(const ArSession *session,
+                          const ArFrame *frame,
+                          int64_t *out_timestamp_ns);
+
+/// Transform the given texture coordinates to correctly show the background
+/// image. This will account for the display rotation, and any additional
+/// required adjustment. For performance, this function should be called only if
+/// ArFrame_hasDisplayGeometryChanged() emits true.
+///
+/// @param[in]    session      The ARCore session
+/// @param[in]    frame        The current frame.
+/// @param[in]    num_elements The number of floats to transform.  Must be
+///     a multiple of 2.  @c uvs_in and @c uvs_out must point to arrays of at
+///     least this many floats.
+/// @param[in]    uvs_in       Input UV coordinates in normalized screen space.
+/// @param[inout] uvs_out      Output UV coordinates in texture coordinates.
+void ArFrame_transformDisplayUvCoords(const ArSession *session,
+                                      const ArFrame *frame,
+                                      int32_t num_elements,
+                                      const float *uvs_in,
+                                      float *uvs_out);
+
+/// Performs a ray cast from the user's device in the direction of the given
+/// location in the camera view. Intersections with detected scene geometry are
+/// returned, sorted by distance from the device; the nearest intersection is
+/// returned first.
+///
+/// Note: Significant geometric leeway is given when returning hit results. For
+/// example, a plane hit may be generated if the ray came close, but did not
+/// actually hit within the plane extents or plane bounds
+/// (ArPlane_isPoseInExtents() and ArPlane_isPoseInPolygon() can be used to
+/// determine these cases). A point (point cloud) hit is generated when a point
+/// is roughly within one finger-width of the provided screen coordinates.
+///
+/// The resulting list is ordered by distance, with the nearest hit first
+///
+/// Note: If not tracking, the hit_result_list will be empty. <br>
+/// Note: If called on an old frame (not the latest produced by
+///     ArSession_update() the hit_result_list will be empty).
+///
+/// @param[in]    session         The ARCore session.
+/// @param[in]    frame           The current frame.
+/// @param[in]    pixel_x         Logical X position within the view, as from an
+///     Android UI event.
+/// @param[in]    pixel_y         Logical X position within the view.
+/// @param[inout] hit_result_list The list to fill.  This list must have been
+///     previously allocated using ArHitResultList_create().  If the list has
+///     been previously used, it will first be cleared.
+void ArFrame_hitTest(const ArSession *session,
+                     const ArFrame *frame,
+                     float pixel_x,
+                     float pixel_y,
+                     ArHitResultList *hit_result_list);
+
+/// Gets the current ambient light estimate, if light estimation was enabled.
+///
+/// @param[in]    session            The ARCore session.
+/// @param[in]    frame              The current frame.
+/// @param[inout] out_light_estimate The light estimate to fill.  This object
+///    must have been previously created with ArLightEstimate_create().
+void ArFrame_getLightEstimate(const ArSession *session,
+                              const ArFrame *frame,
+                              ArLightEstimate *out_light_estimate);
+
+/// Acquires the current set of estimated 3d points attached to real-world
+/// geometry. A matching call to PointCloud_release() must be made when the
+/// application is done accessing the point cloud.
+///
+/// Note: This information is for visualization and debugging purposes only. Its
+/// characteristics and format are subject to change in subsequent versions of
+/// the API.
+///
+/// @param[in]  session         The ARCore session.
+/// @param[in]  frame           The current frame.
+/// @param[out] out_point_cloud Pointer to an @c ArPointCloud* receive the
+///     address of the point cloud.
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_DEADLINE_EXCEEDED if @c frame is not the latest frame from
+///   by ArSession_update().
+/// - #AR_ERROR_RESOURCE_EXHAUSTED if too many point clouds are currently held.
+ArStatus ArFrame_acquirePointCloud(const ArSession *session,
+                                   const ArFrame *frame,
+                                   ArPointCloud **out_point_cloud);
+
+/// Returns the camera object for the session. Note that this Camera instance is
+/// long-lived so the same instance is returned regardless of the frame object
+/// this method was called on.
+void ArFrame_acquireCamera(const ArSession *session,
+                           const ArFrame *frame,
+                           ArCamera **out_camera);
+
+/// Gets the camera metadata for the current camera image.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_DEADLINE_EXCEEDED if @c frame is not the latest frame from
+///   by ArSession_update().
+/// - #AR_ERROR_RESOURCE_EXHAUSTED if too many metadata objects are currently
+///   held.
+/// - #AR_ERROR_NOT_YET_AVAILABLE if the camera failed to produce metadata for
+///   the given frame. Note: this will commonly happen for few frames right
+///   after @c ArSession_resume() due to the camera stack bringup.
+ArStatus ArFrame_acquireImageMetadata(const ArSession *session,
+                                      const ArFrame *frame,
+                                      ArImageMetadata **out_metadata);
+
+/// Gets the set of anchors that were changed by the ArSession_update() that
+/// produced this Frame.
+///
+/// @param[in]    session            The ARCore session
+/// @param[in]    frame              The current frame.
+/// @param[inout] out_anchor_list The list to fill.  This list must have
+///     already been allocated with ArAnchorList_create().  If previously
+///     used, the list will first be cleared.
+void ArFrame_getUpdatedAnchors(const ArSession *session,
+                               const ArFrame *frame,
+                               ArAnchorList *out_anchor_list);
+
+/// Gets the set of trackables of a particular type that were changed by the
+/// ArSession_update() call that produced this Frame.
+///
+/// @param[in]    session            The ARCore session
+/// @param[in]    frame              The current frame.
+/// @param[in]    filter_type        The type(s) of trackables to return.  See
+///     ::ArTrackableType for legal values.
+/// @param[inout] out_trackable_list The list to fill.  This list must have
+///     already been allocated with ArTrackableList_create().  If previously
+///     used, the list will first be cleared.
+void ArFrame_getUpdatedTrackables(const ArSession *session,
+                                  const ArFrame *frame,
+                                  ArTrackableType filter_type,
+                                  ArTrackableList *out_trackable_list);
+/// @}
+
+// === ArPointCloud methods ===
+
+/// @addtogroup pointcloud
+/// @{
+
+/// Retrieves the number of points in the point cloud.
+///
+void ArPointCloud_getNumberOfPoints(const ArSession *session,
+                                    const ArPointCloud *point_cloud,
+                                    int32_t *out_number_of_points);
+
+/// Retrieves a pointer to the point cloud data.
+///
+/// Each point is represented by four consecutive values in the array; first the
+/// X, Y, Z position coordinates, followed by a confidence value. This is the
+/// same format as described in <a
+/// href="https://developer.android.com/reference/android/graphics/ImageFormat.html#DEPTH_POINT_CLOUD"
+/// >DEPTH_POINT_CLOUD</a>.
+///
+/// The pointer returned by this function is valid until ArPointCloud_release()
+/// is called. The application must copy the data if they wish to retain it for
+/// longer. The points are in world coordinates consistent with the frame it was
+/// obtained from. If the number of points is zero, then the value of
+/// @c *out_point_cloud_data should is undefined.
+void ArPointCloud_getData(const ArSession *session,
+                          const ArPointCloud *point_cloud,
+                          const float **out_point_cloud_data);
+
+/// Returns the timestamp in nanoseconds when this point cloud was observed.
+/// This timestamp uses the same time base as ArFrame_getTimestamp().
+void ArPointCloud_getTimestamp(const ArSession *session,
+                               const ArPointCloud *point_cloud,
+                               int64_t *out_timestamp_ns);
+
+/// Releases a reference to the point cloud.  This must match a call to
+/// ArFrame_acquirePointCloud().
+///
+/// This method may safely be called with @c nullptr - it will do nothing.
+void ArPointCloud_release(ArPointCloud *point_cloud);
+
+/// @}
+
+// === Image Metadata methods ===
+
+/// @addtogroup image
+/// @{
+
+/// Retrieves the capture metadata for the current camera image.
+///
+/// @c ACameraMetadata is a struct in Android NDK. Include NdkCameraMetadata.h
+/// to use this type.
+///
+/// Note: that the ACameraMetadata returned from this function will be invalid
+/// after its ArImageMetadata object is released.
+void ArImageMetadata_getNdkCameraMetadata(
+    const ArSession *session,
+    const ArImageMetadata *image_metadata,
+    const ACameraMetadata **out_ndk_metadata);
+
+/// Releases a reference to the metadata.  This must match a call to
+/// ArFrame_acquireImageMetadata().
+///
+/// This method may safely be called with @c nullptr - it will do nothing.
+void ArImageMetadata_release(ArImageMetadata *metadata);
+
+// === CPU Image Access types and methods ===
+/// Gets the image of the tracking camera relative to the input session and
+/// frame.
+/// Return values:
+/// @returns #AR_SUCCESS or any of:
+/// - #AR_ERROR_INVALID_ARGUMENT - one more input arguments are invalid.
+/// - #AR_ERROR_DEADLINE_EXCEEDED - the input frame is not the current frame.
+/// - #AR_ERROR_RESOURCE_EXHAUSTED - the caller app has exceeded maximum number
+///   of images that it can hold without releasing.
+/// - #AR_ERROR_NOT_YET_AVAILABLE - image with the timestamp of the input frame
+///   was not found within a bounded amount of time, or the camera failed to
+///   produce the image
+ArStatus ArFrame_acquireCameraImage(ArSession *session,
+                                    ArFrame *frame,
+                                    ArImage **out_image);
+
+/// Converts an ArImage object to an Android NDK AImage object.
+void ArImage_getNdkImage(const ArImage *image, const AImage **out_ndk_image);
+
+/// Releases an instance of ArImage returned by ArFrame_acquireCameraImage().
+void ArImage_release(ArImage *image);
+/// @}
+
+// === ArLightEstimate methods ===
+
+/// @addtogroup light
+/// @{
+
+/// Allocates a light estimate object.
+void ArLightEstimate_create(const ArSession *session,
+                            ArLightEstimate **out_light_estimate);
+
+/// Releases the provided light estimate object.
+void ArLightEstimate_destroy(ArLightEstimate *light_estimate);
+
+/// Retrieves the validity state of a light estimate.  If the resulting value of
+/// @c *out_light_estimate_state is not #AR_LIGHT_ESTIMATE_STATE_VALID, the
+/// estimate should not be used for rendering.
+void ArLightEstimate_getState(const ArSession *session,
+                              const ArLightEstimate *light_estimate,
+                              ArLightEstimateState *out_light_estimate_state);
+
+/// Retrieves the pixel intensity, in gamma space, of the current camera view.
+/// Values are in the range (0.0, 1.0), with zero being black and one being
+/// white.
+/// If rendering in gamma space, divide this value by 0.466, which is middle
+/// gray in gamma space, and multiply against the final calculated color after
+/// rendering.
+/// If rendering in linear space, first convert this value to linear space by
+/// rising to the power 2.2. Normalize the result by dividing it by 0.18 which
+/// is middle gray in linear space. Then multiply by the final calculated color
+/// after rendering.
+void ArLightEstimate_getPixelIntensity(const ArSession *session,
+                                       const ArLightEstimate *light_estimate,
+                                       float *out_pixel_intensity);
+
+/// Gets the color correction values that are uploaded to the fragment shader.
+/// Use the RGB scale factors (components 0-2) to match the color of the light
+/// in the scene. Use the pixel intensity (component 3) to match the intensity
+/// of the light in the scene.
+///
+/// `out_color_correction_4` components are:
+///   - `[0]` Red channel scale factor.
+///   - `[1]` Green channel scale factor.
+///   - `[2]` Blue channel scale factor.
+///   - `[3]` Pixel intensity. This is the same value as the one return from
+///       ArLightEstimate_getPixelIntensity().
+///
+///  The RGB scale factors can be used independently from the pixel intensity
+///  value. They are put together for the convenience of only having to upload
+///  one float4 to the fragment shader.
+///
+///  The RGB scale factors are not intended to brighten nor dim the scene.  They
+///  are only to shift the color of the virtual object towards the color of the
+///  light; not intensity of the light. The pixel intensity is used to match the
+///  intensity of the light in the scene.
+///
+///  Color correction values are reported in gamma space.
+///  If rendering in gamma space, component-wise multiply them against the final
+///  calculated color after rendering.
+///  If rendering in linear space, first convert the values to linear space by
+///  rising to the power 2.2. Then component-wise multiply against the final
+///  calculated color after rendering.
+void ArLightEstimate_getColorCorrection(const ArSession *session,
+                                        const ArLightEstimate *light_estimate,
+                                        float *out_color_correction_4);
+
+/// @}
+
+// === ArAnchorList methods ===
+
+/// @addtogroup anchor
+/// @{
+
+/// Creates an anchor list object.
+void ArAnchorList_create(const ArSession *session,
+                         ArAnchorList **out_anchor_list);
+
+/// Releases the memory used by an anchor list object, along with all the anchor
+/// references it holds.
+void ArAnchorList_destroy(ArAnchorList *anchor_list);
+
+/// Retrieves the number of anchors in this list.
+void ArAnchorList_getSize(const ArSession *session,
+                          const ArAnchorList *anchor_list,
+                          int32_t *out_size);
+
+/// Acquires a reference to an indexed entry in the list.  This call must
+/// eventually be matched with a call to ArAnchor_release().
+void ArAnchorList_acquireItem(const ArSession *session,
+                              const ArAnchorList *anchor_list,
+                              int32_t index,
+                              ArAnchor **out_anchor);
+
+// === ArAnchor methods ===
+
+/// Retrieves the pose of the anchor in the world coordinate space. This pose
+/// produced by this call may change each time ArSession_update() is called.
+/// This pose should only be used for rendering if ArAnchor_getTrackingState()
+/// returns #AR_TRACKING_STATE_TRACKING.
+///
+/// @param[in]    session  The ARCore session.
+/// @param[in]    anchor   The anchor to retrieve the pose of.
+/// @param[inout] out_pose An already-allocated ArPose object into which the
+///     pose will be stored.
+void ArAnchor_getPose(const ArSession *session,
+                      const ArAnchor *anchor,
+                      ArPose *out_pose);
+
+/// Retrieves the current state of the pose of this anchor.
+void ArAnchor_getTrackingState(const ArSession *session,
+                               const ArAnchor *anchor,
+                               ArTrackingState *out_tracking_state);
+
+/// Tells ARCore to stop tracking and forget this anchor.  This call does not
+/// release the reference to the anchor - that must be done separately using
+/// ArAnchor_release().
+void ArAnchor_detach(ArSession *session, ArAnchor *anchor);
+
+/// Releases a reference to an anchor. This does not mean that the anchor will
+/// stop tracking, as it will be obtainable from e.g. ArSession_getAllAnchors()
+/// if any other references exist.
+///
+/// This method may safely be called with @c nullptr - it will do nothing.
+void ArAnchor_release(ArAnchor *anchor);
+
+/// Acquires the cloud anchor ID of the anchor. The ID acquired is an ASCII
+/// null-terminated string. The acquired ID must be released after use by the
+/// @c ArString_release function. For anchors with cloud state
+/// #AR_CLOUD_ANCHOR_STATE_NONE or #AR_CLOUD_ANCHOR_STATE_TASK_IN_PROGRESS, this
+/// will always be an empty string.
+///
+/// @param[in]    session             The ARCore session.
+/// @param[in]    anchor              The anchor to retrieve the cloud ID of.
+/// @param[inout] out_cloud_anchor_id A pointer to the acquired ID string.
+void ArAnchor_acquireCloudAnchorId(ArSession *session,
+                                   ArAnchor *anchor,
+                                   char **out_cloud_anchor_id);
+
+/// Gets the current cloud anchor state of the anchor. This state is guaranteed
+/// not to change until update() is called.
+///
+/// @param[in]    session   The ARCore session.
+/// @param[in]    anchor    The anchor to retrieve the cloud state of.
+/// @param[inout] out_state The current cloud state of the anchor.
+void ArAnchor_getCloudAnchorState(const ArSession *session,
+                                  const ArAnchor *anchor,
+                                  ArCloudAnchorState *out_state);
+
+/// @}
+
+// === ArTrackableList methods ===
+
+/// @addtogroup trackable
+/// @{
+
+/// Creates a trackable list object.
+void ArTrackableList_create(const ArSession *session,
+                            ArTrackableList **out_trackable_list);
+
+/// Releases the memory used by a trackable list object, along with all the
+/// anchor references it holds.
+void ArTrackableList_destroy(ArTrackableList *trackable_list);
+
+/// Retrieves the number of trackables in this list.
+void ArTrackableList_getSize(const ArSession *session,
+                             const ArTrackableList *trackable_list,
+                             int32_t *out_size);
+
+/// Acquires a reference to an indexed entry in the list.  This call must
+/// eventually be matched with a call to ArTrackable_release().
+void ArTrackableList_acquireItem(const ArSession *session,
+                                 const ArTrackableList *trackable_list,
+                                 int32_t index,
+                                 ArTrackable **out_trackable);
+
+// === ArTrackable methods ===
+
+/// Releases a reference to a trackable. This does not mean that the trackable
+/// will necessarily stop tracking. The same trackable may still be included in
+/// from other calls, for example ArSession_getAllTrackables().
+///
+/// This method may safely be called with @c nullptr - it will do nothing.
+void ArTrackable_release(ArTrackable *trackable);
+
+/// Retrieves the type of the trackable.  See ::ArTrackableType for valid types.
+void ArTrackable_getType(const ArSession *session,
+                         const ArTrackable *trackable,
+                         ArTrackableType *out_trackable_type);
+
+/// Retrieves the current state of ARCore's knowledge of the pose of this
+/// trackable.
+void ArTrackable_getTrackingState(const ArSession *session,
+                                  const ArTrackable *trackable,
+                                  ArTrackingState *out_tracking_state);
+
+/// Creates an Anchor at the given pose in the world coordinate space, attached
+/// to this Trackable, and acquires a reference to it. The type of Trackable
+/// will determine the semantics of attachment and how the Anchor's pose will be
+/// updated to maintain this relationship. Note that the relative offset between
+/// the pose of multiple Anchors attached to a Trackable may adjust slightly
+/// over time as ARCore updates its model of the world.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_NOT_TRACKING if the trackable's tracking state was not
+///   #AR_TRACKING_STATE_TRACKING
+/// - #AR_ERROR_SESSION_PAUSED if the session was paused
+/// - #AR_ERROR_RESOURCE_EXHAUSTED if too many anchors exist
+ArStatus ArTrackable_acquireNewAnchor(ArSession *session,
+                                      ArTrackable *trackable,
+                                      ArPose *pose,
+                                      ArAnchor **out_anchor);
+
+/// Gets the set of anchors attached to this trackable.
+///
+/// @param[in]    session         The ARCore session
+/// @param[in]    trackable       The trackable to query the anchors of.
+/// @param[inout] out_anchor_list The list to fill.  This list must have
+///     already been allocated with ArAnchorList_create().  If previously
+///     used, the list will first be cleared.
+void ArTrackable_getAnchors(const ArSession *session,
+                            const ArTrackable *trackable,
+                            ArAnchorList *out_anchor_list);
+
+/// @}
+
+// === ArPlane methods ===
+
+/// @addtogroup plane
+/// @{
+
+/// Acquires a reference to the plane subsuming this plane.
+///
+/// Two or more planes may be automatically merged into a single parent plane,
+/// resulting in this method acquiring the parent plane when called with each
+/// child plane. A subsumed plane becomes identical to the parent plane, and
+/// will continue behaving as if it were independently tracked, for example
+/// being included in the output of ArFrame_getUpdatedTrackables().
+///
+/// In cases where a subsuming plane is itself subsumed, this function
+/// will always return the topmost non-subsumed plane.
+///
+/// Note: this function will set @c *out_subsumed_by to NULL if the plane is not
+/// subsumed.
+void ArPlane_acquireSubsumedBy(const ArSession *session,
+                               const ArPlane *plane,
+                               ArPlane **out_subsumed_by);
+
+/// Retrieves the type (orientation) of the plane.  See ::ArPlaneType.
+void ArPlane_getType(const ArSession *session,
+                     const ArPlane *plane,
+                     ArPlaneType *out_plane_type);
+
+/// Returns the pose of the center of the detected plane. The pose's transformed
+/// +Y axis will be point normal out of the plane, with the +X and +Z axes
+/// orienting the extents of the bounding rectangle.
+///
+/// @param[in]    session  The ARCore session.
+/// @param[in]    plane    The plane for which to retrieve center pose.
+/// @param[inout] out_pose An already-allocated ArPose object into which the
+///     pose will be stored.
+void ArPlane_getCenterPose(const ArSession *session,
+                           const ArPlane *plane,
+                           ArPose *out_pose);
+
+/// Retrieves the length of this plane's bounding rectangle measured along the
+/// local X-axis of the coordinate space defined by the output of
+/// ArPlane_getCenterPose().
+void ArPlane_getExtentX(const ArSession *session,
+                        const ArPlane *plane,
+                        float *out_extent_x);
+
+/// Retrieves the length of this plane's bounding rectangle measured along the
+/// local Z-axis of the coordinate space defined by the output of
+/// ArPlane_getCenterPose().
+void ArPlane_getExtentZ(const ArSession *session,
+                        const ArPlane *plane,
+                        float *out_extent_z);
+
+/// Retrieves the number of elements (not vertices) in the boundary polygon.
+/// The number of vertices is 1/2 this size.
+void ArPlane_getPolygonSize(const ArSession *session,
+                            const ArPlane *plane,
+                            int32_t *out_polygon_size);
+
+/// Returns the 2D vertices of a convex polygon approximating the detected
+/// plane, in the form <tt>[x1, z1, x2, z2, ...]</tt>. These X-Z values are in
+/// the plane's local x-z plane (y=0) and must be transformed by the pose
+/// (ArPlane_getCenterPose()) to get the boundary in world coordinates.
+///
+/// @param[in]    session        The ARCore session.
+/// @param[in]    plane          The plane to retrieve the polygon from.
+/// @param[inout] out_polygon_xz A pointer to an array of floats.  The length of
+///     this array must be at least that reported by ArPlane_getPolygonSize().
+void ArPlane_getPolygon(const ArSession *session,
+                        const ArPlane *plane,
+                        float *out_polygon_xz);
+
+/// Sets @c *out_pose_in_extents to non-zero if the given pose (usually obtained
+/// from a HitResult) is in the plane's rectangular extents.
+void ArPlane_isPoseInExtents(const ArSession *session,
+                             const ArPlane *plane,
+                             const ArPose *pose,
+                             int32_t *out_pose_in_extents);
+
+/// Sets @c *out_pose_in_extents to non-zero if the given pose (usually obtained
+/// from a HitResult) is in the plane's polygon.
+void ArPlane_isPoseInPolygon(const ArSession *session,
+                             const ArPlane *plane,
+                             const ArPose *pose,
+                             int32_t *out_pose_in_polygon);
+
+/// @}
+
+// === ArPoint methods ===
+
+/// @addtogroup point
+/// @{
+
+/// Returns the pose of the point.
+/// If ArPoint_getOrientationMode() returns ESTIMATED_SURFACE_NORMAL, the
+/// orientation will follow the behavior described in ArHitResult_getHitPose().
+/// If ArPoint_getOrientationMode() returns INITIALIZED_TO_IDENTITY, then
+/// returns an orientation that is identity or close to identity.
+/// @param[in]    session  The ARCore session.
+/// @param[in]    point    The point to retrieve the pose of.
+/// @param[inout] out_pose An already-allocated ArPose object into which the
+/// pose will be stored.
+void ArPoint_getPose(const ArSession *session,
+                     const ArPoint *point,
+                     ArPose *out_pose);
+
+/// Returns the OrientationMode of the point. For @c Point objects created by
+/// ArFrame_hitTest().
+/// If OrientationMode is ESTIMATED_SURFACE_NORMAL, then normal of the surface
+/// centered around the ArPoint was estimated succesfully.
+///
+/// @param[in]    session              The ARCore session.
+/// @param[in]    point                The point to retrieve the pose of.
+/// @param[inout] out_orientation_mode OrientationMode output result for the
+///     the point.
+void ArPoint_getOrientationMode(const ArSession *session,
+                                const ArPoint *point,
+                                ArPointOrientationMode *out_orientation_mode);
+
+/// @}
+
+// === ArAugmentedImage methods ===
+
+/// @addtogroup augmented_image
+/// @{
+
+/// Returns the pose of the center of the detected image. The pose's
+/// transformed +Y axis will be point normal out of the image.
+///
+/// If the tracking state is PAUSED/STOPPED, this returns the pose when the
+/// image state was last TRACKING, or the identity pose if the image state has
+/// never been TRACKING.
+void ArAugmentedImage_getCenterPose(const ArSession *session,
+                                    const ArAugmentedImage *augmented_image,
+                                    ArPose *out_pose);
+
+/// Retrieves the estimated width, in metres, of the corresponding physical
+/// image, as measured along the local X-axis of the coordinate space with
+/// origin and axes as defined by ArAugmentedImage_getCenterPose().
+///
+/// ARCore will attempt to estimate the physical image's width and continuously
+/// update this estimate based on its understanding of the world. If the
+/// optional physical size is specified in the image database, this estimation
+/// process will happen more quickly. However, the estimated size may be
+/// different from the originally specified size.
+///
+/// If the tracking state is PAUSED/STOPPED, this returns the estimated width
+/// when the image state was last TRACKING. If the image state has never been
+/// TRACKING, this returns 0, even the image has a specified physical size in
+/// the image database.
+void ArAugmentedImage_getExtentX(const ArSession *session,
+                                 const ArAugmentedImage *augmented_image,
+                                 float *out_extent_x);
+
+/// Retrieves the estimated height, in metres, of the corresponding physical
+/// image, as measured along the local Z-axis of the coordinate space with
+/// origin and axes as defined by ArAugmentedImage_getCenterPose().
+///
+/// ARCore will attempt to estimate the physical image's height and continuously
+/// update this estimate based on its understanding of the world. If an optional
+/// physical size is specified in the image database, this estimation process
+/// will happen more quickly. However, the estimated size may be different from
+/// the originally specified size.
+///
+/// If the tracking state is PAUSED/STOPPED, this returns the estimated height
+/// when the image state was last TRACKING. If the image state has never been
+/// TRACKING, this returns 0, even the image has a specified physical size in
+/// the image database.
+void ArAugmentedImage_getExtentZ(const ArSession *session,
+                                 const ArAugmentedImage *augmented_image,
+                                 float *out_extent_z);
+
+/// Returns the zero-based positional index of this image from its originating
+/// image database.
+///
+/// This index serves as the unique identifier for the image in the database.
+void ArAugmentedImage_getIndex(const ArSession *session,
+                               const ArAugmentedImage *augmented_image,
+                               int32_t *out_index);
+
+/// Returns the name of this image.
+///
+/// The image name is not guaranteed to be unique.
+///
+/// This function will allocate memory for the name string, and set
+/// *out_augmented_image_name to point to that string. The caller must release
+/// the string using ArString_release when the string is no longer needed.
+void ArAugmentedImage_acquireName(const ArSession *session,
+                                  const ArAugmentedImage *augmented_image,
+                                  char **out_augmented_image_name);
+
+/// @}
+
+// === ArAugmentedImageDatabase methods ===
+
+/// @addtogroup augmented_image_database
+/// @{
+
+/// Creates a new empty image database.
+void ArAugmentedImageDatabase_create(
+    const ArSession *session,
+    ArAugmentedImageDatabase **out_augmented_image_database);
+
+/// Creates a new image database from a byte array. The contents of the byte
+/// array must have been generated by the command-line database generation tool
+/// provided in the SDK, or at runtime from ArAugmentedImageDatabase_serialize.
+///
+/// Note: this function takes about 10-20ms for a 5MB byte array. Run this in a
+/// background thread if this affects your application.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_DATA_INVALID_FORMAT - the bytes are in an invalid format.
+/// - #AR_ERROR_DATA_UNSUPPORTED_VERSION - the database is not supported by
+///   this version of the SDK.
+ArStatus ArAugmentedImageDatabase_deserialize(
+    const ArSession *session,
+    const uint8_t *database_raw_bytes,
+    int64_t database_raw_bytes_size,
+    ArAugmentedImageDatabase **out_augmented_image_database);
+
+/// Serializes an image database to a byte array.
+///
+/// This function will allocate memory for the serialized raw byte array, and
+/// set *out_image_database_raw_bytes to point to that byte array. The caller is
+/// expected to release the byte array using ArByteArray_release when the byte
+/// array is no longer needed.
+void ArAugmentedImageDatabase_serialize(
+    const ArSession *session,
+    const ArAugmentedImageDatabase *augmented_image_database,
+    uint8_t **out_image_database_raw_bytes,
+    int64_t *out_image_database_raw_bytes_size);
+
+/// Adds a single named image of unknown physical size to an image database,
+/// from an array of grayscale pixel values. Returns the zero-based positional
+/// index of the image within the image database.
+///
+/// If the physical size of the image is known, use
+/// ArAugmentedImageDatabase_addImageWithPhysicalSize instead, to improve image
+/// detection time.
+///
+/// For images added via ArAugmentedImageDatabase_addImage, ARCore estimates the
+/// physical image's size and pose at runtime when the physical image is visible
+/// and is being tracked. This extra estimation step will require the user to
+/// move their device to view the physical image from different viewpoints
+/// before the size and pose of the physical image can be estimated.
+///
+/// This function takes time to perform non-trivial image processing (20ms -
+/// 30ms), and should be run on a background thread.
+///
+/// The image name is expected to be a null-terminated string in UTF-8 format.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_IMAGE_INSUFFICIENT_QUALITY - image quality is insufficient, e.g.
+///   because of lack of features in the image.
+ArStatus ArAugmentedImageDatabase_addImage(
+    const ArSession *session,
+    ArAugmentedImageDatabase *augmented_image_database,
+    const char *image_name,
+    const uint8_t *image_grayscale_pixels,
+    int32_t image_width_in_pixels,
+    int32_t image_height_in_pixels,
+    int32_t image_stride_in_pixels,
+    int32_t *out_index);
+
+/// Adds a single named image to an image database, from an array of grayscale
+/// pixel values, along with a positive physical width in meters for this image.
+/// Returns the zero-based positional index of the image within the image
+/// database.
+///
+/// If the physical size of the image is not known, use
+/// ArAugmentedImageDatabase_addImage instead, at the expense of an increased
+/// image detection time.
+///
+/// For images added via ArAugmentedImageDatabase_addImageWithPhysicalSize,
+/// ARCore can estimate the pose of the physical image at runtime as soon as
+/// ARCore detects the physical image, without requiring the user to move the
+/// device to view the physical image from different viewpoints. Note that
+/// ARCore will refine the estimated size and pose of the physical image as it
+/// is viewed from different viewpoints.
+///
+/// This function takes time to perform non-trivial image processing (20ms -
+/// 30ms), and should be run on a background thread.
+///
+/// The image name is expected to be a null-terminated string in UTF-8 format.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_IMAGE_INSUFFICIENT_QUALITY - image quality is insufficient, e.g.
+///   because of lack of features in the image.
+/// - #AR_ERROR_INVALID_ARGUMENT - image_width_in_meters is <= 0.
+ArStatus ArAugmentedImageDatabase_addImageWithPhysicalSize(
+    const ArSession *session,
+    ArAugmentedImageDatabase *augmented_image_database,
+    const char *image_name,
+    const uint8_t *image_grayscale_pixels,
+    int32_t image_width_in_pixels,
+    int32_t image_height_in_pixels,
+    int32_t image_stride_in_pixels,
+    float image_width_in_meters,
+    int32_t *out_index);
+
+/// Returns the number of images in the image database.
+void ArAugmentedImageDatabase_getNumImages(
+    const ArSession *session,
+    const ArAugmentedImageDatabase *augmented_image_database,
+    int32_t *out_num_images);
+
+/// Releases memory used by an image database.
+void ArAugmentedImageDatabase_destroy(
+    ArAugmentedImageDatabase *augmented_image_database);
+
+/// @}
+
+// === ArHitResultList methods ===
+
+/// @addtogroup hit
+/// @{
+
+/// Creates a hit result list object.
+void ArHitResultList_create(const ArSession *session,
+                            ArHitResultList **out_hit_result_list);
+
+/// Releases the memory used by a hit result list object, along with all the
+/// trackable references it holds.
+void ArHitResultList_destroy(ArHitResultList *hit_result_list);
+
+/// Retrieves the number of hit results in this list.
+void ArHitResultList_getSize(const ArSession *session,
+                             const ArHitResultList *hit_result_list,
+                             int32_t *out_size);
+
+/// Copies an indexed entry in the list.  This acquires a reference to any
+/// trackable referenced by the item, and releases any reference currently held
+/// by the provided result object.
+///
+/// @param[in]    session           The ARCore session.
+/// @param[in]    hit_result_list   The list from which to copy an item.
+/// @param[in]    index             Index of the entry to copy.
+/// @param[inout] out_hit_result    An already-allocated ArHitResult object into
+///     which the result will be copied.
+void ArHitResultList_getItem(const ArSession *session,
+                             const ArHitResultList *hit_result_list,
+                             int32_t index,
+                             ArHitResult *out_hit_result);
+
+// === ArHitResult methods ===
+
+/// Allocates an empty hit result object.
+void ArHitResult_create(const ArSession *session, ArHitResult **out_hit_result);
+
+/// Releases the memory used by a hit result object, along with any
+/// trackable reference it holds.
+void ArHitResult_destroy(ArHitResult *hit_result);
+
+/// Returns the distance from the camera to the hit location, in meters.
+void ArHitResult_getDistance(const ArSession *session,
+                             const ArHitResult *hit_result,
+                             float *out_distance);
+
+/// Returns the pose of the intersection between a ray and detected real-world
+/// geometry. The position is the location in space where the ray intersected
+/// the geometry. The orientation is a best effort to face the user's device,
+/// and its exact definition differs depending on the Trackable that was hit.
+///
+/// ::ArPlane : X+ is perpendicular to the cast ray and parallel to the plane,
+/// Y+ points along the plane normal (up, for #AR_PLANE_HORIZONTAL_UPWARD_FACING
+/// planes), and Z+ is parallel to the plane, pointing roughly toward the
+/// user's device.
+///
+/// ::ArPoint :
+/// Attempt to estimate the normal of the surface centered around the hit test.
+/// Surface normal estimation is most likely to succeed on textured surfaces
+/// and with camera motion.
+/// If ArPoint_getOrientationMode() returns ESTIMATED_SURFACE_NORMAL,
+/// then X+ is perpendicular to the cast ray and parallel to the physical
+/// surface centered around the hit test, Y+ points along the estimated surface
+/// normal, and Z+ points roughly toward the user's device. If
+/// ArPoint_getOrientationMode() returns INITIALIZED_TO_IDENTITY, then X+ is
+/// perpendicular to the cast ray and points right from the perspective of the
+/// user's device, Y+ points up, and Z+ points roughly toward the user's device.
+///
+/// If you wish to retain the location of this pose beyond the duration of a
+/// single frame, create an anchor using ArHitResult_acquireNewAnchor() to save
+/// the pose in a physically consistent way.
+///
+/// @param[in]    session    The ARCore session.
+/// @param[in]    hit_result The hit result to retrieve the pose of.
+/// @param[inout] out_pose   An already-allocated ArPose object into which the
+///     pose will be stored.
+void ArHitResult_getHitPose(const ArSession *session,
+                            const ArHitResult *hit_result,
+                            ArPose *out_pose);
+
+/// Acquires reference to the hit trackable. This call must be paired with a
+/// call to ArTrackable_release().
+void ArHitResult_acquireTrackable(const ArSession *session,
+                                  const ArHitResult *hit_result,
+                                  ArTrackable **out_trackable);
+
+/// Creates a new anchor at the hit location. See ArHitResult_getHitPose() for
+/// details.  This is equivalent to creating an anchor on the hit trackable at
+/// the hit pose.
+///
+/// @return #AR_SUCCESS or any of:
+/// - #AR_ERROR_NOT_TRACKING
+/// - #AR_ERROR_SESSION_PAUSED
+/// - #AR_ERROR_RESOURCE_EXHAUSTED
+/// - #AR_ERROR_DEADLINE_EXCEEDED - hit result must be used before the next call
+///     to update().
+ArStatus ArHitResult_acquireNewAnchor(ArSession *session,
+                                      ArHitResult *hit_result,
+                                      ArAnchor **out_anchor);
+
+/// @}
+
+// Utility methods for releasing data.
+
+/// Releases a string acquired using an ARCore API function.
+///
+/// @param[in] str The string to be released.
+void ArString_release(char *str);
+
+/// Releases a byte array created using an ARCore API function.
+void ArByteArray_release(uint8_t *byte_array);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // ARCORE_C_API_H_