kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

[android] Revert to original chunk downloader

Browse source 
Android DownloadManager is unreliable.

Signed-off-by: Roman Tsisyk <roman@tsisyk.com>
This commit is contained in:
Roman Tsisyk 2021-08-22 20:26:57 +03:00
parent 6706271190
commit 14fd1bac17
18 changed files with 1 additions and 796 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
android/AndroidManifest.xml
View file

@ -325,20 +325,6 @@
android:permission="android.permission.BIND_JOB_SERVICE"
android:exported="false"/>
<receiver
android:name="com.mapswithme.maps.background.SystemDownloadCompletedReceiver"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>
</intent-filter>
</receiver>
<service
android:name="com.mapswithme.maps.background.SystemDownloadCompletedService"
android:permission="android.permission.BIND_JOB_SERVICE"
android:exported="false">
</service>
<!-- Catches app upgraded intent -->
<receiver android:name=".background.UpgradeReceiver">
<intent-filter>

2
android/jni/CMakeLists.txt
View file

@ -26,7 +26,6 @@ set(
com/mapswithme/core/logging.hpp
com/mapswithme/core/ScopedEnv.hpp
com/mapswithme/core/ScopedLocalRef.hpp
com/mapswithme/maps/DownloaderAdapter.hpp
com/mapswithme/maps/Framework.hpp
com/mapswithme/maps/SearchEngine.hpp
com/mapswithme/opengl/android_gl_utils.hpp
@ -43,7 +42,6 @@ set(
com/mapswithme/core/logging.cpp
com/mapswithme/maps/bookmarks/data/BookmarkManager.cpp
com/mapswithme/maps/DisplayedCategories.cpp
com/mapswithme/maps/DownloaderAdapter.cpp
com/mapswithme/maps/DownloadResourcesLegacyActivity.cpp
com/mapswithme/maps/editor/Editor.cpp
com/mapswithme/maps/editor/OpeningHours.cpp

208
android/jni/com/mapswithme/maps/DownloaderAdapter.cpp
View file

@ -1,208 +0,0 @@
#include "com/mapswithme/maps/DownloaderAdapter.hpp"
#include "com/mapswithme/core/jni_helper.hpp"
#include "com/mapswithme/platform/Platform.hpp"
#include "storage/downloader.hpp"
#include "base/assert.hpp"
#include "base/file_name_utils.hpp"
#include "base/string_utils.hpp"
#include <memory>
#include <unordered_map>
#include <utility>
using Callbacks = std::pair<std::function<void(bool status)>,
std::function<void(int64_t downloaded, int64_t total)>>;
static std::unordered_map<int64_t, Callbacks> g_completionHandlers;
namespace storage
{
BackgroundDownloaderAdapter::BackgroundDownloaderAdapter()
{
auto env = jni::GetEnv();
auto downloadManagerClazz = jni::GetGlobalClassRef(env, "com/mapswithme/maps/downloader/MapDownloadManager");
auto from = jni::GetStaticMethodID(env, downloadManagerClazz, "from",
"(Landroid/content/Context;)Lcom/mapswithme/maps/downloader/MapDownloadManager;");
auto context = android::Platform::Instance().GetContext();
m_downloadManager = jni::make_global_ref(env->CallStaticObjectMethod(downloadManagerClazz, from, context));
m_downloadManagerRemove = env->GetMethodID(downloadManagerClazz, "remove","(J)V");
m_downloadManagerEnqueue = env->GetMethodID(downloadManagerClazz, "enqueue", "(Ljava/lang/String;)J");
jni::HandleJavaException(env);
}
BackgroundDownloaderAdapter::~BackgroundDownloaderAdapter()
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
g_completionHandlers.clear();
}
void BackgroundDownloaderAdapter::Remove(CountryId const & countryId)
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
MapFilesDownloader::Remove(countryId);
if (!m_queue.Contains(countryId))
return;
auto const id = m_queue.GetTaskInfoForCountryId(countryId);
if (id)
{
RemoveByRequestId(*id);
g_completionHandlers.erase(*id);
}
m_queue.Remove(countryId);
}
void BackgroundDownloaderAdapter::Clear()
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
MapFilesDownloader::Clear();
m_queue.ForEachTaskInfo([this](auto const id)
{
RemoveByRequestId(id);
g_completionHandlers.erase(id);
});
m_queue.Clear();
}
QueueInterface const & BackgroundDownloaderAdapter::GetQueue() const
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
if (m_queue.IsEmpty())
return MapFilesDownloader::GetQueue();
return m_queue;
}
void BackgroundDownloaderAdapter::Download(QueuedCountry && queuedCountry)
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
if (!IsDownloadingAllowed())
{
queuedCountry.OnDownloadFinished(downloader::DownloadStatus::Failed);
return;
}
auto const countryId = queuedCountry.GetCountryId();
auto urls = MakeUrlList(queuedCountry.GetRelativeUrl());
// Get urls order from worst to best.
std::reverse(urls.begin(), urls.end());
auto const path = queuedCountry.GetFileDownloadPath();
// For safety reasons, add to the queue first and notify start downloading then,
// to avoid possible recursion.
m_queue.Append(QueuedCountry(queuedCountry));
queuedCountry.OnStartDownloading();
DownloadFromLastUrl(countryId, path, std::move(urls));
}
void BackgroundDownloaderAdapter::DownloadFromLastUrl(CountryId const & countryId,
std::string const & downloadPath,
std::vector<std::string> && urls)
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
if (urls.empty())
return;
auto env = jni::GetEnv();
jni::TScopedLocalRef url(env, jni::ToJavaString(env, urls.back()));
auto id = static_cast<int64_t>(env->CallLongMethod(*m_downloadManager, m_downloadManagerEnqueue, url.get()));
urls.pop_back();
jni::HandleJavaException(env);
m_queue.SetTaskInfoForCountryId(countryId, id);
auto onFinish = [this, countryId, downloadPath, urls = std::move(urls)](bool status) mutable
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
if (!m_queue.Contains(countryId))
return;
if (!status && !urls.empty())
{
DownloadFromLastUrl(countryId, downloadPath, std::move(urls));
}
else
{
auto const country = m_queue.GetCountryById(countryId);
m_queue.Remove(countryId);
country.OnDownloadFinished(status
? downloader::DownloadStatus::Completed
: downloader::DownloadStatus::Failed);
}
};
auto onProgress = [this, countryId](int64_t bytesDownloaded, int64_t bytesTotal)
{
CHECK_THREAD_CHECKER(m_threadChecker, ());
if (!m_queue.Contains(countryId))
return;
auto const & country = m_queue.GetCountryById(countryId);
country.OnDownloadProgress({bytesDownloaded, bytesTotal});
};
g_completionHandlers.emplace(id, Callbacks(onFinish, onProgress));
}
void BackgroundDownloaderAdapter::RemoveByRequestId(int64_t id)
{
auto env = jni::GetEnv();
env->CallVoidMethod(*m_downloadManager, m_downloadManagerRemove, static_cast<jlong>(id));
jni::HandleJavaException(env);
}
std::unique_ptr<MapFilesDownloader> GetDownloader()
{
return std::make_unique<BackgroundDownloaderAdapter>();
}
} // namespace storage
extern "C" {
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_downloader_MapManager_nativeOnDownloadFinished(JNIEnv *, jclass,
jboolean status, jlong id)
{
auto const it = g_completionHandlers.find(static_cast<int64_t>(id));
if (it == g_completionHandlers.end())
return;
it->second.first(static_cast<bool>(status));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_downloader_MapManager_nativeOnDownloadProgress(JNIEnv *, jclass, jlong id,
jlong bytesDownloaded,
jlong bytesTotal)
{
auto const it = g_completionHandlers.find(static_cast<int64_t>(id));
if (it == g_completionHandlers.end())
return;
it->second.second(static_cast<int64_t>(bytesDownloaded), static_cast<int64_t>(bytesTotal));
}
JNIEXPORT jboolean JNICALL
Java_com_mapswithme_maps_downloader_MapManager_nativeHasPendingDownloads(JNIEnv *, jclass)
{
return !g_completionHandlers.empty();
}
} // extern "C"

48
android/jni/com/mapswithme/maps/DownloaderAdapter.hpp
View file

@ -1,48 +0,0 @@
#pragma once
#include "storage/background_downloading/downloader_queue.hpp"
#include "storage/storage_defines.hpp"
#include "storage/map_files_downloader_with_ping.hpp"
#include "base/thread_checker.hpp"
#include <jni.h>
#include <cstdint>
#include <memory>
#include <optional>
namespace storage
{
class BackgroundDownloaderAdapter : public MapFilesDownloaderWithPing
{
public:
BackgroundDownloaderAdapter();
~BackgroundDownloaderAdapter();
// MapFilesDownloader overrides:
void Remove(CountryId const & countryId) override;
void Clear() override;
QueueInterface const & GetQueue() const override;
private:
// MapFilesDownloaderWithServerList overrides:
void Download(QueuedCountry && queuedCountry) override;
// Trying to download mwm from different servers recursively.
void DownloadFromLastUrl(CountryId const & countryId, std::string const & downloadPath,
std::vector<std::string> && urls);
void RemoveByRequestId(int64_t id);
BackgroundDownloaderQueue<int64_t> m_queue;
jmethodID m_downloadManagerRemove = nullptr;
jmethodID m_downloadManagerEnqueue = nullptr;
std::shared_ptr<jobject> m_downloadManager;
DECLARE_THREAD_CHECKER(m_threadChecker);
};
} // namespace storage

12
android/jni/com/mapswithme/maps/MapManager.cpp
View file

@ -576,16 +576,4 @@ Java_com_mapswithme_maps_downloader_MapManager_nativeGetSelectedCountry(JNIEnv *
storage::CountryId const & res = g_framework->GetPlacePageInfo().GetCountryId();
return (res == storage::kInvalidCountryId ? nullptr : jni::ToJavaString(env, res));
}
JNIEXPORT jboolean JNICALL
Java_com_mapswithme_maps_downloader_MapManager_nativeIsUrlSupported(JNIEnv * env, jclass, jstring url)
{
return static_cast<jboolean>(downloader::IsUrlSupported(jni::ToNativeString(env, url)));
}
JNIEXPORT jstring JNICALL
Java_com_mapswithme_maps_downloader_MapManager_nativeGetFilePathByUrl(JNIEnv * env, jclass, jstring url)
{
return jni::ToJavaString(env, downloader::GetFilePathByUrl(jni::ToNativeString(env, url)));
}
} // extern "C"

1
android/multidex-config.txt
View file

@ -4,7 +4,6 @@ com/mapswithme/maps/bookmarks/data/Bookmark.class
com/mapswithme/maps/bookmarks/data/ElevationInfo.class
com/mapswithme/maps/bookmarks/data/FeatureId.class
com/mapswithme/maps/bookmarks/data/MapObject.class
com/mapswithme/maps/downloader/MapDownloadManager.class
com/mapswithme/maps/location/PlatformSocket.class
com/mapswithme/maps/search/PopularityProvider.class
com/mapswithme/maps/widget/placepage/PlacePageData.class

12
android/src/com/mapswithme/maps/MwmApplication.java
View file

@ -17,7 +17,6 @@ import com.mapswithme.maps.background.Notifier;
import com.mapswithme.maps.base.MediaPlayerWrapper;
import com.mapswithme.maps.bookmarks.data.BookmarkManager;
import com.mapswithme.maps.downloader.CountryItem;
import com.mapswithme.maps.downloader.MapDownloadManager;
import com.mapswithme.maps.downloader.MapManager;
import com.mapswithme.maps.editor.Editor;
import com.mapswithme.maps.location.LocationHelper;
@ -59,10 +58,6 @@ public class MwmApplication extends Application implements AppBackgroundTracker.
@NonNull
private IsolinesManager mIsolinesManager;
@SuppressWarnings("NotNullFieldNotInitialized")
@NonNull
private MapDownloadManager mMapDownloadManager;
private volatile boolean mFrameworkInitialized;
private volatile boolean mPlatformInitialized;
@ -148,7 +143,6 @@ public class MwmApplication extends Application implements AppBackgroundTracker.
mBackgroundTracker = new AppBackgroundTracker(this);
mSubwayManager = new SubwayManager(this);
mIsolinesManager = new IsolinesManager(this);
mMapDownloadManager = new MapDownloadManager(this);
mPlayer = new MediaPlayerWrapper(this);
WebView.setWebContentsDebuggingEnabled(Utils.isDebugOrBeta());
@ -323,12 +317,6 @@ public class MwmApplication extends Application implements AppBackgroundTracker.
nativeOnTransit(foreground);
}
@NonNull
public MapDownloadManager getMapDownloadManager()
{
return mMapDownloadManager;
}
private class StorageCallbackImpl implements MapManager.StorageCallback
{
@Override

25
android/src/com/mapswithme/maps/background/SystemDownloadCompletedReceiver.java
View file

@ -1,25 +0,0 @@
package com.mapswithme.maps.background;
import android.app.DownloadManager;
import android.content.Context;
import android.content.Intent;
import androidx.annotation.NonNull;
import androidx.core.app.JobIntentService;
import com.mapswithme.maps.MwmBroadcastReceiver;
import com.mapswithme.maps.scheduling.JobIdMap;
public class SystemDownloadCompletedReceiver extends MwmBroadcastReceiver
{
@Override
public void onReceiveInitialized(@NonNull Context context, @NonNull Intent intent)
{
DownloadManager manager = (DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE);
if (manager == null)
throw new IllegalStateException("Failed to get a download manager");
intent.setClass(context, SystemDownloadCompletedService.class);
int jobId = JobIdMap.getId(SystemDownloadCompletedService.class);
JobIntentService.enqueueWork(context, SystemDownloadCompletedService.class, jobId, intent);
}
}

58
android/src/com/mapswithme/maps/background/SystemDownloadCompletedService.java
View file

@ -1,58 +0,0 @@
package com.mapswithme.maps.background;
import android.app.DownloadManager;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import androidx.annotation.NonNull;
import androidx.core.app.JobIntentService;
import com.mapswithme.maps.MwmApplication;
import com.mapswithme.maps.MwmJobIntentService;
import com.mapswithme.maps.downloader.MapDownloadCompletedProcessor;
import com.mapswithme.util.Utils;
public class SystemDownloadCompletedService extends MwmJobIntentService
{
private interface DownloadProcessor
{
boolean process(@NonNull Context context, long id, @NonNull Cursor cursor);
}
@Override
protected void onHandleWorkInitialized(@NonNull Intent intent)
{
DownloadManager manager = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
if (manager == null)
throw new IllegalStateException("Failed to get a download manager");
processIntent(manager, intent);
}
private void processIntent(@NonNull DownloadManager manager, @NonNull Intent intent)
{
Cursor cursor = null;
try
{
final long id = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, 0);
DownloadManager.Query query = new DownloadManager.Query().setFilterById(id);
cursor = manager.query(query);
if (!cursor.moveToFirst())
return;
final DownloadProcessor[] processors = {
MapDownloadCompletedProcessor::process
};
for (DownloadProcessor processor : processors)
{
if (processor.process(getApplicationContext(), id, cursor))
break;
}
}
finally
{
Utils.closeSafely(cursor);
}
}
}

16
android/src/com/mapswithme/maps/downloader/DownloaderFragment.java
View file

@ -171,22 +171,6 @@ public class DownloaderFragment extends BaseMwmRecyclerFragment<DownloaderAdapte
getRecyclerView().removeOnScrollListener(mScrollListener);
}
@Override
public void onResume()
{
super.onResume();
MapDownloadManager.from(requireContext()).startProgressTracking();
}
@Override
public void onPause()
{
super.onPause();
MapDownloadManager.from(requireContext()).stopProgressTracking();
}
@Override
public boolean onBackPressed()
{

109
android/src/com/mapswithme/maps/downloader/MapDownloadCompletedProcessor.java
View file

@ -1,109 +0,0 @@
package com.mapswithme.maps.downloader;
import android.app.DownloadManager;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.text.TextUtils;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.WorkerThread;
import com.mapswithme.maps.MwmApplication;
import com.mapswithme.util.StorageUtils;
import com.mapswithme.util.concurrency.UiThread;
import com.mapswithme.util.log.Logger;
import com.mapswithme.util.log.LoggerFactory;
import java.io.File;
import java.io.IOException;
public class MapDownloadCompletedProcessor
{
private static final Logger LOGGER = LoggerFactory.INSTANCE.getLogger(LoggerFactory.Type.DOWNLOADER);
private static final String TAG = MapDownloadCompletedProcessor.class.getSimpleName();
@WorkerThread
public static boolean process(@NonNull Context context, long id, @NonNull Cursor cursor)
{
try
{
String targetUri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_URI));
String targetUriPath = Uri.parse(targetUri).getPath();
if (TextUtils.isEmpty(targetUriPath) || !MapManager.nativeIsUrlSupported(targetUriPath))
return false;
int status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS));
String downloadedFileUri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
boolean result = processColumns(context, status, targetUri, downloadedFileUri);
UiThread.run(new MapDownloadCompletedTask(context, result, id));
LOGGER.d(TAG, "Processing for map downloading for request id " + id + " is finished.");
return true;
}
catch (Exception e)
{
LOGGER.e(TAG, "Failed to process map download for request id " + id + ". Exception ", e);
return false;
}
}
private static boolean processColumns(@NonNull Context context, int status,
@Nullable String targetUri, @Nullable String localFileUri)
{
String targetUriPath = Uri.parse(targetUri).getPath();
Uri downloadedFileUri = Uri.parse(localFileUri);
if (status != DownloadManager.STATUS_SUCCESSFUL || TextUtils.isEmpty(targetUriPath)
|| downloadedFileUri == null)
{
return false;
}
String dstPath = MapManager.nativeGetFilePathByUrl(targetUriPath);
ContentResolver resolver = context.getContentResolver();
try
{
if (!StorageUtils.copyFile(resolver, downloadedFileUri, new File(dstPath)))
return false;
resolver.delete(downloadedFileUri, null, null);
return true;
}
catch (IOException e)
{
LOGGER.e(TAG, "Failed to copy or delete downloaded map file from " + downloadedFileUri.toString() +
" to " + dstPath + ". Exception ", e);
return false;
}
}
private static class MapDownloadCompletedTask implements Runnable
{
@NonNull
private final Context mAppContext;
private final boolean mStatus;
private final long mId;
private MapDownloadCompletedTask(@NonNull Context applicationContext, boolean status, long id)
{
mAppContext = applicationContext;
mStatus = status;
mId = id;
}
@Override
@MainThread
public void run()
{
MwmApplication application = MwmApplication.from(mAppContext);
MapDownloadManager manager = MapDownloadManager.from(application);
manager.onDownloadFinished(mStatus, mId);
}
}
}

171
android/src/com/mapswithme/maps/downloader/MapDownloadManager.java
View file

@ -1,171 +0,0 @@
package com.mapswithme.maps.downloader;
import android.app.DownloadManager;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.text.TextUtils;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.mapswithme.maps.MwmApplication;
import com.mapswithme.maps.R;
import com.mapswithme.util.Utils;
import com.mapswithme.util.log.Logger;
import com.mapswithme.util.log.LoggerFactory;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
public class MapDownloadManager
{
private static final Logger LOGGER = LoggerFactory.INSTANCE.getLogger(LoggerFactory.Type.DOWNLOADER);
private static final String TAG = MapDownloadManager.class.getSimpleName();
@NonNull
private DownloadManager mDownloadManager;
@Nullable
private Map<String, Long> mRestoredRequests;
@NonNull
private MapDownloadProgressTracker mProgressTracker;
@NonNull
private String mAppName;
public MapDownloadManager(@NonNull Context context)
{
DownloadManager downloadManager =
(DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE);
if (downloadManager == null)
throw new NullPointerException("Download manager is null, failed to create MapDownloadManager");
mDownloadManager = downloadManager;
mProgressTracker = new MapDownloadProgressTracker(context);
mAppName = context.getString(R.string.app_name);
}
@NonNull
private Map<String, Long> loadEnqueued()
{
Map<String, Long> result = new HashMap<>();
DownloadManager.Query query = new DownloadManager.Query();
query.setFilterByStatus(DownloadManager.STATUS_PENDING | DownloadManager.STATUS_RUNNING |
DownloadManager.STATUS_PAUSED | DownloadManager.STATUS_SUCCESSFUL);
Cursor cursor = null;
try
{
cursor = mDownloadManager.query(query);
cursor.moveToFirst();
int count = cursor.getCount();
for (int i = 0; i < count; ++i)
{
long id = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_ID));
String url = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_URI));
String urlPath = getUrlPath(url);
if (!TextUtils.isEmpty(urlPath))
result.put(urlPath, id);
cursor.moveToNext();
}
}
catch (Exception e)
{
LOGGER.e(TAG, "Failed to load enqueued requests. Exception ", e);
}
finally
{
Utils.closeSafely(cursor);
}
return result;
}
@Nullable
private String getUrlPath(@Nullable String url)
{
if (TextUtils.isEmpty(url))
return null;
String path = Uri.parse(url).getPath();
if (TextUtils.isEmpty(path)|| !MapManager.nativeIsUrlSupported(path))
return null;
try
{
return URLDecoder.decode(path, "UTF-8");
}
catch (UnsupportedEncodingException ignored)
{
return null;
}
}
@MainThread
public long enqueue(@NonNull String url)
{
Uri uri = Uri.parse(url);
String uriPath = uri.getPath();
if (uriPath == null)
throw new AssertionError("The path must be not null");
if (mRestoredRequests == null)
mRestoredRequests = loadEnqueued();
Long id = mRestoredRequests.get(uriPath);
long requestId = 0;
if (id == null)
{
DownloadManager.Request request = new DownloadManager
.Request(uri)
.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE)
.setDescription(mAppName);
requestId = mDownloadManager.enqueue(request);
}
else
{
mRestoredRequests.remove(uriPath);
requestId = id;
}
startProgressTracking();
return requestId;
}
@MainThread
public void remove(long requestId)
{
mDownloadManager.remove(requestId);
}
public void onDownloadFinished(boolean status, long id)
{
MapManager.nativeOnDownloadFinished(status, id);
}
public void startProgressTracking()
{
mProgressTracker.start();
}
public void stopProgressTracking()
{
mProgressTracker.stop();
}
@NonNull
public static MapDownloadManager from(@NonNull Context context)
{
MwmApplication app = (MwmApplication) context.getApplicationContext();
return app.getMapDownloadManager();
}
}

96
android/src/com/mapswithme/maps/downloader/MapDownloadProgressTracker.java
View file

@ -1,96 +0,0 @@
package com.mapswithme.maps.downloader;
import android.app.DownloadManager;
import android.content.Context;
import android.database.Cursor;
import androidx.annotation.NonNull;
import com.mapswithme.util.Utils;
import com.mapswithme.util.concurrency.UiThread;
import com.mapswithme.util.log.Logger;
import com.mapswithme.util.log.LoggerFactory;
public class MapDownloadProgressTracker
{
private static final Logger LOGGER = LoggerFactory.INSTANCE.getLogger(LoggerFactory.Type.DOWNLOADER);
private static final String TAG = MapDownloadProgressTracker.class.getSimpleName();
private static final long PROGRESS_TRACKING_INTERVAL_MILLISECONDS = 1000;
@NonNull
private final DownloadManager mDownloadManager;
private boolean mTrackingEnabled = false;
private final Runnable mTrackingMethod = this::trackProgress;
MapDownloadProgressTracker(@NonNull Context context)
{
DownloadManager downloadManager =
(DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE);
if (downloadManager == null)
throw new NullPointerException("Download manager is null, failed to create MapDownloadManager");
mDownloadManager = downloadManager;
}
public void start()
{
if (mTrackingEnabled)
return;
mTrackingEnabled = true;
// Delayed start, because g_completionHandlers are empty until enquee() method finishes.
UiThread.runLater(mTrackingMethod, PROGRESS_TRACKING_INTERVAL_MILLISECONDS);
}
public void stop()
{
mTrackingEnabled = false;
UiThread.cancelDelayedTasks(mTrackingMethod);
}
private void trackProgress()
{
if (!mTrackingEnabled)
return;
if (!MapManager.nativeHasPendingDownloads())
{
mTrackingEnabled = false;
return;
}
DownloadManager.Query query = new DownloadManager.Query();
query.setFilterByStatus(DownloadManager.STATUS_RUNNING);
Cursor cursor = null;
try
{
cursor = mDownloadManager.query(query);
cursor.moveToFirst();
int count = cursor.getCount();
for (int i = 0; i < count; ++i)
{
long id = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_ID));
long bytesDownloaded = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
long bytesTotal = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
MapManager.nativeOnDownloadProgress(id, bytesDownloaded, bytesTotal);
cursor.moveToNext();
}
UiThread.runLater(mTrackingMethod, PROGRESS_TRACKING_INTERVAL_MILLISECONDS);
}
catch (Exception e)
{
LOGGER.e(TAG, "Downloading progress tracking failed. Exception: " + e);
stop();
}
finally
{
Utils.closeSafely(cursor);
}
}
}

8
android/src/com/mapswithme/maps/downloader/MapManager.java
View file

@ -411,12 +411,4 @@ public final class MapManager
* Returns country ID which the current PP object points to, or {@code null}.
*/
public static native @Nullable String nativeGetSelectedCountry();
public static native boolean nativeIsUrlSupported(@NonNull String url);
@NonNull
public static native String nativeGetFilePathByUrl(@NonNull String url);
public static native void nativeOnDownloadFinished(boolean status, long id);
public static native void nativeOnDownloadProgress(long id, long bytesDownloaded, long bytesTotal);
public static native boolean nativeHasPendingDownloads();
}

4
android/src/com/mapswithme/maps/downloader/OnmapDownloader.java
View file

@ -246,8 +246,6 @@ public class OnmapDownloader implements MwmActivity.LeftAnimationTrackListener
mStorageSubscriptionSlot = 0;
MapManager.nativeUnsubscribeOnCountryChanged();
MapDownloadManager.from(mActivity).stopProgressTracking();
}
}
@ -258,8 +256,6 @@ public class OnmapDownloader implements MwmActivity.LeftAnimationTrackListener
mStorageSubscriptionSlot = MapManager.nativeSubscribe(mStorageCallback);
MapManager.nativeSubscribeOnCountryChanged(mCountryChangedListener);
MapDownloadManager.from(mActivity).startProgressTracking();
}
}

2
android/src/com/mapswithme/maps/scheduling/JobIdMap.java
View file

@ -1,7 +1,6 @@
package com.mapswithme.maps.scheduling;
import com.mapswithme.maps.background.OsmUploadService;
import com.mapswithme.maps.background.SystemDownloadCompletedService;
import java.util.HashMap;
import java.util.Map;
@ -11,7 +10,6 @@ public class JobIdMap
private static final Map<Class<?>, Integer> MAP = new HashMap<>();
static {
MAP.put(SystemDownloadCompletedService.class, calcIdentifier(MAP.size()));
MAP.put(OsmUploadService.class, calcIdentifier(MAP.size()));
}

4
android/src/com/mapswithme/maps/widget/placepage/PlacePageView.java
View file

@ -5,7 +5,6 @@ import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.location.Location;
import android.os.Build;
import android.text.Html;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
@ -47,7 +46,6 @@ import com.mapswithme.maps.bookmarks.data.Metadata;
import com.mapswithme.maps.bookmarks.data.RoadWarningMarkType;
import com.mapswithme.maps.downloader.CountryItem;
import com.mapswithme.maps.downloader.DownloaderStatusIcon;
import com.mapswithme.maps.downloader.MapDownloadManager;
import com.mapswithme.maps.downloader.MapManager;
import com.mapswithme.maps.editor.Editor;
import com.mapswithme.maps.editor.OpeningHours;
@ -1317,7 +1315,6 @@ public class PlacePageView extends NestedScrollViewClickFixed
mCurrentCountry = map;
if (mStorageCallbackSlot == 0)
mStorageCallbackSlot = MapManager.nativeSubscribe(mStorageCallback);
MapDownloadManager.from(getContext()).startProgressTracking();
mDownloaderIcon.setOnIconClickListener(mDownloadClickListener)
.setOnCancelClickListener(mCancelDownloadListener);
@ -1333,7 +1330,6 @@ public class PlacePageView extends NestedScrollViewClickFixed
MapManager.nativeUnsubscribe(mStorageCallbackSlot);
mStorageCallbackSlot = 0;
MapDownloadManager.from(getContext()).stopProgressTracking();
mCurrentCountry = null;
mDownloaderIcon.setOnIconClickListener(null)
.setOnCancelClickListener(null);

7
storage/CMakeLists.txt
View file

@ -51,12 +51,7 @@ set(
storage_helpers.hpp
)
if(${PLATFORM_ANDROID})
append(
SRC
background_downloading/downloader_queue.hpp
)
elseif(${PLATFORM_IPHONE})
if(${PLATFORM_IPHONE})
append(
SRC
background_downloading/downloader_adapter_ios.h