4 files changed, 160 insertions, 0 deletions

diff --git a/platform/android/src/offline/offline_manager.cpp b/platform/android/src/offline/offline_manager.cpp
index 54b1142845..029252f786 100644
--- a/platform/android/src/offline/offline_manager.cpp
+++ b/platform/android/src/offline/offline_manager.cpp
@@ -104,10 +104,104 @@ void OfflineManager::mergeOfflineRegions(jni::JNIEnv& env_, const jni::Object<Fi
     });
 }
 
+void OfflineManager::resetDatabase(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
+    fileSource->resetDatabase([
+        //Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
+    ](std::exception_ptr exception) mutable {
+
+        // Reattach, the callback comes from a different thread
+        android::UniqueEnv env = android::AttachEnv();
+
+        if (exception) {
+            OfflineManager::FileSourceCallback::onError(*env, *callback, jni::Make<jni::String>(*env, mbgl::util::toString(exception)));
+        } else {
+            OfflineManager::FileSourceCallback::onSuccess(*env, *callback);
+        }
+    });
+}
+
+void OfflineManager::invalidateAmbientCache(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
+    fileSource->invalidateAmbientCache([
+        //Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
+    ](std::exception_ptr exception) mutable {
+
+        // Reattach, the callback comes from a different thread
+        android::UniqueEnv env = android::AttachEnv();
+
+        if (exception) {
+            OfflineManager::FileSourceCallback::onError(*env, *callback, jni::Make<jni::String>(*env, mbgl::util::toString(exception)));
+        } else {
+            OfflineManager::FileSourceCallback::onSuccess(*env, *callback);
+        }
+    });
+}
+
+void OfflineManager::clearAmbientCache(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
+    fileSource->clearAmbientCache([
+        //Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
+    ](std::exception_ptr exception) mutable {
+
+        // Reattach, the callback comes from a different thread
+        android::UniqueEnv env = android::AttachEnv();
+
+        if (exception) {
+            OfflineManager::FileSourceCallback::onError(*env, *callback, jni::Make<jni::String>(*env, mbgl::util::toString(exception)));
+        } else {
+            OfflineManager::FileSourceCallback::onSuccess(*env, *callback);
+        }
+    });
+}
+
+void OfflineManager::setMaximumAmbientCacheSize(jni::JNIEnv& env_, const jni::jlong size_, const jni::Object<FileSourceCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
+    fileSource->setMaximumAmbientCacheSize(size_, [
+        //Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
+    ](std::exception_ptr exception) mutable {
+
+        // Reattach, the callback comes from a different thread
+        android::UniqueEnv env = android::AttachEnv();
+
+        if (exception) {
+            OfflineManager::FileSourceCallback::onError(*env, *callback, jni::Make<jni::String>(*env, mbgl::util::toString(exception)));
+        } else {
+            OfflineManager::FileSourceCallback::onSuccess(*env, *callback);
+        }
+    });
+}
+
+// FileSource::FileSourceCallback //
+
+void OfflineManager::FileSourceCallback::onSuccess(jni::JNIEnv& env,
+                                               const jni::Object<OfflineManager::FileSourceCallback>& callback) {
+    static auto& javaClass = jni::Class<OfflineManager::FileSourceCallback>::Singleton(env);
+    static auto method = javaClass.GetMethod<void ()>(env, "onSuccess");
+    callback.Call(env, method);
+}
+
+void OfflineManager::FileSourceCallback::onError(jni::JNIEnv& env,
+                                             const jni::Object<OfflineManager::FileSourceCallback>& callback,
+                                             const jni::String& message) {
+    static auto& javaClass = jni::Class<OfflineManager::FileSourceCallback>::Singleton(env);
+    static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
+    callback.Call(env, method, message);
+}
+
 void OfflineManager::registerNative(jni::JNIEnv& env) {
     jni::Class<ListOfflineRegionsCallback>::Singleton(env);
     jni::Class<CreateOfflineRegionCallback>::Singleton(env);
     jni::Class<MergeOfflineRegionsCallback>::Singleton(env);
+    jni::Class<FileSourceCallback>::Singleton(env);
 
     static auto& javaClass = jni::Class<OfflineManager>::Singleton(env);
 
@@ -121,6 +215,10 @@ void OfflineManager::registerNative(jni::JNIEnv& env) {
         METHOD(&OfflineManager::listOfflineRegions, "listOfflineRegions"),
         METHOD(&OfflineManager::createOfflineRegion, "createOfflineRegion"),
         METHOD(&OfflineManager::mergeOfflineRegions, "mergeOfflineRegions"),
+        METHOD(&OfflineManager::resetDatabase, "nativeResetDatabase"),
+        METHOD(&OfflineManager::invalidateAmbientCache, "nativeInvalidateAmbientCache"),
+        METHOD(&OfflineManager::clearAmbientCache, "nativeClearAmbientCache"),
+        METHOD(&OfflineManager::setMaximumAmbientCacheSize, "nativeSetMaximumAmbientCacheSize"),
         METHOD(&OfflineManager::putResourceWithUrl, "putResourceWithUrl"));
 }
 
diff --git a/platform/android/src/offline/offline_manager.hpp b/platform/android/src/offline/offline_manager.hpp
index d0b637b900..058cfb5b48 100644
--- a/platform/android/src/offline/offline_manager.hpp
+++ b/platform/android/src/offline/offline_manager.hpp
@@ -55,6 +55,14 @@ public:
                             mbgl::OfflineRegions&);
     };
 
+    struct FileSourceCallback {
+        static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$FileSourceCallback";}
+
+        static void onSuccess(jni::JNIEnv&, const jni::Object<OfflineManager::FileSourceCallback>&);
+
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineManager::FileSourceCallback>&, const jni::String&);
+    };
+
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager"; };
 
     static void registerNative(jni::JNIEnv&);
@@ -85,6 +93,13 @@ public:
                             const jni::String& eTag,
                             jboolean mustRevalidate);
 
+    void resetDatabase(jni::JNIEnv&, const jni::Object<FileSourceCallback>& callback_);
+
+    void invalidateAmbientCache(jni::JNIEnv&, const jni::Object<FileSourceCallback>& callback_);
+
+    void clearAmbientCache(jni::JNIEnv&, const jni::Object<FileSourceCallback>& callback_);
+
+    void setMaximumAmbientCacheSize(jni::JNIEnv&, const jni::jlong size, const jni::Object<FileSourceCallback>& callback_);
 
 private:
     std::shared_ptr<mbgl::DefaultFileSource> fileSource;
diff --git a/platform/android/src/offline/offline_region.cpp b/platform/android/src/offline/offline_region.cpp
index e0f28631b4..ac9f491ab6 100644
--- a/platform/android/src/offline/offline_region.cpp
+++ b/platform/android/src/offline/offline_region.cpp
@@ -119,6 +119,24 @@ void OfflineRegion::deleteOfflineRegion(jni::JNIEnv& env_, const jni::Object<Off
     });
 }
 
+void OfflineRegion::invalidateOfflineRegion(jni::JNIEnv& env_, const jni::Object<OfflineRegionInvalidateCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
+    fileSource->invalidateOfflineRegion(*region, [
+        //Ensure the object is not gc'd in the meanwhile
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
+    ](std::exception_ptr error) mutable {
+        // Reattach, the callback comes from a different thread
+        android::UniqueEnv env = android::AttachEnv();
+
+        if (error) {
+            OfflineRegionInvalidateCallback::onError(*env, *callback, error);
+        } else {
+            OfflineRegionInvalidateCallback::onInvalidate(*env, *callback);
+        }
+    });
+}
+
 void OfflineRegion::updateOfflineRegionMetadata(jni::JNIEnv& env_, const jni::Array<jni::jbyte>& jMetadata, const jni::Object<OfflineRegionUpdateMetadataCallback>& callback_) {
     auto metadata = OfflineRegion::metadata(env_, jMetadata);
     auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
@@ -182,6 +200,7 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
     jni::Class<OfflineRegionStatusCallback>::Singleton(env);
     jni::Class<OfflineRegionDeleteCallback>::Singleton(env);
     jni::Class<OfflineRegionUpdateMetadataCallback>::Singleton(env);
+    jni::Class<OfflineRegionInvalidateCallback>::Singleton(env);
 
     static auto& javaClass = jni::Class<OfflineRegion>::Singleton(env);
 
@@ -195,6 +214,7 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
         METHOD(&OfflineRegion::setOfflineRegionDownloadState, "setOfflineRegionDownloadState"),
         METHOD(&OfflineRegion::getOfflineRegionStatus, "getOfflineRegionStatus"),
         METHOD(&OfflineRegion::deleteOfflineRegion, "deleteOfflineRegion"),
+        METHOD(&OfflineRegion::invalidateOfflineRegion, "invalidateOfflineRegion"),
         METHOD(&OfflineRegion::updateOfflineRegionMetadata, "updateOfflineRegionMetadata")
     );
 }
@@ -260,5 +280,21 @@ void OfflineRegion::OfflineRegionUpdateMetadataCallback::onUpdate(jni::JNIEnv& e
     callback.Call(env, method, OfflineRegion::metadata(env, std::move(*metadata)));
 }
 
+// OfflineRegionInvalidateCallback //
+
+void OfflineRegion::OfflineRegionInvalidateCallback::onError(jni::JNIEnv& env,
+                                                          const jni::Object<OfflineRegion::OfflineRegionInvalidateCallback>& callback,
+                                                          std::exception_ptr error) {
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionInvalidateCallback>::Singleton(env);
+    static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
+    callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
+}
+
+void OfflineRegion::OfflineRegionInvalidateCallback::onInvalidate(jni::JNIEnv& env, const jni::Object<OfflineRegion::OfflineRegionInvalidateCallback>& callback) {
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionInvalidateCallback>::Singleton(env);
+    static auto method = javaClass.GetMethod<void ()>(env, "onInvalidate");
+    callback.Call(env, method);
+}
+
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/offline/offline_region.hpp b/platform/android/src/offline/offline_region.hpp
index 4618e1abbd..dda253469e 100644
--- a/platform/android/src/offline/offline_region.hpp
+++ b/platform/android/src/offline/offline_region.hpp
@@ -37,6 +37,15 @@ public:
         static void onDelete(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&);
     };
 
+    class OfflineRegionInvalidateCallback {
+    public:
+        static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionInvalidateCallback"; };
+
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionInvalidateCallback>&, std::exception_ptr);
+
+        static void onInvalidate(jni::JNIEnv&, const jni::Object<OfflineRegionInvalidateCallback>&);
+    };
+
     class OfflineRegionUpdateMetadataCallback {
     public:
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionUpdateMetadataCallback"; };
@@ -62,6 +71,8 @@ public:
 
     void deleteOfflineRegion(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&);
 
+    void invalidateOfflineRegion(jni::JNIEnv&, const jni::Object<OfflineRegionInvalidateCallback>&);
+
     void updateOfflineRegionMetadata(jni::JNIEnv&, const jni::Array<jni::jbyte>&, const jni::Object<OfflineRegionUpdateMetadataCallback>&);
 
     static jni::Local<jni::Object<OfflineRegion>> New(jni::JNIEnv&, const jni::Object<FileSource>&, mbgl::OfflineRegion);