[android] async rendering

- introduces GLSurfaceView
- introduces Orchestration thread
- renders on the gl thread

5 files changed, 287 insertions, 497 deletions

diff --git a/platform/android/src/android_gl_thread.hpp b/platform/android/src/android_gl_thread.hpp
new file mode 100644
index 0000000000..1c2412d594
--- /dev/null
+++ b/platform/android/src/android_gl_thread.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <mbgl/actor/actor.hpp>
+#include <mbgl/actor/mailbox.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/renderer/renderer.hpp>
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <utility>
+
+namespace mbgl {
+namespace android {
+
+class AndroidGLThread : public Scheduler {
+public:
+    using InvalidateCallback = std::function<void ()>;
+
+    template <class... Args>
+    AndroidGLThread(InvalidateCallback callback_, Args&&... args)
+        : renderer(std::make_unique<Renderer>(std::forward<Args>(args)...))
+        , mailbox(std::make_shared<Mailbox>(*this))
+        , callback(callback_)
+        , rendererRef(*renderer, mailbox) {
+    }
+
+    ~AndroidGLThread() override = default;
+
+    ActorRef<Renderer> actor() const {
+        return rendererRef;
+    }
+
+    void schedule(std::weak_ptr<Mailbox> scheduled) override {
+        {
+            std::lock_guard<std::mutex> lock(mutex);
+            queue.push(scheduled);
+        }
+
+        // Invalidate so we get processing time later
+        callback();
+    }
+
+    // Only safe on the GL Thread
+    void process() {
+        while (true) {
+            std::unique_lock<std::mutex> lock(mutex);
+
+            if (queue.empty()) {
+                return;
+            }
+
+            auto scheduled = queue.front();
+            queue.pop();
+
+            lock.unlock();
+
+            Mailbox::maybeReceive(scheduled);
+        }
+    }
+
+    // Only safe to access on the GL Thread
+    std::unique_ptr<Renderer> renderer;
+
+private:
+    std::mutex mutex;
+    std::queue<std::weak_ptr<Mailbox>> queue;
+
+    std::shared_ptr<Mailbox> mailbox;
+    InvalidateCallback callback;
+    ActorRef<Renderer> rendererRef;
+};
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/android_renderer_frontend.cpp b/platform/android/src/android_renderer_frontend.cpp
index 597bebe40d..cdcd8eddfe 100644
--- a/platform/android/src/android_renderer_frontend.cpp
+++ b/platform/android/src/android_renderer_frontend.cpp
@@ -1,72 +1,188 @@
 #include "android_renderer_frontend.hpp"
 
-#include <mbgl/renderer/backend_scope.hpp>
-#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/renderer/renderer_observer.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/util/thread.hpp>
+#include <mbgl/util/run_loop.hpp>
+#include <mbgl/util/logging.hpp>
+
+#include "android_renderer_backend.hpp"
 
 namespace mbgl {
 namespace android {
 
-AndroidRendererFrontend::AndroidRendererFrontend(
-        std::unique_ptr<Renderer> renderer_,
-        RendererBackend& backend_,
-        InvalidateCallback invalidate)
-        : renderer(std::move(renderer_))
-        , backend(backend_)
-        , asyncInvalidate([=, invalidate=std::move(invalidate)]() {
+// Forwards RendererObserver signals to the given
+// Delegate RendererObserver on the given RunLoop
+class ForwardingRendererObserver : public RendererObserver {
+public:
+    ForwardingRendererObserver(util::RunLoop& mapRunLoop, RendererObserver& delegate_)
+            : mailbox(std::make_shared<Mailbox>(mapRunLoop))
+            , delegate(delegate_, mailbox) {
+    }
+
+    ~ForwardingRendererObserver() {
+        mailbox->close();
+    }
+
+    void onInvalidate() override {
+        delegate.invoke(&RendererObserver::onInvalidate);
+    }
+
+    void onResourceError(std::exception_ptr err) override {
+        delegate.invoke(&RendererObserver::onResourceError, err);
+    }
+
+    void onWillStartRenderingMap() override {
+        delegate.invoke(&RendererObserver::onWillStartRenderingMap);
+    }
+
+    void onWillStartRenderingFrame() override {
+        delegate.invoke(&RendererObserver::onWillStartRenderingFrame);
+    }
+
+    void onDidFinishRenderingFrame(RenderMode mode, bool repaintNeeded) override {
+        delegate.invoke(&RendererObserver::onDidFinishRenderingFrame, mode, repaintNeeded);
+    }
+
+    void onDidFinishRenderingMap() override {
+        delegate.invoke(&RendererObserver::onDidFinishRenderingMap);
+    }
+
+private:
+    std::shared_ptr<Mailbox> mailbox;
+    ActorRef<RendererObserver> delegate;
+};
+
+AndroidRendererFrontend::AndroidRendererFrontend(float pixelRatio,
+                                                 FileSource& fileSource,
+                                                 Scheduler& scheduler,
+                                                 std::string programCacheDir,
+                                                 InvalidateCallback invalidate)
+        : backend(std::make_unique<AndroidRendererBackend>())
+        , glThread(std::make_unique<AndroidGLThread>(
+                invalidate,
+                *backend,
+                pixelRatio,
+                fileSource,
+                scheduler,
+                GLContextMode::Unique,
+                programCacheDir
+        ))
+        , asyncInvalidate([=]() {
             invalidate();
-        }) {
+        })
+        , mapRunLoop(util::RunLoop::Get()) {
 }
 
 AndroidRendererFrontend::~AndroidRendererFrontend() = default;
 
 void AndroidRendererFrontend::reset() {
-    assert (renderer);
-    if (renderer) {
-        renderer.reset();
-    }
+    assert(glThread);
+    glThread.reset();
 }
 
 void AndroidRendererFrontend::setObserver(RendererObserver& observer) {
-    assert (renderer);
-    renderer->setObserver(&observer);
+    assert (glThread);
+    assert (util::RunLoop::Get());
+    rendererObserver = std::make_unique<ForwardingRendererObserver>(*mapRunLoop, observer);
+    glThread->actor().invoke(&Renderer::setObserver, rendererObserver.get());
 }
 
 void AndroidRendererFrontend::update(std::shared_ptr<UpdateParameters> params) {
-    updateParameters = std::move(params);
+    {
+        // Lock on the parameters
+        std::lock_guard<std::mutex> lock(updateMutex);
+        updateParameters = std::move(params);
+    }
     asyncInvalidate.send();
 }
 
+// Called on OpenGL thread
 void AndroidRendererFrontend::render() {
-    assert (renderer);
-    if (!updateParameters) return;
+    assert (glThread);
+
+    std::shared_ptr<UpdateParameters> params;
+    {
+        // Lock on the parameters
+        std::unique_lock<std::mutex> lock(updateMutex);
+        if (!updateParameters) return;
+
+        // Hold on to the update parameters during render
+        params = updateParameters;
+    }
+
+    // Process the gl thread mailbox
+    glThread->process();
 
-    BackendScope guard { backend };
+    // Activate the backend
+    BackendScope backendGuard { *backend };
 
-    renderer->render(*updateParameters);
+    // Ensure that the "current" scheduler on the render thread is
+    // actually the scheduler from the orchestration  thread
+    Scheduler::SetCurrent(glThread.get());
+
+    if (framebufferSizeChanged) {
+        backend->updateViewPort();
+        framebufferSizeChanged = false;
+    }
+
+    glThread->renderer->render(*params);
 }
 
 void AndroidRendererFrontend::onLowMemory() {
-    assert (renderer);
-    renderer->onLowMemory();
+    assert (glThread);
+    glThread->actor().invoke(&Renderer::onLowMemory);
 }
 
 std::vector<Feature> AndroidRendererFrontend::querySourceFeatures(const std::string& sourceID,
                                                                   const SourceQueryOptions& options) const {
-    return renderer->querySourceFeatures(sourceID, options);
+    assert (glThread);
+    // Waits for the result from the orchestration thread and returns
+    return glThread->actor().ask(&Renderer::querySourceFeatures, sourceID, options).get();
 }
 
 std::vector<Feature> AndroidRendererFrontend::queryRenderedFeatures(const ScreenBox& box,
                                                                     const RenderedQueryOptions& options) const {
-    return renderer->queryRenderedFeatures(box, options);
+    assert (glThread);
+
+    // Select the right overloaded method
+    std::vector<Feature> (Renderer::*fn)(const ScreenBox&, const RenderedQueryOptions&) const = &Renderer::queryRenderedFeatures;
+
+    // Waits for the result from the orchestration thread and returns
+    return glThread->actor().ask(fn, box, options).get();
 }
 
 std::vector<Feature> AndroidRendererFrontend::queryRenderedFeatures(const ScreenCoordinate& point,
                                                                     const RenderedQueryOptions& options) const {
-    return renderer->queryRenderedFeatures(point, options);
+    assert (glThread);
+
+    // Select the right overloaded method
+    std::vector<Feature> (Renderer::*fn)(const ScreenCoordinate&, const RenderedQueryOptions&) const = &Renderer::queryRenderedFeatures;
+
+    // Waits for the result from the orchestration thread and returns
+    return glThread->actor().ask(fn, point, options).get();
 }
 
 AnnotationIDs AndroidRendererFrontend::queryPointAnnotations(const ScreenBox& box) const {
-    return renderer->queryPointAnnotations(box);
+    assert (glThread);
+
+    // Waits for the result from the orchestration thread and returns
+    return glThread->actor().ask(&Renderer::queryPointAnnotations, box).get();
+}
+
+void AndroidRendererFrontend::requestSnapshot(SnapshotCallback callback_) {
+    snapshotCallback = std::make_unique<SnapshotCallback>([callback=std::move(callback_), runloop=util::RunLoop::Get()](PremultipliedImage image){
+        runloop->invoke([&]() {
+            callback(std::move(image));
+        });
+    });
+}
+
+void AndroidRendererFrontend::resizeFramebuffer(int width, int height) {
+    backend->resizeFramebuffer(width, height);
+    framebufferSizeChanged = true;
+    asyncInvalidate.send();
 }
 
 } // namespace android
diff --git a/platform/android/src/android_renderer_frontend.hpp b/platform/android/src/android_renderer_frontend.hpp
index 107bbbe0b6..f2e951bd05 100644
--- a/platform/android/src/android_renderer_frontend.hpp
+++ b/platform/android/src/android_renderer_frontend.hpp
@@ -1,34 +1,50 @@
 
 #pragma once
 
+#include "android_gl_thread.hpp"
+
+#include <mbgl/actor/actor.hpp>
 #include <mbgl/annotation/annotation.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/util/async_task.hpp>
 #include <mbgl/util/geo.hpp>
+#include <mbgl/util/image.hpp>
+#include <mbgl/util/run_loop.hpp>
 
 #include <functional>
 #include <memory>
 #include <vector>
+#include <string>
 
 namespace mbgl {
 
-class Renderer;
+class FileSource;
+class Scheduler;
 class RenderedQueryOptions;
 class SourceQueryOptions;
 
 namespace android {
 
+class AndroidRendererBackend;
+
 class AndroidRendererFrontend : public RendererFrontend {
 public:
     using InvalidateCallback = std::function<void ()>;
-    AndroidRendererFrontend(std::unique_ptr<Renderer>, RendererBackend&, InvalidateCallback);
+
+    AndroidRendererFrontend(float pixelRatio,
+                            mbgl::FileSource&,
+                            mbgl::Scheduler&,
+                            std::string programCacheDir,
+                            InvalidateCallback);
     ~AndroidRendererFrontend() override;
 
     void reset() override;
     void setObserver(RendererObserver&) override;
 
     void update(std::shared_ptr<UpdateParameters>) override;
+
+    // Called from OpenGL Thread
     void render();
 
     // Feature querying
@@ -37,14 +53,31 @@ public:
     std::vector<Feature> querySourceFeatures(const std::string& sourceID, const SourceQueryOptions&) const;
     AnnotationIDs queryPointAnnotations(const ScreenBox& box) const;
 
+    // RenderBackend proxy - Called from OpenGL Thread
+    void resizeFramebuffer(int width, int height);
+
     // Memory
     void onLowMemory();
 
+    // Snapshot - Callback will be called on calling thread through RunLoop
+    using SnapshotCallback = std::function<void (PremultipliedImage)>;
+    void requestSnapshot(SnapshotCallback);
+
 private:
-    std::unique_ptr<Renderer> renderer;
-    RendererBackend& backend;
+    std::unique_ptr<AndroidRendererBackend> backend;
+    std::unique_ptr<AndroidGLThread> glThread;
+    std::unique_ptr<RendererObserver> rendererObserver;
+
+    std::mutex updateMutex;
     std::shared_ptr<UpdateParameters> updateParameters;
+
+
     util::AsyncTask asyncInvalidate;
+
+    util::RunLoop* mapRunLoop;
+
+    bool framebufferSizeChanged = true;
+    std::unique_ptr<SnapshotCallback> snapshotCallback;
 };
 
 } // namespace android
diff --git a/platform/android/src/native_map_view.cpp b/platform/android/src/native_map_view.cpp
index a0d88e8cf1..1a0dc34bbc 100755
--- a/platform/android/src/native_map_view.cpp
+++ b/platform/android/src/native_map_view.cpp
@@ -61,8 +61,7 @@ NativeMapView::NativeMapView(jni::JNIEnv& _env,
                              jni::Object<FileSource> jFileSource,
                              jni::jfloat _pixelRatio,
                              jni::String _programCacheDir)
-    : rendererBackend(std::make_unique<AndroidRendererBackend>()),
-      javaPeer(_obj.NewWeakGlobalRef(_env)),
+    : javaPeer(_obj.NewWeakGlobalRef(_env)),
       pixelRatio(_pixelRatio),
       threadPool(sharedThreadPool()) {
 
@@ -72,16 +71,13 @@ NativeMapView::NativeMapView(jni::JNIEnv& _env,
         return;
     }
 
-    auto& fileSource = mbgl::android::FileSource::getDefaultFileSource(_env, jFileSource);
-
-    // Create a renderer
-    auto renderer = std::make_unique<Renderer>(*rendererBackend, pixelRatio, fileSource,
-                                               *threadPool, GLContextMode::Unique,
-                                               jni::Make<std::string>(_env, _programCacheDir));
+    mbgl::FileSource& fileSource = mbgl::android::FileSource::getDefaultFileSource(_env, jFileSource);
 
     // Create a renderer frontend
-    rendererFrontend = std::make_unique<AndroidRendererFrontend>(std::move(renderer),
-                                                                 *rendererBackend,
+    rendererFrontend = std::make_unique<AndroidRendererFrontend>(pixelRatio, fileSource,
+                                                                 *threadPool,
+                                                                 jni::Make<std::string>(_env,
+                                                                                        _programCacheDir),
                                                                  [this] { this->invalidate(); });
 
     // Create the core map
@@ -90,29 +86,21 @@ NativeMapView::NativeMapView(jni::JNIEnv& _env,
                                                   static_cast<uint32_t>(height) }, pixelRatio,
                                       fileSource, *threadPool, MapMode::Continuous,
                                       ConstrainMode::HeightOnly, ViewportMode::Default);
-
-    // initialize egl components
-    _initializeDisplay();
-    _initializeContext();
 }
 
 /**
  * Called through NativeMapView#destroy()
  */
 NativeMapView::~NativeMapView() {
-    _terminateContext();
-    _destroySurface();
-    _terminateDisplay();
-
     map.reset();
-
     vm = nullptr;
 }
 
 /**
  * Callback to java NativeMapView#onInvalidate().
  *
- * May be called from any thread
+ * Called to invalidate the View and schedule a render on the next
+ * runloop iteration.
  */
 void NativeMapView::invalidate() {
     android::UniqueEnv _env = android::AttachEnv();
@@ -199,48 +187,12 @@ void NativeMapView::onSourceChanged(mbgl::style::Source&) {
 
 // JNI Methods //
 
-void NativeMapView::createSurface(jni::JNIEnv& env, jni::Object<> _surface) {
-    _createSurface(ANativeWindow_fromSurface(&env, jni::Unwrap(*_surface)));
-}
-
-void NativeMapView::destroySurface(jni::JNIEnv&) {
-    _destroySurface();
-}
-
-void NativeMapView::render(jni::JNIEnv& env) {
-    BackendScope guard { *rendererBackend };
-
-    if (framebufferSizeChanged) {
-        rendererBackend->updateViewPort();
-        framebufferSizeChanged = false;
-    }
-
+// Called from the OpenGL renderer thread
+void NativeMapView::render(jni::JNIEnv& ) {
     rendererFrontend->render();
 
-    if(snapshot){
-         snapshot = false;
-
-         // take snapshot
-         auto image = rendererBackend->readFramebuffer();
-         auto bitmap = Bitmap::CreateBitmap(env, std::move(image));
-
-         // invoke Mapview#OnSnapshotReady
-        android::UniqueEnv _env = android::AttachEnv();
-        static auto onSnapshotReady = javaClass.GetMethod<void (jni::Object<Bitmap>)>(*_env, "onSnapshotReady");
-        javaPeer->Call(*_env, onSnapshotReady, bitmap);
-    }
-
-    if ((display != EGL_NO_DISPLAY) && (surface != EGL_NO_SURFACE)) {
-        if (!eglSwapBuffers(display, surface)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL, "eglSwapBuffers() returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglSwapBuffers() failed");
-        }
-
-        updateFps();
-    } else {
-        mbgl::Log::Info(mbgl::Event::Android, "Not swapping as we are not ready");
-    }
+    // TODO
+    updateFps();
 }
 
 void NativeMapView::update(jni::JNIEnv&) {
@@ -254,9 +206,9 @@ void NativeMapView::resizeView(jni::JNIEnv&, int w, int h) {
 }
 
 void NativeMapView::resizeFramebuffer(jni::JNIEnv&, int w, int h) {
-    rendererBackend->resizeFramebuffer(w, h);
-    framebufferSizeChanged = true;
-    invalidate();
+    rendererFrontend->resizeFramebuffer(w, h);
+//    framebufferSizeChanged = true;
+//    invalidate();
 }
 
 jni::String NativeMapView::getStyleUrl(jni::JNIEnv& env) {
@@ -476,7 +428,15 @@ void NativeMapView::setContentPadding(JNIEnv&, double top, double left, double b
 }
 
 void NativeMapView::scheduleSnapshot(jni::JNIEnv&) {
-    snapshot = true;
+    rendererFrontend->requestSnapshot([&](PremultipliedImage image) {
+        auto _env = android::AttachEnv();
+        // Convert image to bitmap
+        auto bitmap = Bitmap::CreateBitmap(*_env, std::move(image));
+
+        // invoke Mapview#OnSnapshotReady
+        static auto onSnapshotReady = javaClass.GetMethod<void (jni::Object<Bitmap>)>(*_env, "onSnapshotReady");
+        javaPeer->Call(*_env, onSnapshotReady, bitmap);
+    });
 }
 
 void NativeMapView::enableFps(jni::JNIEnv&, jni::jboolean enable) {
@@ -1001,371 +961,6 @@ jni::jboolean NativeMapView::getPrefetchesTiles(JNIEnv&) {
 
 // Private methods //
 
-void NativeMapView::_initializeDisplay() {
-    assert(display == EGL_NO_DISPLAY);
-    assert(config == nullptr);
-    assert(format < 0);
-
-    display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    if (display == EGL_NO_DISPLAY) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglGetDisplay() returned error %d", eglGetError());
-        throw std::runtime_error("eglGetDisplay() failed");
-    }
-
-    EGLint major, minor;
-    if (!eglInitialize(display, &major, &minor)) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglInitialize() returned error %d", eglGetError());
-        throw std::runtime_error("eglInitialize() failed");
-    }
-    if ((major <= 1) && (minor < 3)) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "EGL version is too low, need 1.3, got %d.%d", major,
-                         minor);
-        throw std::runtime_error("EGL version is too low");
-    }
-
-    // Detect if we are in emulator.
-    const bool inEmulator = []() {
-        char prop[PROP_VALUE_MAX];
-        __system_property_get("ro.kernel.qemu", prop);
-        return strtol(prop, nullptr, 0) == 1;
-    }();
-
-    if (inEmulator) {
-        // XXX https://code.google.com/p/android/issues/detail?id=78977
-        mbgl::Log::Warning(mbgl::Event::Android, "Running SDK in emulator!");
-    }
-
-    if (!eglBindAPI(EGL_OPENGL_ES_API)) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglBindAPI(EGL_OPENGL_ES_API) returned error %d", eglGetError());
-        throw std::runtime_error("eglBindAPI() failed");
-    }
-
-    // Get all configs at least RGB 565 with 16 depth and 8 stencil
-    EGLint configAttribs[] = {
-        EGL_CONFIG_CAVEAT,                               EGL_NONE,
-        EGL_RENDERABLE_TYPE,                             EGL_OPENGL_ES2_BIT,
-        EGL_SURFACE_TYPE,                                EGL_WINDOW_BIT,
-        EGL_BUFFER_SIZE,                                 16,
-        EGL_RED_SIZE,                                    5,
-        EGL_GREEN_SIZE,                                  6,
-        EGL_BLUE_SIZE,                                   5,
-        EGL_DEPTH_SIZE,                                  16,
-        EGL_STENCIL_SIZE,                                8,
-        (inEmulator ? EGL_NONE : EGL_CONFORMANT),        EGL_OPENGL_ES2_BIT,
-        (inEmulator ? EGL_NONE : EGL_COLOR_BUFFER_TYPE), EGL_RGB_BUFFER,
-        EGL_NONE
-    };
-
-    EGLint numConfigs;
-    if (!eglChooseConfig(display, configAttribs, nullptr, 0, &numConfigs)) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglChooseConfig(NULL) returned error %d",
-                         eglGetError());
-        throw std::runtime_error("eglChooseConfig() failed");
-    }
-    if (numConfigs < 1) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglChooseConfig() returned no configs.");
-        throw std::runtime_error("eglChooseConfig() failed");
-    }
-
-    const auto configs = std::make_unique<EGLConfig[]>(numConfigs);
-    if (!eglChooseConfig(display, configAttribs, configs.get(), numConfigs, &numConfigs)) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglChooseConfig() returned error %d", eglGetError());
-        throw std::runtime_error("eglChooseConfig() failed");
-    }
-
-    config = chooseConfig(configs.get(), numConfigs);
-    if (config == nullptr) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "No config chosen");
-        throw std::runtime_error("No config chosen");
-    }
-
-    if (!eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format)) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglGetConfigAttrib() returned error %d",
-                         eglGetError());
-        throw std::runtime_error("eglGetConfigAttrib() failed");
-    }
-}
-
-// Quality
-typedef enum {
-    Format16Bit = 3,
-    Format32BitNoAlpha = 1,
-    Format32BitAlpha = 2,
-    Format24Bit = 0,
-    Unknown = 4
-} BufferFormat;
-
-typedef enum {
-    Format16Depth8Stencil = 1,
-    Format24Depth8Stencil = 0,
-} DepthStencilFormat;
-
-// Tuple is <buffer_format, depth_stencil_format, is_not_conformant, is_caveat, config_num,
-// config_id>
-typedef std::tuple<BufferFormat, DepthStencilFormat, bool, bool, int, EGLConfig> ConfigProperties;
-
-EGLConfig NativeMapView::chooseConfig(const EGLConfig configs[], EGLint numConfigs) {
-    // Create a list of configs that pass our filters
-    std::list<ConfigProperties> configList;
-    for (int i = 0; i < numConfigs; i++) {
-        EGLint caveat, conformant, bits, red, green, blue, alpha, alphaMask, depth, stencil,
-            sampleBuffers, samples;
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_CONFIG_CAVEAT, &caveat)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_CONFIG_CAVEAT) returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_CONFORMANT, &conformant)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_CONFORMANT) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_BUFFER_SIZE, &bits)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_BUFFER_SIZE) returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_RED_SIZE, &red)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_RED_SIZE) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_GREEN_SIZE, &green)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_GREEN_SIZE) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_BLUE_SIZE, &blue)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_BLUE_SIZE) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_ALPHA_SIZE, &alpha)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_ALPHA_SIZE) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_ALPHA_MASK_SIZE, &alphaMask)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_ALPHA_MASK_SIZE) returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_DEPTH_SIZE, &depth)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_DEPTH_SIZE) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_STENCIL_SIZE, &stencil)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_STENCIL_SIZE) returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_SAMPLE_BUFFERS, &sampleBuffers)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_SAMPLE_BUFFERS) returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        if (!eglGetConfigAttrib(display, configs[i], EGL_SAMPLES, &samples)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglGetConfigAttrib(EGL_SAMPLES) returned error %d", eglGetError());
-            throw std::runtime_error("eglGetConfigAttrib() failed");
-        }
-
-        bool configOk = true;
-        configOk &= (depth == 24) || (depth == 16);
-        configOk &= stencil == 8;
-        configOk &= sampleBuffers == 0;
-        configOk &= samples == 0;
-
-        // Filter our configs first for depth, stencil and anti-aliasing
-        if (configOk) {
-            // Work out the config's buffer format
-            BufferFormat bufferFormat;
-            if ((bits == 16) && (red == 5) && (green == 6) && (blue == 5) && (alpha == 0)) {
-                bufferFormat = Format16Bit;
-            } else if ((bits == 32) && (red == 8) && (green == 8) && (blue == 8) && (alpha == 0)) {
-                bufferFormat = Format32BitNoAlpha;
-            } else if ((bits == 32) && (red == 8) && (green == 8) && (blue == 8) && (alpha == 8)) {
-                bufferFormat = Format32BitAlpha;
-            } else if ((bits == 24) && (red == 8) && (green == 8) && (blue == 8) && (alpha == 0)) {
-                bufferFormat = Format24Bit;
-            } else {
-                bufferFormat = Unknown;
-            }
-
-            // Work out the config's depth stencil format
-            DepthStencilFormat depthStencilFormat;
-            if ((depth == 16) && (stencil == 8)) {
-                depthStencilFormat = Format16Depth8Stencil;
-            } else {
-                depthStencilFormat = Format24Depth8Stencil;
-            }
-
-            bool isNotConformant = (conformant & EGL_OPENGL_ES2_BIT) != EGL_OPENGL_ES2_BIT;
-            bool isCaveat = caveat != EGL_NONE;
-            EGLConfig configId = configs[i];
-
-            // Ignore formats we don't recognise
-            if (bufferFormat != Unknown) {
-                configList.push_back(std::make_tuple(bufferFormat, depthStencilFormat,
-                                                     isNotConformant, isCaveat, i, configId));
-            }
-        }
-    }
-
-    if (configList.empty()) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "Config list was empty.");
-    }
-
-    // Sort the configs to find the best one
-    configList.sort();
-    bool isConformant = !std::get<2>(configList.front());
-    bool isCaveat = std::get<3>(configList.front());
-    EGLConfig configId = std::get<5>(configList.front());
-
-    if (isCaveat) {
-        mbgl::Log::Warning(mbgl::Event::OpenGL, "Chosen config has a caveat.");
-    }
-    if (!isConformant) {
-        mbgl::Log::Warning(mbgl::Event::OpenGL, "Chosen config is not conformant.");
-    }
-
-    return configId;
-}
-
-void NativeMapView::_terminateDisplay() {
-    if (display != EGL_NO_DISPLAY) {
-        // Destroy the surface first, if it still exists. This call needs a valid surface.
-        if (surface != EGL_NO_SURFACE) {
-            if (!eglDestroySurface(display, surface)) {
-                mbgl::Log::Error(mbgl::Event::OpenGL, "eglDestroySurface() returned error %d",
-                                 eglGetError());
-                throw std::runtime_error("eglDestroySurface() failed");
-            }
-            surface = EGL_NO_SURFACE;
-        }
-
-        if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglMakeCurrent(EGL_NO_CONTEXT) returned error %d", eglGetError());
-            throw std::runtime_error("eglMakeCurrent() failed");
-        }
-
-        if (!eglTerminate(display)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL, "eglTerminate() returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglTerminate() failed");
-        }
-    }
-
-    display = EGL_NO_DISPLAY;
-    config = nullptr;
-    format = -1;
-}
-
-void NativeMapView::_initializeContext() {
-    assert(display != EGL_NO_DISPLAY);
-    assert(context == EGL_NO_CONTEXT);
-    assert(config != nullptr);
-
-    const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
-    context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
-    if (context == EGL_NO_CONTEXT) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglCreateContext() returned error %d",
-                         eglGetError());
-        throw std::runtime_error("eglCreateContext() failed");
-    }
-}
-
-void NativeMapView::_terminateContext() {
-    if (display != EGL_NO_DISPLAY) {
-
-        if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL,
-                             "eglMakeCurrent(EGL_NO_CONTEXT) returned error %d", eglGetError());
-            throw std::runtime_error("eglMakeCurrent() failed");
-        }
-
-        if (context != EGL_NO_CONTEXT) {
-            if (!eglDestroyContext(display, context)) {
-                mbgl::Log::Error(mbgl::Event::OpenGL, "eglDestroyContext() returned error %d",
-                                 eglGetError());
-                throw std::runtime_error("eglDestroyContext() failed");
-            }
-        }
-    }
-
-    context = EGL_NO_CONTEXT;
-}
-
-void NativeMapView::_createSurface(ANativeWindow *window_) {
-    assert(window == nullptr);
-    assert(window_ != nullptr);
-    window = window_;
-
-    assert(display != EGL_NO_DISPLAY);
-    assert(surface == EGL_NO_SURFACE);
-    assert(config != nullptr);
-    assert(format >= 0);
-
-    ANativeWindow_setBuffersGeometry(window, 0, 0, format);
-
-    const EGLint surfaceAttribs[] = {EGL_NONE};
-    surface = eglCreateWindowSurface(display, config, window, surfaceAttribs);
-    if (surface == EGL_NO_SURFACE) {
-        mbgl::Log::Error(mbgl::Event::OpenGL, "eglCreateWindowSurface() returned error %d",
-                         eglGetError());
-        throw std::runtime_error("eglCreateWindowSurface() failed");
-    }
-
-    if (firstRender) {
-        firstRender = false;
-
-        BackendScope guard(*rendererBackend);
-
-        if (!eglMakeCurrent(display, surface, surface, context)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL, "eglMakeCurrent() returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglMakeCurrent() failed");
-        }
-    }
-}
-
-void NativeMapView::_destroySurface() {
-    if (surface != EGL_NO_SURFACE) {
-        if (!eglDestroySurface(display, surface)) {
-            mbgl::Log::Error(mbgl::Event::OpenGL, "eglDestroySurface() returned error %d",
-                             eglGetError());
-            throw std::runtime_error("eglDestroySurface() failed");
-        }
-    }
-
-    surface = EGL_NO_SURFACE;
-    firstRender = true;
-
-    if (window != nullptr) {
-        ANativeWindow_release(window);
-        window = nullptr;
-    }
-}
-
 void NativeMapView::updateFps() {
     if (!fpsEnabled) {
         return;
@@ -1412,8 +1007,6 @@ void NativeMapView::registerNative(jni::JNIEnv& env) {
             METHOD(&NativeMapView::update, "nativeUpdate"),
             METHOD(&NativeMapView::resizeView, "nativeResizeView"),
             METHOD(&NativeMapView::resizeFramebuffer, "nativeResizeFramebuffer"),
-            METHOD(&NativeMapView::createSurface, "nativeCreateSurface"),
-            METHOD(&NativeMapView::destroySurface, "nativeDestroySurface"),
             METHOD(&NativeMapView::getStyleUrl, "nativeGetStyleUrl"),
             METHOD(&NativeMapView::setStyleUrl, "nativeSetStyleUrl"),
             METHOD(&NativeMapView::getStyleJson, "nativeGetStyleJson"),
@@ -1498,5 +1091,5 @@ void NativeMapView::registerNative(jni::JNIEnv& env) {
     );
 }
 
-}
-}
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/native_map_view.hpp b/platform/android/src/native_map_view.hpp
index 074906dbab..0539a29b46 100755
--- a/platform/android/src/native_map_view.hpp
+++ b/platform/android/src/native_map_view.hpp
@@ -36,7 +36,6 @@
 namespace mbgl {
 namespace android {
 
-class AndroidRendererBackend;
 class AndroidRendererFrontend;
 
 class NativeMapView : public MapObserver {
@@ -78,18 +77,19 @@ public:
 
     // JNI //
 
+    // Called on OpenGL Thread
+    void onSurfaceCreated(jni::JNIEnv&);
+
+    // Called on OpenGL Thread
     void render(jni::JNIEnv&);
 
     void update(jni::JNIEnv&);
 
     void resizeView(jni::JNIEnv&, int, int);
 
+    // Called on OpenGL Thread
     void resizeFramebuffer(jni::JNIEnv&, int, int);
 
-    void createSurface(jni::JNIEnv&, jni::Object<>);
-
-    void destroySurface(jni::JNIEnv&);
-
     jni::String getStyleUrl(jni::JNIEnv&);
 
     void setStyleUrl(jni::JNIEnv&, jni::String);
@@ -257,25 +257,11 @@ public:
     jni::jboolean getPrefetchesTiles(JNIEnv&);
 
 private:
-    void _initializeDisplay();
-
-    void _terminateDisplay();
-
-    void _initializeContext();
-
-    void _terminateContext();
-
-    void _createSurface(ANativeWindow*);
-
-    void _destroySurface();
-
-    EGLConfig chooseConfig(const EGLConfig configs[], EGLint numConfigs);
 
     void updateFps();
 
 private:
     std::unique_ptr<AndroidRendererFrontend> rendererFrontend;
-    std::unique_ptr<AndroidRendererBackend> rendererBackend;
 
     JavaVM *vm = nullptr;
     jni::UniqueWeakObject<NativeMapView> javaPeer;
@@ -283,28 +269,14 @@ private:
     std::string styleUrl;
     std::string apiKey;
 
-    ANativeWindow *window = nullptr;
-
-    EGLConfig config = nullptr;
-    EGLint format = -1;
-
-    EGLDisplay display = EGL_NO_DISPLAY;
-    EGLSurface surface = EGL_NO_SURFACE;
-    EGLContext context = EGL_NO_CONTEXT;
-
-
     float pixelRatio;
     bool fpsEnabled = false;
-    bool snapshot = false;
-    bool firstRender = true;
     double fps = 0.0;
 
     // Minimum texture size according to OpenGL ES 2.0 specification.
     int width = 64;
     int height = 64;
 
-    bool framebufferSizeChanged = true;
-
     // Ensure these are initialised last
     std::shared_ptr<mbgl::ThreadPool> threadPool;
     std::unique_ptr<mbgl::Map> map;