From a60333a5fe172d309a13b4e7efd213928973bef7 Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Fri, 8 Nov 2019 18:14:35 +0200
Subject: [android] Add OfflineRegion.deleteAndSkipPackDatabase

---
 .../mapbox/mapboxsdk/offline/OfflineRegion.java    | 50 +++++++++++++++++++++
 platform/android/src/offline/offline_region.cpp    | 51 +++++++++++++++-------
 platform/android/src/offline/offline_region.hpp    |  2 +
 3 files changed, 88 insertions(+), 15 deletions(-)

diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/offline/OfflineRegion.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/offline/OfflineRegion.java
index f13128da63..c4ba363baf 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/offline/OfflineRegion.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/offline/OfflineRegion.java
@@ -429,6 +429,53 @@ public class OfflineRegion {
     }
   }
 
+  /**
+   * Same as the method above but skipping database file packing for performance reasons.
+   * <p>
+   * This method is useful optimization e.g. when several regions should be deleted in a row.
+   * </p>
+   * <p>
+   * When the operation is complete or encounters an error, the given callback will be
+   * executed on the main thread.
+   * </p>
+   * <p>
+   * After you call this method, you may not call any additional methods on this object.
+   * </p>
+   *
+   * @param callback the callback to be invoked
+   */
+  public void deleteAndSkipPackDatabase(@NonNull final OfflineRegionDeleteCallback callback) {
+    if (!isDeleted) {
+      isDeleted = true;
+      fileSource.activate();
+      deleteOfflineRegionSkipPackDatabase(new OfflineRegionDeleteCallback() {
+        @Override
+        public void onDelete() {
+          handler.post(new Runnable() {
+            @Override
+            public void run() {
+              fileSource.deactivate();
+              callback.onDelete();
+              OfflineRegion.this.finalize();
+            }
+          });
+        }
+
+        @Override
+        public void onError(final String error) {
+          handler.post(new Runnable() {
+            @Override
+            public void run() {
+              isDeleted = false;
+              fileSource.deactivate();
+              callback.onError(error);
+            }
+          });
+        }
+      });
+    }
+  }
+
   /**
    * Invalidate all the tiles from an offline region forcing Mapbox GL to revalidate
    * the tiles with the server before using. This is more efficient than deleting the
@@ -523,6 +570,9 @@ public class OfflineRegion {
   @Keep
   private native void deleteOfflineRegion(OfflineRegionDeleteCallback callback);
 
+  @Keep
+  private native void deleteOfflineRegionSkipPackDatabase(OfflineRegionDeleteCallback callback);
+
   @Keep
   private native void updateOfflineRegionMetadata(byte[] metadata, OfflineRegionUpdateMetadataCallback callback);
 
diff --git a/platform/android/src/offline/offline_region.cpp b/platform/android/src/offline/offline_region.cpp
index ac9f491ab6..fa5f6889c0 100644
--- a/platform/android/src/offline/offline_region.cpp
+++ b/platform/android/src/offline/offline_region.cpp
@@ -101,22 +101,40 @@ void OfflineRegion::getOfflineRegionStatus(jni::JNIEnv& env_, const jni::Object<
     });
 }
 
+namespace {
+// Reattach, the callback comes from a different thread
+void handleException(std::exception_ptr exception,
+                     const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback,
+                     android::UniqueEnv env = android::AttachEnv()) {
+    if (exception) {
+        OfflineRegion::OfflineRegionDeleteCallback::onError(*env, callback, exception);
+    } else {
+        OfflineRegion::OfflineRegionDeleteCallback::onDelete(*env, callback);
+    }
+}
+} // namespace
+
 void OfflineRegion::deleteOfflineRegion(jni::JNIEnv& env_, const jni::Object<OfflineRegionDeleteCallback>& callback_) {
     auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
 
-    fileSource->deleteOfflineRegion(std::move(*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();
+    fileSource->deleteOfflineRegion(
+        std::move(*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 { handleException(error, *callback); });
+}
 
-        if (error) {
-            OfflineRegionDeleteCallback::onError(*env, *callback, error);
-        } else {
-            OfflineRegionDeleteCallback::onDelete(*env, *callback);
-        }
-    });
+void OfflineRegion::deleteOfflineRegionSkipPackDatabase(jni::JNIEnv& env_,
+                                                        const jni::Object<OfflineRegionDeleteCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
+    fileSource->deleteOfflineRegionSkipPackDatabase(
+        std::move(*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 { handleException(error, *callback); });
 }
 
 void OfflineRegion::invalidateOfflineRegion(jni::JNIEnv& env_, const jni::Object<OfflineRegionInvalidateCallback>& callback_) {
@@ -206,7 +224,10 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
 
     #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-    jni::RegisterNativePeer<OfflineRegion>( env, javaClass, "nativePtr",
+    jni::RegisterNativePeer<OfflineRegion>(
+        env,
+        javaClass,
+        "nativePtr",
         jni::MakePeer<OfflineRegion, jni::jlong, const jni::Object<FileSource>&>,
         "initialize",
         "finalize",
@@ -214,9 +235,9 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
         METHOD(&OfflineRegion::setOfflineRegionDownloadState, "setOfflineRegionDownloadState"),
         METHOD(&OfflineRegion::getOfflineRegionStatus, "getOfflineRegionStatus"),
         METHOD(&OfflineRegion::deleteOfflineRegion, "deleteOfflineRegion"),
+        METHOD(&OfflineRegion::deleteOfflineRegionSkipPackDatabase, "deleteOfflineRegionSkipPackDatabase"),
         METHOD(&OfflineRegion::invalidateOfflineRegion, "invalidateOfflineRegion"),
-        METHOD(&OfflineRegion::updateOfflineRegionMetadata, "updateOfflineRegionMetadata")
-    );
+        METHOD(&OfflineRegion::updateOfflineRegionMetadata, "updateOfflineRegionMetadata"));
 }
 
 // OfflineRegionObserver //
diff --git a/platform/android/src/offline/offline_region.hpp b/platform/android/src/offline/offline_region.hpp
index dda253469e..8a632ff7f1 100644
--- a/platform/android/src/offline/offline_region.hpp
+++ b/platform/android/src/offline/offline_region.hpp
@@ -71,6 +71,8 @@ public:
 
     void deleteOfflineRegion(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&);
 
+    void deleteOfflineRegionSkipPackDatabase(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>&);
-- 
cgit v1.2.1