GeoPackage Android Map

GeoPackage Android Map Lib

The GeoPackage Libraries were developed at the National Geospatial-Intelligence Agency (NGA) in collaboration with BIT Systems. The government has "unlimited rights" and is releasing this software to increase the impact of government investments by providing developers with the opportunity to take things in new directions. The software use, modification, and distribution rights are stipulated within the MIT license.

Pull Requests

If you'd like to contribute to this project, please make a pull request. We'll review the pull request and discuss the changes. All pull request contributions to this project will be released under the MIT license.

Software source code previously released under an open source license and then modified by NGA staff is considered a "joint work" (see 17 USC ยง 101); it is partially copyrighted, partially public domain, and as a whole is protected by the copyrights of the non-government authors and must be released according to the terms of the original open source license.

About

GeoPackage Android Map is a GeoPackage Library SDK implementation of the Open Geospatial Consortium GeoPackage spec. It is listed as an OGC GeoPackage Implementation by the National Geospatial-Intelligence Agency.

The GeoPackage Android Map SDK provides Google Map library implementations in addition to the inherited base GeoPackage Android functionality. The library provides TileProvider overlay implementations and Google Map shape translations.

Usage

View the latest Javadoc

Implementations

GeoPackage MapCache

The GeoPackage MapCache app provides an extensive standalone example on how to use the SDK.

MAGE

The Mobile Awareness GEOINT Environment (MAGE) app provides mobile situational awareness capabilities. It uses the SDK to provide GeoPackage functionality.

DICE

The Disconnected Interactive Content Explorer (DICE) app allows users to load and display interactive content without a network connection. It uses the SDK to provide GeoPackage functionality on the map and within reports.

Example


// Context context = ...;
// File geoPackageFile = ...;
// GoogleMap map = ...;

// Get a manager
GeoPackageManager manager = GeoPackageFactory.getManager(context);

// Available databases
List<String> databases = manager.databases();

// Import database
boolean imported = manager.importGeoPackage(geoPackageFile);

// Open database
GeoPackage geoPackage = manager.open(databases.get(0));

// GeoPackage Table DAOs
SpatialReferenceSystemDao srsDao = geoPackage.getSpatialReferenceSystemDao();
ContentsDao contentsDao = geoPackage.getContentsDao();
GeometryColumnsDao geomColumnsDao = geoPackage.getGeometryColumnsDao();
TileMatrixSetDao tileMatrixSetDao = geoPackage.getTileMatrixSetDao();
TileMatrixDao tileMatrixDao = geoPackage.getTileMatrixDao();
DataColumnsDao dataColumnsDao = geoPackage.getDataColumnsDao();
DataColumnConstraintsDao dataColumnConstraintsDao = geoPackage.getDataColumnConstraintsDao();
MetadataDao metadataDao = geoPackage.getMetadataDao();
MetadataReferenceDao metadataReferenceDao = geoPackage.getMetadataReferenceDao();
ExtensionsDao extensionsDao = geoPackage.getExtensionsDao();

// Feature and tile tables
List<String> features = geoPackage.getFeatureTables();
List<String> tiles = geoPackage.getTileTables();

// Query Features
String featureTable = features.get(0);
FeatureDao featureDao = geoPackage.getFeatureDao(featureTable);
GoogleMapShapeConverter converter = new GoogleMapShapeConverter(
        featureDao.getProjection());
FeatureCursor featureCursor = featureDao.queryForAll();
try{
    while(featureCursor.moveToNext()){
        FeatureRow featureRow = featureCursor.getRow();
        GeoPackageGeometryData geometryData = featureRow.getGeometry();
        Geometry geometry = geometryData.getGeometry();
        GoogleMapShape shape = converter.toShape(geometry);
        GoogleMapShape mapShape = GoogleMapShapeConverter
                .addShapeToMap(map, shape);
        // ...
    }
}finally{
    featureCursor.close();
}

// Query Tiles
String tileTable = tiles.get(0);
TileDao tileDao = geoPackage.getTileDao(tileTable);
TileCursor tileCursor = tileDao.queryForAll();
try{
    while(tileCursor.moveToNext()){
        TileRow tileRow = tileCursor.getRow();
        byte[] tileBytes = tileRow.getTileData();
        Bitmap tileBitmap = tileRow.getTileDataBitmap();
        // ...
    }
}finally{
    tileCursor.close();
}

// Tile Provider (GeoPackage or Google API)
TileProvider overlay = GeoPackageOverlayFactory
        .getTileProvider(tileDao);
TileOverlayOptions overlayOptions = new TileOverlayOptions();
overlayOptions.tileProvider(overlay);
overlayOptions.zIndex(-1);
map.addTileOverlay(overlayOptions);

// Index Features
FeatureIndexManager indexer = new FeatureIndexManager(context, geoPackage, featureDao);
indexer.setIndexLocation(FeatureIndexType.GEOPACKAGE);
int indexedCount = indexer.index();

// Feature Tile Provider (dynamically draw tiles from features)
FeatureTiles featureTiles = new DefaultFeatureTiles(context, featureDao);
featureTiles.setMaxFeaturesPerTile(1000); // Set max features to draw per tile
NumberFeaturesTile numberFeaturesTile = new NumberFeaturesTile(context); // Custom feature tile implementation
featureTiles.setMaxFeaturesTileDraw(numberFeaturesTile); // Draw feature count tiles when max features passed
featureTiles.setIndexManager(indexer); // Set index manager to query feature indices
FeatureOverlay featureOverlay = new FeatureOverlay(featureTiles);
featureOverlay.setMinZoom(featureDao.getZoomLevel()); // Set zoom level to start showing tiles
TileOverlayOptions featureOverlayOptions = new TileOverlayOptions();
featureOverlayOptions.tileProvider(featureOverlay);
featureOverlayOptions.zIndex(-1); // Draw the feature tiles behind map markers
map.addTileOverlay(featureOverlayOptions);

BoundingBox boundingBox = new BoundingBox();
Projection projection = ProjectionFactory.getProjection(ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM);

// URL Tile Generator (generate tiles from a URL)
TileGenerator urlTileGenerator = new UrlTileGenerator(context, geoPackage,
                "url_tile_table", "http://url/{z}/{x}/{y}.png", 2, 7, boundingBox, projection);
int urlTileCount = urlTileGenerator.generateTiles();

// Feature Tile Generator (generate tiles from features)
TileGenerator featureTileGenerator = new FeatureTileGenerator(context, geoPackage,
                featureTable + "_tiles", featureTiles, 10, 15, boundingBox, projection);
int featureTileCount = featureTileGenerator.generateTiles();

// Close database when done
geoPackage.close();

Installation

Pull from the Maven Central Repository (AAR, POM, Source, Javadoc)

compile "mil.nga.geopackage.map:geopackage-android-map:3.5.0"

Build

Build Artifacts Test

Build this repository using Android Studio and/or Gradle.

Project Setup

Include as repositories in your project build.gradle:

repositories {
    jcenter()
    mavenLocal()
}
Normal Build

Include the dependency in your module build.gradle with desired version number:

compile "mil.nga.geopackage.map:geopackage-android-map:3.5.0"

As part of the build process, run the "uploadArchives" task on the geopackage-android Gradle script to update the Maven local repository.

Local Build

Replace the normal build dependency in your module build.gradle with:

compile project(':geopackage-map')

Include in your settings.gradle:

include ':geopackage-map'

From your project directory, link the cloned SDK directory:

ln -s ../geopackage-android-map/geopackage-map geopackage-map

Remote Dependencies