From e76fd5ac7ecb5126720da84e87ea997b8aa1c198 Mon Sep 17 00:00:00 2001 From: Brian Osborn Date: Tue, 17 Nov 2015 15:26:41 -0700 Subject: [PATCH 1/5] open with file intent filters, get the path and pass through to landing activity --- mage/src/main/AndroidManifest.xml | 23 +++++++++++++++++++ .../mil/nga/giat/mage/LandingActivity.java | 10 ++++++++ .../nga/giat/mage/event/EventActivity.java | 7 +++++- .../nga/giat/mage/login/LoginActivity.java | 20 +++++++++++++++- 4 files changed, 58 insertions(+), 2 deletions(-) diff --git a/mage/src/main/AndroidManifest.xml b/mage/src/main/AndroidManifest.xml index 4414c575f..cc70a9515 100644 --- a/mage/src/main/AndroidManifest.xml +++ b/mage/src/main/AndroidManifest.xml @@ -52,6 +52,29 @@ + + + + + + + + + + + + + + + + + + + + + + + Date: Wed, 18 Nov 2015 16:48:16 -0700 Subject: [PATCH 2/5] add local GeoPackage files as links. copy remote and temporary files to the cache folder --- mage/build.gradle | 2 +- .../mil/nga/giat/mage/LandingActivity.java | 27 +++- .../src/main/java/mil/nga/giat/mage/MAGE.java | 148 +++++++++++------- .../mil/nga/giat/mage/cache/CacheUtils.java | 89 +++++++++++ .../giat/mage/cache/GeoPackageCacheUtils.java | 76 +++++++++ .../nga/giat/mage/login/LoginActivity.java | 26 ++- .../mil/nga/giat/mage/map/MapFragment.java | 21 ++- mage/src/main/res/values/integers.xml | 2 + mage/src/main/res/values/strings.xml | 4 +- 9 files changed, 330 insertions(+), 65 deletions(-) create mode 100644 mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java create mode 100644 mage/src/main/java/mil/nga/giat/mage/cache/GeoPackageCacheUtils.java diff --git a/mage/build.gradle b/mage/build.gradle index fff395077..16a03b433 100644 --- a/mage/build.gradle +++ b/mage/build.gradle @@ -90,7 +90,7 @@ dependencies { //compile project(':sdk') // uncomment me to build locally compile "mil.nga.giat.mage:sdk:4.0.4" // comment me to build locally - compile "mil.nga.geopackage:geopackage-android:1.1.0" + compile "mil.nga.geopackage:geopackage-android:1.1.1" compile 'com.android.support:multidex:1.0.1' compile 'com.android.support:support-v4:23.1.+' compile 'com.google.android.gms:play-services:8.3.+' diff --git a/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java b/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java index f04156393..05ec3b41b 100644 --- a/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java +++ b/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java @@ -30,8 +30,10 @@ import java.util.ArrayList; import java.util.List; +import mil.nga.geopackage.validate.GeoPackageValidate; import mil.nga.giat.mage.event.EventFragment; import mil.nga.giat.mage.help.HelpFragment; +import mil.nga.giat.mage.cache.GeoPackageCacheUtils; import mil.nga.giat.mage.login.AlertBannerFragment; import mil.nga.giat.mage.login.LoginActivity; import mil.nga.giat.mage.map.MapFragment; @@ -54,7 +56,7 @@ public class LandingActivity extends Activity implements ListView.OnItemClickListener { /** - * Extra key for storing the path of a file used to launch MAGE + * Extra key for storing the local file path used to launch MAGE */ public static final String EXTRA_OPEN_FILE_PATH = "extra_open_file_path"; @@ -150,9 +152,10 @@ public View getView(int position, View view, ViewGroup parent) { getFragmentManager().beginTransaction().add(android.R.id.content, alertBannerFragment).commit(); } + // Check if MAGE was launched with a local file String openFilePath = getIntent().getStringExtra(EXTRA_OPEN_FILE_PATH); if(openFilePath != null){ - // TODO handle the open with file + handleOpenFilePath(openFilePath); } goToMap(); @@ -316,7 +319,24 @@ public void onItemClick(AdapterView adapterView, View view, int position, lon drawerList.setItemChecked(position, true); drawerLayout.closeDrawer(drawerList); } - + + /** + * Handle opening the file path that MAGE was launched with + * @param path + */ + private void handleOpenFilePath(String path){ + + File cacheFile = new File(path); + + // Handle GeoPackage files by linking them to their current location + if(GeoPackageValidate.hasGeoPackageExtension(cacheFile)){ + + // Import the GeoPackage if needed + GeoPackageCacheUtils.importGeoPackage(this, cacheFile); + } + + } + public static void deleteAllData(Context context) { DaoStore.getInstance(context).resetDatabase(); PreferenceManager.getDefaultSharedPreferences(context).edit().clear().commit(); @@ -354,4 +374,5 @@ public static boolean deleteDir(File dir) { } return dir.delete(); } + } \ No newline at end of file diff --git a/mage/src/main/java/mil/nga/giat/mage/MAGE.java b/mage/src/main/java/mil/nga/giat/mage/MAGE.java index 7192944c7..7cd70a6b5 100644 --- a/mage/src/main/java/mil/nga/giat/mage/MAGE.java +++ b/mage/src/main/java/mil/nga/giat/mage/MAGE.java @@ -32,9 +32,9 @@ import mil.nga.geopackage.factory.GeoPackageFactory; import mil.nga.geopackage.features.index.FeatureIndexManager; import mil.nga.geopackage.features.user.FeatureDao; -import mil.nga.geopackage.io.GeoPackageIOUtils; import mil.nga.geopackage.tiles.user.TileDao; import mil.nga.geopackage.validate.GeoPackageValidate; +import mil.nga.giat.mage.cache.GeoPackageCacheUtils; import mil.nga.giat.mage.login.LoginActivity; import mil.nga.giat.mage.map.cache.CacheOverlay; import mil.nga.giat.mage.map.cache.GeoPackageCacheOverlay; @@ -349,13 +349,14 @@ public TileOverlaysTask(Context context){ protected List doInBackground(Void... params) { List overlays = new ArrayList(); - // Delete all external GeoPackage links + // Add the existing external GeoPackage databases as cache overlays GeoPackageManager geoPackageManager = GeoPackageFactory.getManager(context); - geoPackageManager.deleteAllExternal(); + addGeoPackageCacheOverlays(context, overlays, geoPackageManager); + // Add each cache file or directory structure Map storageLocations = StorageUtility.getAllStorageLocations(); for (File storageLocation : storageLocations.values()) { - File root = new File(storageLocation, "MapCache"); + File root = new File(storageLocation, getString(R.string.overlay_cache_directory)); if (root.exists() && root.isDirectory() && root.canRead()) { for (File cache : root.listFiles()) { @@ -368,7 +369,7 @@ protected List doInBackground(Void... params) { } // GeoPackage File else if(GeoPackageValidate.hasGeoPackageExtension(cache)){ - addGeoPackageCacheOverlays(context, overlays, cache, geoPackageManager); + addGeoPackageCacheOverlay(context, overlays, cache, geoPackageManager); } } } @@ -403,61 +404,96 @@ protected void onPostExecute(List result) { } } - /** - * Add GeoPackage Cache Overlays + /** + * Add GeoPackage Cache Overlay for the existing databases * - * @param context - * @param overlays - * @param cache - * @param geoPackageManager - */ - private void addGeoPackageCacheOverlays(Context context, List overlays, File cache, GeoPackageManager geoPackageManager){ - // Import the GeoPackage as a linked file - String cacheName = GeoPackageIOUtils.getFileNameWithoutExtension(cache); - if(geoPackageManager.importGeoPackageAsExternalLink(cache, cacheName)){ + * @param context + * @param overlays + * @param geoPackageManager + */ + private void addGeoPackageCacheOverlays(Context context, List overlays, GeoPackageManager geoPackageManager) { + + // Delete any GeoPackages where the file is no longer accessible + geoPackageManager.deleteAllMissingExternal(); + + // Add each existing database as a cache + List externalDatabases = geoPackageManager.externalDatabases(); + for (String database : externalDatabases) { + addGeoPackageCacheOverlay(context, overlays, geoPackageManager, database); + } + } + + /** + * Add GeoPackage Cache Overlay for the database file + * + * @param context + * @param overlays + * @param cache + * @param geoPackageManager + */ + private void addGeoPackageCacheOverlay(Context context, List overlays, File cache, GeoPackageManager geoPackageManager) { + + // Import the GeoPackage if needed + String cacheName = GeoPackageCacheUtils.importGeoPackage(geoPackageManager, cache); + if(cacheName != null){ // Add the GeoPackage overlay - GeoPackage geoPackage = geoPackageManager.open(cacheName); - try { - List tables = new ArrayList<>(); - - // GeoPackage tile tables - List tileTables = geoPackage.getTileTables(); - for (String tileTable : tileTables) { - String tableCacheName = CacheOverlay.buildChildCacheName(cacheName, tileTable); - TileDao tileDao = geoPackage.getTileDao(tileTable); - int count = tileDao.count(); - int minZoom = (int) tileDao.getMinZoom(); - int maxZoom = (int) tileDao.getMaxZoom(); - GeoPackageTableCacheOverlay tableCache = new GeoPackageTileTableCacheOverlay(tileTable, cacheName, tableCacheName, count, minZoom, maxZoom); - tables.add(tableCache); - } + addGeoPackageCacheOverlay(context, overlays, geoPackageManager, cacheName); + } - // GeoPackage feature tables - List featureTables = geoPackage.getFeatureTables(); - for (String featureTable : featureTables) { - String tableCacheName = CacheOverlay.buildChildCacheName(cacheName, featureTable); - FeatureDao featureDao = geoPackage.getFeatureDao(featureTable); - int count = featureDao.count(); - GeometryType geometryType = featureDao.getGeometryType(); - FeatureIndexManager indexer = new FeatureIndexManager(context, geoPackage, featureDao); - boolean indexed = indexer.isIndexed(); - int minZoom = 0; - if(indexed) { - minZoom = featureDao.getZoomLevel() + getResources().getInteger(R.integer.geopackage_feature_tiles_min_zoom_offset); - minZoom = Math.max(minZoom, 0); - minZoom = Math.min(minZoom, GeoPackageFeatureTableCacheOverlay.MAX_ZOOM); - } - GeoPackageTableCacheOverlay tableCache = new GeoPackageFeatureTableCacheOverlay(featureTable, cacheName, tableCacheName, count, minZoom, indexed, geometryType); - tables.add(tableCache); - } + } - // Add the GeoPackage overlay with child tables - overlays.add(new GeoPackageCacheOverlay(cacheName, tables)); - }finally { - geoPackage.close(); - } - } - } + /** + * Add the GeoPackage database as a cache overlay + * + * @param context + * @param overlays + * @param geoPackageManager + * @param database + */ + private void addGeoPackageCacheOverlay(Context context, List overlays, GeoPackageManager geoPackageManager, String database) { + + // Add the GeoPackage overlay + GeoPackage geoPackage = geoPackageManager.open(database); + try { + List tables = new ArrayList<>(); + + // GeoPackage tile tables + List tileTables = geoPackage.getTileTables(); + for (String tileTable : tileTables) { + String tableCacheName = CacheOverlay.buildChildCacheName(database, tileTable); + TileDao tileDao = geoPackage.getTileDao(tileTable); + int count = tileDao.count(); + int minZoom = (int) tileDao.getMinZoom(); + int maxZoom = (int) tileDao.getMaxZoom(); + GeoPackageTableCacheOverlay tableCache = new GeoPackageTileTableCacheOverlay(tileTable, database, tableCacheName, count, minZoom, maxZoom); + tables.add(tableCache); + } + + // GeoPackage feature tables + List featureTables = geoPackage.getFeatureTables(); + for (String featureTable : featureTables) { + String tableCacheName = CacheOverlay.buildChildCacheName(database, featureTable); + FeatureDao featureDao = geoPackage.getFeatureDao(featureTable); + int count = featureDao.count(); + GeometryType geometryType = featureDao.getGeometryType(); + FeatureIndexManager indexer = new FeatureIndexManager(context, geoPackage, featureDao); + boolean indexed = indexer.isIndexed(); + int minZoom = 0; + if (indexed) { + minZoom = featureDao.getZoomLevel() + getResources().getInteger(R.integer.geopackage_feature_tiles_min_zoom_offset); + minZoom = Math.max(minZoom, 0); + minZoom = Math.min(minZoom, GeoPackageFeatureTableCacheOverlay.MAX_ZOOM); + } + GeoPackageTableCacheOverlay tableCache = new GeoPackageFeatureTableCacheOverlay(featureTable, database, tableCacheName, count, minZoom, indexed, geometryType); + tables.add(tableCache); + } + + // Add the GeoPackage overlay with child tables + overlays.add(new GeoPackageCacheOverlay(database, tables)); + } finally { + geoPackage.close(); + } + } @Override public void onError(Throwable error) { diff --git a/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java b/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java new file mode 100644 index 000000000..6ece8d4e2 --- /dev/null +++ b/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java @@ -0,0 +1,89 @@ +package mil.nga.giat.mage.cache; + +import android.content.ContentResolver; +import android.content.Context; +import android.net.Uri; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.Map; + +import mil.nga.geopackage.validate.GeoPackageValidate; +import mil.nga.giat.mage.R; +import mil.nga.giat.mage.sdk.utils.MediaUtility; +import mil.nga.giat.mage.sdk.utils.StorageUtility; + +/** + * Cache File Utilities + */ +public class CacheUtils { + + /** + * Copy the Uri to the cache directory + * + * @param context + * @param uri + * @param path + */ + public static void copyToCache(Context context, Uri uri, String path) { + + String name = MediaUtility.getDisplayName(context, uri, path); + File cacheDirectory = CacheUtils.getWritableCacheDirectory(context); + if (cacheDirectory != null) { + File cacheFile = new File(cacheDirectory, name); + if (isCacheFile(cacheFile)) { + // TODO Do this as a background task + final ContentResolver resolver = context.getContentResolver(); + try { + InputStream stream = resolver.openInputStream(uri); + MediaUtility.copyStream(stream, cacheFile); + } catch (IOException e) { + // TODO + String TODO = "TODO"; + } + } + } + } + + /** + * Determine if the file is a cache file based upon its extension + * + * @param file potential cache file + * @return true if a cache file + */ + public static boolean isCacheFile(File file) { + return GeoPackageValidate.hasGeoPackageExtension(file); + } + + /** + * Get a writeable cache directory for saving cache files + * + * @param context + * @return file directory or null + */ + public static File getWritableCacheDirectory(Context context) { + + File directory = null; + + Map storageLocations = StorageUtility.getAllStorageLocations(); + for (File storageLocation : storageLocations.values()) { + File temp = new File(storageLocation, context.getString(R.string.overlay_cache_directory)); + + if (temp.exists()) { + if (temp.canWrite()) { + directory = temp; + } + } else if (temp.mkdirs()) { + directory = temp; + } + + if (directory != null) { + break; + } + } + + return directory; + } + +} diff --git a/mage/src/main/java/mil/nga/giat/mage/cache/GeoPackageCacheUtils.java b/mage/src/main/java/mil/nga/giat/mage/cache/GeoPackageCacheUtils.java new file mode 100644 index 000000000..808836485 --- /dev/null +++ b/mage/src/main/java/mil/nga/giat/mage/cache/GeoPackageCacheUtils.java @@ -0,0 +1,76 @@ +package mil.nga.giat.mage.cache; + + +import android.content.Context; + +import java.io.File; + +import mil.nga.geopackage.GeoPackageManager; +import mil.nga.geopackage.factory.GeoPackageFactory; +import mil.nga.giat.mage.sdk.utils.MediaUtility; + +/** + * GeoPackage cache utils + */ +public class GeoPackageCacheUtils { + + /** + * Import the GeoPackage file as an external link if it does not exist + * + * @param context + * @param cacheFile + * @return cache name when imported, null when not imported + */ + public static String importGeoPackage(Context context, File cacheFile) { + GeoPackageManager manager = GeoPackageFactory.getManager(context); + return importGeoPackage(manager, cacheFile); + } + + /** + * Import the GeoPackage file as an external link if it does not exist + * + * @param manager + * @param cacheFile + * @return cache name when imported, null when not imported + */ + public static String importGeoPackage(GeoPackageManager manager, File cacheFile) { + + String importedCacheName = null; + + if (!manager.existsAtExternalFile(cacheFile)) { + + // Get the cache name + String cacheName = getCacheName(manager, cacheFile); + + // Import the GeoPackage as a linked file + if (manager.importGeoPackageAsExternalLink(cacheFile, cacheName)) { + importedCacheName = cacheName; + } + } + + return importedCacheName; + } + + /** + * Get a cache name for the cache file + * + * @param manager + * @param cacheFile + * @return cache name + */ + public static String getCacheName(GeoPackageManager manager, File cacheFile) { + + // Get the cache name + String cacheName = MediaUtility.getFileNameWithoutExtension(cacheFile); + + // Adjust the name until it is unique + final String baseCacheName = cacheName; + int nameCount = 0; + while (manager.exists(cacheName)) { + cacheName = baseCacheName + "_" + (++nameCount); + } + + return cacheName; + } + +} diff --git a/mage/src/main/java/mil/nga/giat/mage/login/LoginActivity.java b/mage/src/main/java/mil/nga/giat/mage/login/LoginActivity.java index 0802f2ae5..f1e871c3e 100644 --- a/mage/src/main/java/mil/nga/giat/mage/login/LoginActivity.java +++ b/mage/src/main/java/mil/nga/giat/mage/login/LoginActivity.java @@ -43,6 +43,7 @@ import mil.nga.giat.mage.R; import mil.nga.giat.mage.disclaimer.DisclaimerActivity; import mil.nga.giat.mage.event.EventActivity; +import mil.nga.giat.mage.cache.CacheUtils; import mil.nga.giat.mage.sdk.connectivity.ConnectivityUtility; import mil.nga.giat.mage.sdk.datastore.DaoStore; import mil.nga.giat.mage.sdk.login.AbstractAccountTask; @@ -129,9 +130,10 @@ public void onClick(DialogInterface dialog, int which) { } } + // Handle when MAGE was launched with a Uri (such as a local or remote cache file) Uri uri = intent.getData(); - if(uri != null){ - mOpenFilePath = MediaUtility.getPath(getApplicationContext(), uri); + if(uri != null) { + handleUri(uri); } // if token is not expired, then skip the login module @@ -230,6 +232,24 @@ public boolean onTouch(View v, MotionEvent event) { } } + /** + * Handle the Uri used to launch MAGE + * @param uri + */ + private void handleUri(Uri uri){ + + // Attempt to get a local file path + String openPath = MediaUtility.getPath(this, uri); + + // If not a local or temporary file path, copy the file to cache + if(openPath == null || MediaUtility.isTemporaryPath(openPath)){ + CacheUtils.copyToCache(this, uri, openPath); + }else{ + // Else, store the path to pass to further intents + mOpenFilePath = openPath; + } + } + /** * Fired when user clicks login * @@ -492,6 +512,7 @@ public void startNextActivityAndFinish() { new Intent(getApplicationContext(), DisclaimerActivity.class) : new Intent(getApplicationContext(), EventActivity.class); + // If launched with a local file path, save as an extra if(mOpenFilePath != null){ intent.putExtra(LandingActivity.EXTRA_OPEN_FILE_PATH, mOpenFilePath); } @@ -509,6 +530,7 @@ public void skipLogin() { new Intent(getApplicationContext(), DisclaimerActivity.class); intent.putExtra(EventActivity.EXTRA_CHOOSE_CURRENT_EVENT, true); + // If launched with a local file path, save as an extra if(mOpenFilePath != null){ intent.putExtra(LandingActivity.EXTRA_OPEN_FILE_PATH, mOpenFilePath); } diff --git a/mage/src/main/java/mil/nga/giat/mage/map/MapFragment.java b/mage/src/main/java/mil/nga/giat/mage/map/MapFragment.java index 16fc2709d..76aa61ea9 100644 --- a/mage/src/main/java/mil/nga/giat/mage/map/MapFragment.java +++ b/mage/src/main/java/mil/nga/giat/mage/map/MapFragment.java @@ -27,6 +27,7 @@ import android.webkit.WebView; import android.widget.EditText; import android.widget.ImageButton; +import android.widget.Toast; import com.google.android.gms.maps.CameraUpdateFactory; import com.google.android.gms.maps.GoogleMap; @@ -153,7 +154,7 @@ public class MapFragment extends Fragment implements OnMapReadyCallback, OnMapCl private StaticGeometryCollection staticGeometryCollection; private List searchMarkers = new ArrayList(); - private Map cacheOverlays = new HashMap();; + private Map cacheOverlays = new HashMap(); // GeoPackage cache of open GeoPackage connections private GeoPackageCache geoPackageCache; @@ -364,7 +365,7 @@ public void beforeTextChanged(CharSequence s, int start, int count, int after) { @Override public void onTextChanged(CharSequence s, int start, int before, int count) { - if(s == null || s.toString().trim().isEmpty()) { + if (s == null || s.toString().trim().isEmpty()) { if (searchMarkers != null) { for (Marker m : searchMarkers) { m.remove(); @@ -902,10 +903,18 @@ private void addGeoPackageFeatureCacheOverlay(Map enabledC } // Not indexed, add the features to the map else { + int maxFeaturesPerTable = 0; + if(featureDao.getGeometryType() == GeometryType.POINT){ + maxFeaturesPerTable = getResources().getInteger(R.integer.geopackage_features_max_points_per_table); + }else{ + maxFeaturesPerTable = getResources().getInteger(R.integer.geopackage_features_max_features_per_table); + } Projection projection = featureDao.getProjection(); GoogleMapShapeConverter shapeConverter = new GoogleMapShapeConverter(projection); FeatureCursor featureCursor = featureDao.queryForAll(); try { + final int totalCount = featureCursor.getCount(); + int count = 0; while (featureCursor.moveToNext()) { FeatureRow featureRow = featureCursor.getRow(); GeoPackageGeometryData geometryData = featureRow.getGeometry(); @@ -915,6 +924,14 @@ private void addGeoPackageFeatureCacheOverlay(Map enabledC GoogleMapShape shape = shapeConverter.toShape(geometry); // Set the Shape Marker, PolylineOptions, and PolygonOptions here if needed to change color and style featureTableCacheOverlay.addShapeToMap(featureRow.getId(), shape, map); + + if(++count >= maxFeaturesPerTable){ + if(count < totalCount){ + Toast.makeText(getActivity().getApplicationContext(), featureTableCacheOverlay.getCacheName() + + "- added " + count + " of " + totalCount, Toast.LENGTH_LONG).show(); + } + break; + } } } } diff --git a/mage/src/main/res/values/integers.xml b/mage/src/main/res/values/integers.xml index b26e8ac91..0c198cda7 100644 --- a/mage/src/main/res/values/integers.xml +++ b/mage/src/main/res/values/integers.xml @@ -3,6 +3,8 @@ 1000 500 + 1000 + 500 0 \ No newline at end of file diff --git a/mage/src/main/res/values/strings.xml b/mage/src/main/res/values/strings.xml index 957325a02..6fd0d9255 100644 --- a/mage/src/main/res/values/strings.xml +++ b/mage/src/main/res/values/strings.xml @@ -35,5 +35,7 @@ Click the refresh button below to pull all feature overlays from the server. You are about to refresh all feature overlays, this could take a while.\n\n Refresh all feature overlays? You are about to delete the selected data and logout.\n\n Are you sure you want to do this? - + + MapCache + \ No newline at end of file From 4805d20fc64e9d9e6b277fa41f61d1fa4041c4d8 Mon Sep 17 00:00:00 2001 From: Brian Osborn Date: Thu, 19 Nov 2015 10:04:49 -0700 Subject: [PATCH 3/5] enable open with cache overlays and refresh, delete cache overlays --- .../mil/nga/giat/mage/LandingActivity.java | 7 +- .../src/main/java/mil/nga/giat/mage/MAGE.java | 46 +++++- .../TileOverlayPreferenceActivity.java | 156 +++++++++++++++++- 3 files changed, 194 insertions(+), 15 deletions(-) diff --git a/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java b/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java index 05ec3b41b..70380de11 100644 --- a/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java +++ b/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java @@ -332,7 +332,12 @@ private void handleOpenFilePath(String path){ if(GeoPackageValidate.hasGeoPackageExtension(cacheFile)){ // Import the GeoPackage if needed - GeoPackageCacheUtils.importGeoPackage(this, cacheFile); + String cacheName = GeoPackageCacheUtils.importGeoPackage(this, cacheFile); + if(cacheName != null){ + MAGE mage = ((MAGE) getApplication()); + mage.enableOverlay(cacheName); + mage.refreshTileOverlays(); + } } } diff --git a/mage/src/main/java/mil/nga/giat/mage/MAGE.java b/mage/src/main/java/mil/nga/giat/mage/MAGE.java index 7cd70a6b5..58ac266e0 100644 --- a/mage/src/main/java/mil/nga/giat/mage/MAGE.java +++ b/mage/src/main/java/mil/nga/giat/mage/MAGE.java @@ -329,6 +329,22 @@ public void refreshTileOverlays() { task.execute(); } + public void enableOverlay(String overlayName){ + List overlayNames = new ArrayList<>(); + overlayNames.add(overlayName); + enableOverlays(overlayNames); + } + + public void enableOverlays(Collection overlayNames){ + String overlayKey = getString(R.string.tileOverlaysKey); + SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext()); + Set enabledOverlays = preferences.getStringSet(overlayKey, Collections.emptySet()); + enabledOverlays.addAll(overlayNames); + SharedPreferences.Editor editor = preferences.edit(); + editor.putStringSet(overlayKey, enabledOverlays); + editor.apply(); + } + private void setCacheOverlays(List cacheOverlays) { this.cacheOverlays = cacheOverlays; @@ -382,16 +398,36 @@ else if(GeoPackageValidate.hasGeoPackageExtension(cache)){ // Determine which caches are enabled for (CacheOverlay cacheOverlay : overlays) { - if (enabledOverlays.contains(cacheOverlay.getCacheName())) { + + // Check and enable the cache + boolean cacheEnabled = enabledOverlays.contains(cacheOverlay.getCacheName()); + if (cacheEnabled) { cacheOverlay.setEnabled(true); } - // If a child is enabled, enable the parent - for (CacheOverlay childCache : cacheOverlay.getChildren()) { - if (enabledOverlays.contains(childCache.getCacheName())) { - childCache.setEnabled(true); + // If the cache supports children + if(cacheOverlay.isSupportsChildren()) { + + // Check the child caches + boolean childCacheEnabled = false; + for (CacheOverlay childCache : cacheOverlay.getChildren()) { + if (enabledOverlays.contains(childCache.getCacheName())) { + childCache.setEnabled(true); + childCacheEnabled = true; + } + } + + // If a child cache is set, enable the parent by default + if(childCacheEnabled) { cacheOverlay.setEnabled(true); } + + // If no child cache is set, but the parent is, enable all children + if(!childCacheEnabled && cacheEnabled) { + for (CacheOverlay childCache : cacheOverlay.getChildren()) { + childCache.setEnabled(true); + } + } } } diff --git a/mage/src/main/java/mil/nga/giat/mage/map/preference/TileOverlayPreferenceActivity.java b/mage/src/main/java/mil/nga/giat/mage/map/preference/TileOverlayPreferenceActivity.java index 98c635b46..cefd37bf3 100644 --- a/mage/src/main/java/mil/nga/giat/mage/map/preference/TileOverlayPreferenceActivity.java +++ b/mage/src/main/java/mil/nga/giat/mage/map/preference/TileOverlayPreferenceActivity.java @@ -1,8 +1,9 @@ package mil.nga.giat.mage.map.preference; import android.app.Activity; +import android.app.AlertDialog; import android.app.ExpandableListActivity; -import android.content.Context; +import android.content.DialogInterface; import android.content.Intent; import android.os.Bundle; import android.view.LayoutInflater; @@ -11,19 +12,28 @@ import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; +import android.widget.AdapterView; import android.widget.BaseExpandableListAdapter; import android.widget.CheckBox; +import android.widget.ExpandableListView; import android.widget.ImageView; import android.widget.ProgressBar; import android.widget.TextView; +import java.io.File; import java.util.ArrayList; import java.util.List; +import java.util.Map; +import mil.nga.geopackage.GeoPackageManager; +import mil.nga.geopackage.factory.GeoPackageFactory; import mil.nga.giat.mage.MAGE; import mil.nga.giat.mage.MAGE.OnCacheOverlayListener; import mil.nga.giat.mage.R; import mil.nga.giat.mage.map.cache.CacheOverlay; +import mil.nga.giat.mage.map.cache.GeoPackageCacheOverlay; +import mil.nga.giat.mage.map.cache.XYZDirectoryCacheOverlay; +import mil.nga.giat.mage.sdk.utils.StorageUtility; public class TileOverlayPreferenceActivity extends ExpandableListActivity implements OnCacheOverlayListener { @@ -56,6 +66,25 @@ public void onCacheOverlay(List cacheOverlays) { overlayAdapter = new OverlayAdapter(this, cacheOverlays); setListAdapter(overlayAdapter); + getExpandableListView().setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() { + @Override + public boolean onItemLongClick(AdapterView parent, View view, + int position, long id) { + int itemType = ExpandableListView.getPackedPositionType(id); + if (itemType == ExpandableListView.PACKED_POSITION_TYPE_CHILD) { + int childPosition = ExpandableListView.getPackedPositionChild(id); + int groupPosition = ExpandableListView.getPackedPositionGroup(id); + // Handle child row long clicks here + return true; + } else if (itemType == ExpandableListView.PACKED_POSITION_TYPE_GROUP) { + int groupPosition = ExpandableListView.getPackedPositionGroup(id); + CacheOverlay cacheOverlay = (CacheOverlay) overlayAdapter.getGroup(groupPosition); + deleteCacheOverlayConfirm(cacheOverlay); + return true; + } + return false; + } + }); refreshButton.setEnabled(true); getExpandableListView().setEnabled(true); progressBar.setVisibility(View.GONE); @@ -145,7 +174,7 @@ public static class OverlayAdapter extends BaseExpandableListAdapter { /** * Context */ - private Context context; + private TileOverlayPreferenceActivity activity; /** * List of cache overlays @@ -155,11 +184,11 @@ public static class OverlayAdapter extends BaseExpandableListAdapter { /** * Constructor * - * @param context + * @param activity * @param overlays */ - public OverlayAdapter(Context context, List overlays) { - this.context = context; + public OverlayAdapter(TileOverlayPreferenceActivity activity, List overlays) { + this.activity = activity; this.overlays = overlays; } @@ -211,13 +240,13 @@ public boolean hasStableIds() { public View getGroupView(int i, boolean isExpanded, View view, ViewGroup viewGroup) { if (view == null) { - LayoutInflater inflater = LayoutInflater.from(context); + LayoutInflater inflater = LayoutInflater.from(activity); view = inflater.inflate(R.layout.cache_overlay_group, viewGroup, false); } ImageView imageView = (ImageView) view .findViewById(R.id.cache_overlay_group_image); - TextView geoPackageName = (TextView) view + TextView cacheName = (TextView) view .findViewById(R.id.cache_overlay_group_name); TextView childCount = (TextView) view .findViewById(R.id.cache_overlay_group_count); @@ -253,7 +282,7 @@ public void onClick(View v) { }else{ imageView.setImageResource(-1); } - geoPackageName.setText(overlay.getName()); + cacheName.setText(overlay.getName()); if (overlay.isSupportsChildren()) { childCount.setText("(" + getChildrenCount(i) + ")"); }else{ @@ -268,7 +297,7 @@ public void onClick(View v) { public View getChildView(int i, int j, boolean b, View view, ViewGroup viewGroup) { if (view == null) { - LayoutInflater inflater = LayoutInflater.from(context); + LayoutInflater inflater = LayoutInflater.from(activity); view = inflater.inflate(R.layout.cache_overlay_child, viewGroup, false); } @@ -337,4 +366,113 @@ public boolean isChildSelectable(int i, int j) { } + /** + * Delete the cache overlay + * @param cacheOverlay + */ + private void deleteCacheOverlayConfirm(final CacheOverlay cacheOverlay) { + AlertDialog deleteDialog = new AlertDialog.Builder(this) + .setTitle("Delete Cache") + .setMessage("Delete " + cacheOverlay.getName() + " Cache?") + .setPositiveButton("Delete", + + new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, + int which) { + deleteCacheOverlay(cacheOverlay); + } + }) + + .setNegativeButton(getString(R.string.cancel), + new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, + int which) { + dialog.dismiss(); + } + }).create(); + deleteDialog.show(); + } + + /** + * Delete the cache overlay + * @param cacheOverlay + */ + private void deleteCacheOverlay(CacheOverlay cacheOverlay){ + + progressBar.setVisibility(View.VISIBLE); + getExpandableListView().setEnabled(false); + + switch(cacheOverlay.getType()) { + + case XYZ_DIRECTORY: + deleteXYZCacheOverlay((XYZDirectoryCacheOverlay)cacheOverlay); + break; + + case GEOPACKAGE: + deleteGeoPackageCacheOverlay((GeoPackageCacheOverlay)cacheOverlay); + break; + + } + + ((MAGE) getApplication()).refreshTileOverlays(); + } + + /** + * Delete the XYZ cache overlay + * @param xyzCacheOverlay + */ + private void deleteXYZCacheOverlay(XYZDirectoryCacheOverlay xyzCacheOverlay){ + + File directory = xyzCacheOverlay.getDirectory(); + + if(directory.canWrite()){ + deleteFile(directory); + } + + } + + /** + * Delete the base directory file + * @param base directory + */ + private void deleteFile(File base) { + if (base.isDirectory()) { + for (File file : base.listFiles()) { + deleteFile(file); + } + } + base.delete(); + } + + /** + * Delete the GeoPackage cache overlay + * @param geoPackageCacheOverlay + */ + private void deleteGeoPackageCacheOverlay(GeoPackageCacheOverlay geoPackageCacheOverlay){ + + String database = geoPackageCacheOverlay.getName(); + + // Get the GeoPackage file + GeoPackageManager manager = GeoPackageFactory.getManager(this); + File path = manager.getFile(database); + + // Delete the cache from the GeoPackage manager + manager.delete(database); + + // Attempt to delete the cache file if it is in the cache directory + File pathDirectory = path.getParentFile(); + if(path.canWrite() && pathDirectory != null){ + Map storageLocations = StorageUtility.getAllStorageLocations(); + for (File storageLocation : storageLocations.values()) { + File root = new File(storageLocation, getString(R.string.overlay_cache_directory)); + if (root.equals(pathDirectory)) { + path.delete(); + break; + } + } + } + } + } \ No newline at end of file From daf9a6ac190ef8ab6c4b48ba3e1af546a53ab2c2 Mon Sep 17 00:00:00 2001 From: Brian Osborn Date: Thu, 19 Nov 2015 11:20:55 -0700 Subject: [PATCH 4/5] Copy remote Uri cache file streams in a background task --- .../mil/nga/giat/mage/cache/CacheUtils.java | 32 ++++--- .../giat/mage/cache/CopyCacheStreamTask.java | 85 +++++++++++++++++++ 2 files changed, 100 insertions(+), 17 deletions(-) create mode 100644 mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java diff --git a/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java b/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java index 6ece8d4e2..9a8227ec3 100644 --- a/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java +++ b/mage/src/main/java/mil/nga/giat/mage/cache/CacheUtils.java @@ -1,12 +1,10 @@ package mil.nga.giat.mage.cache; -import android.content.ContentResolver; +import android.app.Activity; import android.content.Context; import android.net.Uri; import java.io.File; -import java.io.IOException; -import java.io.InputStream; import java.util.Map; import mil.nga.geopackage.validate.GeoPackageValidate; @@ -20,28 +18,28 @@ public class CacheUtils { /** - * Copy the Uri to the cache directory + * Copy the Uri to the cache directory in a background task * - * @param context + * @param activity * @param uri * @param path */ - public static void copyToCache(Context context, Uri uri, String path) { + public static void copyToCache(Activity activity, Uri uri, String path) { + + // Get the Uri display name, which should be the file name with extension + String name = MediaUtility.getDisplayName(activity, uri, path); - String name = MediaUtility.getDisplayName(context, uri, path); - File cacheDirectory = CacheUtils.getWritableCacheDirectory(context); + // Get a cache directory to write to + File cacheDirectory = CacheUtils.getWritableCacheDirectory(activity); if (cacheDirectory != null) { + + // Verify that the file is a cache file by its extension File cacheFile = new File(cacheDirectory, name); if (isCacheFile(cacheFile)) { - // TODO Do this as a background task - final ContentResolver resolver = context.getContentResolver(); - try { - InputStream stream = resolver.openInputStream(uri); - MediaUtility.copyStream(stream, cacheFile); - } catch (IOException e) { - // TODO - String TODO = "TODO"; - } + + // Copy the file in a background task + CopyCacheStreamTask task = new CopyCacheStreamTask(activity, uri, cacheFile); + task.execute(); } } } diff --git a/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java b/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java new file mode 100644 index 000000000..f8bbae8d5 --- /dev/null +++ b/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java @@ -0,0 +1,85 @@ +package mil.nga.giat.mage.cache; + +import android.app.Activity; +import android.content.ContentResolver; +import android.net.Uri; +import android.os.AsyncTask; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; + +import mil.nga.giat.mage.MAGE; +import mil.nga.giat.mage.sdk.utils.MediaUtility; + +/** + * Task for copying a cache file Uri stream to the cache folder location + */ +public class CopyCacheStreamTask extends AsyncTask { + + /** + * Activity + */ + private Activity activity; + + /** + * Intent Uri used to launch MAGE + */ + private Uri uri; + + /** + * Cache file to create + */ + private File cacheFile; + + /** + * Constructor + * + * @param activity + * @param uri Uri containing stream + * @param cacheFile copy to cache file location + */ + public CopyCacheStreamTask(Activity activity, Uri uri, File cacheFile) { + this.activity = activity; + this.uri = uri; + this.cacheFile = cacheFile; + } + + /** + * Copy the cache stream to cache file location + * + * @param params + * @return + */ + @Override + protected String doInBackground(Void... params) { + + String error = null; + + final ContentResolver resolver = activity.getContentResolver(); + try { + InputStream stream = resolver.openInputStream(uri); + MediaUtility.copyStream(stream, cacheFile); + } catch (IOException e) { + error = e.getMessage(); + } + + return error; + } + + /** + * Enable the new cache file and refresh the overlays + * + * @param result + */ + @Override + protected void onPostExecute(String result) { + if (result == null) { + MAGE mage = ((MAGE) activity.getApplication()); + String cacheName = MediaUtility.getFileNameWithoutExtension(cacheFile); + mage.enableOverlay(cacheName); + mage.refreshTileOverlays(); + } + } + +} From 0841c06ed5dd280c0427feb9911ec313bb690ba7 Mon Sep 17 00:00:00 2001 From: Brian Osborn Date: Thu, 19 Nov 2015 14:18:10 -0700 Subject: [PATCH 5/5] update the enabled cache preferences as part of the refresh, remove any that have been deleted --- .../mil/nga/giat/mage/LandingActivity.java | 3 +- .../src/main/java/mil/nga/giat/mage/MAGE.java | 116 +++++++++++------- .../giat/mage/cache/CopyCacheStreamTask.java | 3 +- 3 files changed, 74 insertions(+), 48 deletions(-) diff --git a/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java b/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java index 70380de11..caa2e7187 100644 --- a/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java +++ b/mage/src/main/java/mil/nga/giat/mage/LandingActivity.java @@ -335,8 +335,7 @@ private void handleOpenFilePath(String path){ String cacheName = GeoPackageCacheUtils.importGeoPackage(this, cacheFile); if(cacheName != null){ MAGE mage = ((MAGE) getApplication()); - mage.enableOverlay(cacheName); - mage.refreshTileOverlays(); + mage.enableAndRefreshTileOverlays(cacheName); } } diff --git a/mage/src/main/java/mil/nga/giat/mage/MAGE.java b/mage/src/main/java/mil/nga/giat/mage/MAGE.java index 58ac266e0..2b8923645 100644 --- a/mage/src/main/java/mil/nga/giat/mage/MAGE.java +++ b/mage/src/main/java/mil/nga/giat/mage/MAGE.java @@ -23,6 +23,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -325,24 +326,19 @@ public void unregisterCacheOverlayListener(OnCacheOverlayListener listener) { } public void refreshTileOverlays() { - TileOverlaysTask task = new TileOverlaysTask(this); + TileOverlaysTask task = new TileOverlaysTask(this, null); task.execute(); } - public void enableOverlay(String overlayName){ + public void enableAndRefreshTileOverlays(String enableOverlayName) { List overlayNames = new ArrayList<>(); - overlayNames.add(overlayName); - enableOverlays(overlayNames); + overlayNames.add(enableOverlayName); + enableAndRefreshTileOverlays(overlayNames); } - public void enableOverlays(Collection overlayNames){ - String overlayKey = getString(R.string.tileOverlaysKey); - SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext()); - Set enabledOverlays = preferences.getStringSet(overlayKey, Collections.emptySet()); - enabledOverlays.addAll(overlayNames); - SharedPreferences.Editor editor = preferences.edit(); - editor.putStringSet(overlayKey, enabledOverlays); - editor.apply(); + public void enableAndRefreshTileOverlays(Collection enableOverlayNames) { + TileOverlaysTask task = new TileOverlaysTask(this, enableOverlayNames); + task.execute(); } private void setCacheOverlays(List cacheOverlays) { @@ -356,9 +352,13 @@ private void setCacheOverlays(List cacheOverlays) { private class TileOverlaysTask extends AsyncTask> { private Context context; + private Set enable = new HashSet<>(); - public TileOverlaysTask(Context context){ + public TileOverlaysTask(Context context, Collection enable){ this.context = context; + if(enable != null) { + this.enable.addAll(enable); + } } @Override @@ -385,7 +385,10 @@ protected List doInBackground(Void... params) { } // GeoPackage File else if(GeoPackageValidate.hasGeoPackageExtension(cache)){ - addGeoPackageCacheOverlay(context, overlays, cache, geoPackageManager); + GeoPackageCacheOverlay cacheOverlay = getGeoPackageCacheOverlay(context, cache, geoPackageManager); + if(cacheOverlay != null){ + overlays.add(cacheOverlay); + } } } } @@ -393,42 +396,57 @@ else if(GeoPackageValidate.hasGeoPackageExtension(cache)){ } // Set what should be enabled based on preferences. + boolean update = false; SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext()); - Set enabledOverlays = preferences.getStringSet(getString(R.string.tileOverlaysKey), Collections.emptySet()); + Set updatedEnabledOverlays = preferences.getStringSet(getString(R.string.tileOverlaysKey), Collections.emptySet()); + Set enabledOverlays = new HashSet<>(); + enabledOverlays.addAll(updatedEnabledOverlays); // Determine which caches are enabled for (CacheOverlay cacheOverlay : overlays) { // Check and enable the cache - boolean cacheEnabled = enabledOverlays.contains(cacheOverlay.getCacheName()); - if (cacheEnabled) { + String cacheName = cacheOverlay.getCacheName(); + if (enabledOverlays.remove(cacheName)) { cacheOverlay.setEnabled(true); } - // If the cache supports children - if(cacheOverlay.isSupportsChildren()) { - - // Check the child caches - boolean childCacheEnabled = false; - for (CacheOverlay childCache : cacheOverlay.getChildren()) { - if (enabledOverlays.contains(childCache.getCacheName())) { - childCache.setEnabled(true); - childCacheEnabled = true; - } - } - - // If a child cache is set, enable the parent by default - if(childCacheEnabled) { + // Check the child caches + for (CacheOverlay childCache : cacheOverlay.getChildren()) { + if (enabledOverlays.remove(childCache.getCacheName())) { + childCache.setEnabled(true); cacheOverlay.setEnabled(true); } + } + + // Check for new caches to enable in the overlays and preferences + if(enable.contains(cacheName) && !cacheOverlay.isEnabled()){ - // If no child cache is set, but the parent is, enable all children - if(!childCacheEnabled && cacheEnabled) { + update = true; + cacheOverlay.setEnabled(true); + if(cacheOverlay.isSupportsChildren()){ for (CacheOverlay childCache : cacheOverlay.getChildren()) { childCache.setEnabled(true); + updatedEnabledOverlays.add(childCache.getCacheName()); } + }else{ + updatedEnabledOverlays.add(cacheName); } } + + } + + // Remove overlays in the preferences that no longer exist + if(!enabledOverlays.isEmpty()){ + updatedEnabledOverlays.removeAll(enabledOverlays); + update = true; + } + + // If new enabled cache overlays, update them in the preferences + if(update){ + SharedPreferences.Editor editor = preferences.edit(); + editor.putStringSet(getString(R.string.tileOverlaysKey), updatedEnabledOverlays); + editor.apply(); } return overlays; @@ -455,38 +473,46 @@ private void addGeoPackageCacheOverlays(Context context, List over // Add each existing database as a cache List externalDatabases = geoPackageManager.externalDatabases(); for (String database : externalDatabases) { - addGeoPackageCacheOverlay(context, overlays, geoPackageManager, database); + GeoPackageCacheOverlay cacheOverlay = getGeoPackageCacheOverlay(context, geoPackageManager, database); + if(cacheOverlay != null){ + overlays.add(cacheOverlay); + } } } /** - * Add GeoPackage Cache Overlay for the database file + * Get GeoPackage Cache Overlay for the database file * * @param context - * @param overlays * @param cache * @param geoPackageManager + * @return cache overlay */ - private void addGeoPackageCacheOverlay(Context context, List overlays, File cache, GeoPackageManager geoPackageManager) { + private GeoPackageCacheOverlay getGeoPackageCacheOverlay(Context context, File cache, GeoPackageManager geoPackageManager) { + + GeoPackageCacheOverlay cacheOverlay = null; // Import the GeoPackage if needed String cacheName = GeoPackageCacheUtils.importGeoPackage(geoPackageManager, cache); if(cacheName != null){ - // Add the GeoPackage overlay - addGeoPackageCacheOverlay(context, overlays, geoPackageManager, cacheName); + // Get the GeoPackage overlay + cacheOverlay = getGeoPackageCacheOverlay(context, geoPackageManager, cacheName); } + return cacheOverlay; } /** - * Add the GeoPackage database as a cache overlay + * Get the GeoPackage database as a cache overlay * * @param context - * @param overlays * @param geoPackageManager * @param database + * @return cache overlay */ - private void addGeoPackageCacheOverlay(Context context, List overlays, GeoPackageManager geoPackageManager, String database) { + private GeoPackageCacheOverlay getGeoPackageCacheOverlay(Context context, GeoPackageManager geoPackageManager, String database) { + + GeoPackageCacheOverlay cacheOverlay = null; // Add the GeoPackage overlay GeoPackage geoPackage = geoPackageManager.open(database); @@ -524,11 +550,13 @@ private void addGeoPackageCacheOverlay(Context context, List overl tables.add(tableCache); } - // Add the GeoPackage overlay with child tables - overlays.add(new GeoPackageCacheOverlay(database, tables)); + // Create the GeoPackage overlay with child tables + cacheOverlay = new GeoPackageCacheOverlay(database, tables); } finally { geoPackage.close(); } + + return cacheOverlay; } @Override diff --git a/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java b/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java index f8bbae8d5..c0e8d5311 100644 --- a/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java +++ b/mage/src/main/java/mil/nga/giat/mage/cache/CopyCacheStreamTask.java @@ -77,8 +77,7 @@ protected void onPostExecute(String result) { if (result == null) { MAGE mage = ((MAGE) activity.getApplication()); String cacheName = MediaUtility.getFileNameWithoutExtension(cacheFile); - mage.enableOverlay(cacheName); - mage.refreshTileOverlays(); + mage.enableAndRefreshTileOverlays(cacheName); } }