Revert "[android] Use new FileSourceManager interface"

This reverts commit 6ddff19ceedb8f6cb095792b90121330afcc38cf.

10 files changed, 65 insertions, 133 deletions

diff --git a/platform/android/src/asset_manager_file_source.cpp b/platform/android/src/asset_manager_file_source.cpp
index 73ecec2b05..b9150deef9 100644
--- a/platform/android/src/asset_manager_file_source.cpp
+++ b/platform/android/src/asset_manager_file_source.cpp
@@ -1,11 +1,10 @@
 #include "asset_manager_file_source.hpp"
 
 #include <mbgl/storage/file_source_request.hpp>
-#include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
+#include <mbgl/util/util.hpp>
 #include <mbgl/util/thread.hpp>
 #include <mbgl/util/url.hpp>
-#include <mbgl/util/util.hpp>
 
 #include <android/asset_manager.h>
 #include <android/asset_manager_jni.h>
@@ -55,8 +54,4 @@ std::unique_ptr<AsyncRequest> AssetManagerFileSource::request(const Resource& re
     return std::move(req);
 }
 
-bool AssetManagerFileSource::canRequest(const Resource& resource) const {
-    return 0 == resource.url.rfind(mbgl::util::ASSET_PROTOCOL, 0);
-}
-
 } // namespace mbgl
diff --git a/platform/android/src/asset_manager_file_source.hpp b/platform/android/src/asset_manager_file_source.hpp
index bcbc6f1e9d..4ec5b4c30e 100644
--- a/platform/android/src/asset_manager_file_source.hpp
+++ b/platform/android/src/asset_manager_file_source.hpp
@@ -18,7 +18,6 @@ public:
     ~AssetManagerFileSource() override;
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
-    bool canRequest(const Resource&) const override;
 
 private:
     class Impl;
diff --git a/platform/android/src/file_source.cpp b/platform/android/src/file_source.cpp
index 8bbe9acbd2..a002d6616f 100644
--- a/platform/android/src/file_source.cpp
+++ b/platform/android/src/file_source.cpp
@@ -5,7 +5,6 @@
 
 #include <mbgl/actor/actor.hpp>
 #include <mbgl/actor/scheduler.hpp>
-#include <mbgl/storage/file_source_manager.hpp>
 #include <mbgl/storage/resource_options.hpp>
 #include <mbgl/storage/resource_transform.hpp>
 #include <mbgl/util/logging.hpp>
@@ -15,6 +14,21 @@
 #include "asset_manager_file_source.hpp"
 
 namespace mbgl {
+
+std::shared_ptr<FileSource> FileSource::createPlatformFileSource(const ResourceOptions& options) {
+    auto env{android::AttachEnv()};
+    std::shared_ptr<DefaultFileSource> fileSource;
+    if (android::Mapbox::hasInstance(*env)) {
+        auto assetManager = android::Mapbox::getAssetManager(*env);
+        fileSource = std::make_shared<DefaultFileSource>(options.cachePath(),
+                                                         std::make_unique<AssetManagerFileSource>(*env, assetManager));
+    } else {
+        fileSource = std::make_shared<DefaultFileSource>(options.cachePath(), options.assetPath());
+    }
+    fileSource->setAccessToken(options.accessToken());
+    return fileSource;
+}
+
 namespace android {
 
 // FileSource //
@@ -23,99 +37,53 @@ FileSource::FileSource(jni::JNIEnv& _env, const jni::String& accessToken, const
     std::string path = jni::Make<std::string>(_env, _cachePath);
     mapbox::sqlite::setTempPath(path);
 
-    mbgl::FileSourceManager::get()->registerFileSourceFactory(
-        mbgl::FileSourceType::Asset, [](const mbgl::ResourceOptions&) {
-            auto env{android::AttachEnv()};
-            std::unique_ptr<mbgl::FileSource> assetFileSource;
-            if (android::Mapbox::hasInstance(*env)) {
-                auto assetManager = android::Mapbox::getAssetManager(*env);
-                assetFileSource = std::make_unique<AssetManagerFileSource>(*env, assetManager);
-            }
-            return assetFileSource;
-        });
-
     resourceOptions.withAccessToken(accessToken ? jni::Make<std::string>(_env, accessToken) : "")
         .withCachePath(path + DATABASE_FILE);
 
-    // Create a core file sources
-    // TODO: Split Android FileSource API to smaller interfaces
-    resourceLoader =
-        mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::ResourceLoader, resourceOptions);
-    databaseSource = std::static_pointer_cast<mbgl::DatabaseFileSource>(
-        mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Database, resourceOptions));
-    onlineSource = std::static_pointer_cast<mbgl::OnlineFileSource>(
-        mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, resourceOptions));
+    // Create a core default file source
+    fileSource = std::static_pointer_cast<mbgl::DefaultFileSource>(mbgl::FileSource::getSharedFileSource(resourceOptions));
 }
 
 FileSource::~FileSource() {
 }
 
 jni::Local<jni::String> FileSource::getAccessToken(jni::JNIEnv& env) {
-    if (auto* token = onlineSource->getProperty(mbgl::ACCESS_TOKEN_KEY).getString()) {
-        return jni::Make<jni::String>(env, *token);
-    }
-
-    ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Online functionality is disabled.");
-    return jni::Make<jni::String>(env, "");
+    return jni::Make<jni::String>(env, fileSource->getAccessToken());
 }
 
 void FileSource::setAccessToken(jni::JNIEnv& env, const jni::String& token) {
-    if (onlineSource) {
-        onlineSource->setProperty(mbgl::ACCESS_TOKEN_KEY, token ? jni::Make<std::string>(env, token) : "");
-    } else {
-        ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Online functionality is disabled.");
-    }
+    fileSource->setAccessToken(token ? jni::Make<std::string>(env, token) : "");
 }
 
 void FileSource::setAPIBaseUrl(jni::JNIEnv& env, const jni::String& url) {
-    if (onlineSource) {
-        onlineSource->setProperty(mbgl::API_BASE_URL_KEY, jni::Make<std::string>(env, url));
-    } else {
-        ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Online functionality is disabled.");
-    }
+    fileSource->setAPIBaseURL(jni::Make<std::string>(env, url));
 }
 
 void FileSource::setResourceTransform(jni::JNIEnv& env, const jni::Object<FileSource::ResourceTransformCallback>& transformCallback) {
-    // Core could be built without support for network resource provider.
-    if (!onlineSource) {
-        ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Online functionality is disabled.");
-        return;
-    }
-
     if (transformCallback) {
         auto global = jni::NewGlobal<jni::EnvAttachingDeleter>(env, transformCallback);
-        resourceTransform = std::make_unique<Actor<ResourceTransform::TransformCallback>>(
+        resourceTransform = std::make_unique<Actor<ResourceTransform>>(
             *Scheduler::GetCurrent(),
             // Capture the ResourceTransformCallback object as a managed global into
             // the lambda. It is released automatically when we're setting a new ResourceTransform in
             // a subsequent call.
             // Note: we're converting it to shared_ptr because this lambda is converted to a std::function,
             // which requires copyability of its captured variables.
-            [callback = std::make_shared<decltype(global)>(std::move(global))](
-                mbgl::Resource::Kind kind, const std::string& url_, ResourceTransform::FinishedCallback cb) {
+            [callback = std::make_shared<decltype(global)>(std::move(global))](mbgl::Resource::Kind kind,
+                                                                               const std::string& url_) {
                 android::UniqueEnv _env = android::AttachEnv();
-                cb(FileSource::ResourceTransformCallback::onURL(*_env, *callback, int(kind), url_));
+                return FileSource::ResourceTransformCallback::onURL(*_env, *callback, int(kind), url_);
             });
-        onlineSource->setResourceTransform(
-            {[actorRef = resourceTransform->self()](
-                 Resource::Kind kind, const std::string& url, ResourceTransform::FinishedCallback cb) {
-                actorRef.invoke(&ResourceTransform::TransformCallback::operator(), kind, url, std::move(cb));
-            }});
+        fileSource->setResourceTransform(resourceTransform->self());
     } else {
         // Reset the callback
         resourceTransform.reset();
-        onlineSource->setResourceTransform({});
+        fileSource->setResourceTransform({});
     }
 }
 
-void FileSource::setResourceCachePath(jni::JNIEnv& env,
-                                      const jni::String& path,
+void FileSource::setResourceCachePath(jni::JNIEnv& env, const jni::String& path,
                                       const jni::Object<FileSource::ResourcesCachePathChangeCallback>& _callback) {
-    if (!databaseSource) {
-        ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Offline functionality is disabled.");
-        return;
-    }
-
     if (pathChangeCallback) {
         FileSource::ResourcesCachePathChangeCallback::onError(env, _callback, jni::Make<jni::String>(env, "Another resources cache path change is in progress"));
         return;
@@ -125,22 +93,17 @@ void FileSource::setResourceCachePath(jni::JNIEnv& env,
     mapbox::sqlite::setTempPath(newPath);
 
     auto global = jni::NewGlobal<jni::EnvAttachingDeleter>(env, _callback);
-    pathChangeCallback = Scheduler::GetCurrent()->bindOnce(
-        [this, callback = std::make_shared<decltype(global)>(std::move(global)), newPath] {
-            android::UniqueEnv _env = android::AttachEnv();
-            FileSource::ResourcesCachePathChangeCallback::onSuccess(
-                *_env, *callback, jni::Make<jni::String>(*_env, newPath));
-            pathChangeCallback = {};
-        });
+    pathChangeCallback = std::make_unique<Actor<PathChangeCallback>>(*Scheduler::GetCurrent(),
+            [this, callback = std::make_shared<decltype(global)>(std::move(global)), newPath] {
+                android::UniqueEnv _env = android::AttachEnv();
+                FileSource::ResourcesCachePathChangeCallback::onSuccess(*_env, *callback, jni::Make<jni::String>(*_env, newPath));
+                pathChangeCallback.reset();
+            });
 
-    databaseSource->setDatabasePath(newPath + DATABASE_FILE, pathChangeCallback);
+    fileSource->setResourceCachePath(newPath + DATABASE_FILE, pathChangeCallback->self());
 }
 
 void FileSource::resume(jni::JNIEnv&) {
-    if (!resourceLoader) {
-        return;
-    }
-
     if (!activationCounter) {
         activationCounter = optional<int>(1) ;
         return;
@@ -148,19 +111,15 @@ void FileSource::resume(jni::JNIEnv&) {
 
     activationCounter.value()++;
     if (activationCounter == 1) {
-        resourceLoader->resume();
+        fileSource->resume();
     }
 }
 
 void FileSource::pause(jni::JNIEnv&) {
-    if (!resourceLoader) {
-        return;
-    }
-
     if (activationCounter) {
         activationCounter.value()--;
         if (activationCounter == 0) {
-            resourceLoader->pause();
+            fileSource->pause();
         }
     }
 }
@@ -178,15 +137,10 @@ FileSource* FileSource::getNativePeer(jni::JNIEnv& env, const jni::Object<FileSo
     return reinterpret_cast<FileSource *>(jFileSource.Get(env, field));
 }
 
-mbgl::ResourceOptions FileSource::getSharedResourceOptions(jni::JNIEnv& env,
-                                                           const jni::Object<FileSource>& jFileSource) {
+mbgl::ResourceOptions FileSource::getSharedResourceOptions(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource) {
     FileSource* fileSource = FileSource::getNativePeer(env, jFileSource);
-    // Core could be compiled without support for any sources.
-    if (fileSource) {
-        return fileSource->resourceOptions.clone();
-    }
-
-    return {};
+    assert(fileSource != nullptr);
+    return fileSource->resourceOptions.clone();
 }
 
 // FileSource::ResourcesCachePathChangeCallback //
diff --git a/platform/android/src/file_source.hpp b/platform/android/src/file_source.hpp
index 591bfbc93e..6a9190fa06 100644
--- a/platform/android/src/file_source.hpp
+++ b/platform/android/src/file_source.hpp
@@ -1,9 +1,7 @@
 #pragma once
 
-#include <mbgl/storage/database_file_source.hpp>
-#include <mbgl/storage/online_file_source.hpp>
+#include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/storage/resource_options.hpp>
-#include <mbgl/storage/resource_transform.hpp>
 
 #include "asset_manager.hpp"
 
@@ -12,12 +10,13 @@
 namespace mbgl {
 
 template <typename T> class Actor;
+class ResourceTransform;
+using mbgl::PathChangeCallback;
 
 namespace android {
 
 /**
- * Peer class for the Android FileSource holder. Ensures that a single core FileSource
- * of a ResourceLoader type is used.
+ * Peer class for the Android FileSource holder. Ensures that a single DefaultFileSource is used
  */
 class FileSource {
 public:
@@ -72,12 +71,11 @@ private:
     const std::string DATABASE_FILE = "/mbgl-offline.db";
     optional<int> activationCounter;
     mbgl::ResourceOptions resourceOptions;
-    std::unique_ptr<Actor<ResourceTransform::TransformCallback>> resourceTransform;
-    std::function<void()> pathChangeCallback;
-    std::shared_ptr<mbgl::DatabaseFileSource> databaseSource;
-    std::shared_ptr<mbgl::OnlineFileSource> onlineSource;
-    std::shared_ptr<mbgl::FileSource> resourceLoader;
+    std::unique_ptr<Actor<ResourceTransform>> resourceTransform;
+    std::unique_ptr<Actor<PathChangeCallback>> pathChangeCallback;
+    std::shared_ptr<mbgl::DefaultFileSource> fileSource;
 };
 
+
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/http_file_source.cpp b/platform/android/src/http_file_source.cpp
index 37f7307373..7066918fef 100644
--- a/platform/android/src/http_file_source.cpp
+++ b/platform/android/src/http_file_source.cpp
@@ -3,11 +3,10 @@
 #include <mbgl/storage/response.hpp>
 #include <mbgl/util/logging.hpp>
 
-#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/async_task.hpp>
-#include <mbgl/util/http_header.hpp>
-#include <mbgl/util/string.hpp>
 #include <mbgl/util/util.hpp>
+#include <mbgl/util/string.hpp>
+#include <mbgl/util/http_header.hpp>
 
 #include <jni/jni.hpp>
 #include "attach_env.hpp"
diff --git a/platform/android/src/jni_native.cpp b/platform/android/src/jni_native.cpp
index d6b03d981e..bcbdfcf484 100644
--- a/platform/android/src/jni_native.cpp
+++ b/platform/android/src/jni_native.cpp
@@ -66,7 +66,7 @@ void registerNatives(JavaVM *vm) {
 
     jni::JNIEnv& env = jni::GetEnv(*vm, jni::jni_version_1_6);
 
-    // For the FileSource
+    // For the DefaultFileSource
     static mbgl::util::RunLoop mainRunLoop;
     FileSource::registerNative(env);
 
diff --git a/platform/android/src/offline/offline_manager.cpp b/platform/android/src/offline/offline_manager.cpp
index 98f2b88a7f..be864e18aa 100644
--- a/platform/android/src/offline/offline_manager.cpp
+++ b/platform/android/src/offline/offline_manager.cpp
@@ -1,7 +1,5 @@
 #include "offline_manager.hpp"
 
-#include <mbgl/storage/file_source_manager.hpp>
-#include <mbgl/storage/resource.hpp>
 #include <mbgl/util/string.hpp>
 
 #include "../attach_env.hpp"
@@ -25,12 +23,7 @@ void handleException(std::exception_ptr exception,
 
 // OfflineManager //
 OfflineManager::OfflineManager(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource)
-    : fileSource(std::static_pointer_cast<mbgl::DatabaseFileSource>(mbgl::FileSourceManager::get()->getFileSource(
-          mbgl::FileSourceType::Database, FileSource::getSharedResourceOptions(env, jFileSource)))) {
-    if (!fileSource) {
-        ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Offline functionality is disabled.");
-    }
-}
+    : fileSource(std::static_pointer_cast<DefaultFileSource>(mbgl::FileSource::getSharedFileSource(FileSource::getSharedResourceOptions(env, jFileSource)))) {}
 
 OfflineManager::~OfflineManager() {}
 
diff --git a/platform/android/src/offline/offline_manager.hpp b/platform/android/src/offline/offline_manager.hpp
index 84111a7423..0af92f8115 100644
--- a/platform/android/src/offline/offline_manager.hpp
+++ b/platform/android/src/offline/offline_manager.hpp
@@ -12,6 +12,8 @@
 
 namespace mbgl {
 
+class DefaultFileSource;
+
 namespace android {
 
 class OfflineManager {
@@ -104,7 +106,7 @@ public:
     void runPackDatabaseAutomatically(jni::JNIEnv&, jboolean autopack);
 
 private:
-    std::shared_ptr<mbgl::DatabaseFileSource> fileSource;
+    std::shared_ptr<mbgl::DefaultFileSource> fileSource;
 };
 
 } // namespace android
diff --git a/platform/android/src/offline/offline_region.cpp b/platform/android/src/offline/offline_region.cpp
index 4ee835bab3..4276ce8f45 100644
--- a/platform/android/src/offline/offline_region.cpp
+++ b/platform/android/src/offline/offline_region.cpp
@@ -1,6 +1,5 @@
 #include "offline_region.hpp"
 
-#include <mbgl/storage/file_source_manager.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/string.hpp>
 
@@ -15,13 +14,8 @@ namespace android {
 // OfflineRegion //
 
 OfflineRegion::OfflineRegion(jni::JNIEnv& env, jni::jlong offlineRegionPtr, const jni::Object<FileSource>& jFileSource)
-    : region(reinterpret_cast<mbgl::OfflineRegion*>(offlineRegionPtr)),
-      fileSource(std::static_pointer_cast<mbgl::DatabaseFileSource>(mbgl::FileSourceManager::get()->getFileSource(
-          mbgl::FileSourceType::Database, FileSource::getSharedResourceOptions(env, jFileSource)))) {
-    if (!fileSource) {
-        ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Offline functionality is disabled.");
-    }
-}
+    : region(reinterpret_cast<mbgl::OfflineRegion *>(offlineRegionPtr))
+    , fileSource(std::static_pointer_cast<DefaultFileSource>(mbgl::FileSource::getSharedFileSource(FileSource::getSharedResourceOptions(env, jFileSource)))) {}
 
 OfflineRegion::~OfflineRegion() {}
 
@@ -165,17 +159,15 @@ void OfflineRegion::updateOfflineRegionMetadata(jni::JNIEnv& env_, const jni::Ar
     });
 }
 
-jni::Local<jni::Object<OfflineRegion>> OfflineRegion::New(jni::JNIEnv& env,
-                                                          const jni::Object<FileSource>& jFileSource,
-                                                          mbgl::OfflineRegion region) {
+jni::Local<jni::Object<OfflineRegion>> OfflineRegion::New(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource, mbgl::OfflineRegion region) {
+
     // Definition
     auto definition = region.getDefinition().match(
-        [&](const mbgl::OfflineTilePyramidRegionDefinition def) {
-            return OfflineTilePyramidRegionDefinition::New(env, def);
-        },
-        [&](const mbgl::OfflineGeometryRegionDefinition def) {
-            return OfflineGeometryRegionDefinition::New(env, def);
-        });
+            [&](const mbgl::OfflineTilePyramidRegionDefinition def) {
+                return OfflineTilePyramidRegionDefinition::New(env, def);
+            }, [&](const mbgl::OfflineGeometryRegionDefinition def) {
+                return OfflineGeometryRegionDefinition::New(env, def);
+            });
 
     // Create region java object
     static auto& javaClass = jni::Class<OfflineRegion>::Singleton(env);
diff --git a/platform/android/src/offline/offline_region.hpp b/platform/android/src/offline/offline_region.hpp
index 6844008bb4..dda253469e 100644
--- a/platform/android/src/offline/offline_region.hpp
+++ b/platform/android/src/offline/offline_region.hpp
@@ -85,7 +85,7 @@ public:
 
 private:
     std::unique_ptr<mbgl::OfflineRegion> region;
-    std::shared_ptr<mbgl::DatabaseFileSource> fileSource;
+    std::shared_ptr<mbgl::DefaultFileSource> fileSource;
 };
 
 } // namespace android