mil.nga.geopackage.validate.GeoPackageValidate Java Examples

private static void exportGeoPackage(Context context) throws IOException {

        if (ContextCompat.checkSelfPermission(context,
                Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {

            GeoPackageManager manager = GeoPackageFactory.getManager(context);

            String name = GeoPackageValidate.addGeoPackageExtension(GEOPACKAGE_NAME + "-" + System.currentTimeMillis());
            manager.exportGeoPackage(GEOPACKAGE_NAME,
                    name,
                    Environment.DIRECTORY_DOCUMENTS,
                    MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL));

            String path = "/storage/emulated/0/Documents/" + name;
            Log.i(LOG_NAME, "Created: " + path);
            Log.i(LOG_NAME, "To copy GeoPackage, run: "
                    + "adb pull " + path + " " + GeoPackageValidate.addGeoPackageExtension(GEOPACKAGE_NAME));
        } else {
            Log.w(LOG_NAME,
                    "To export the GeoPackage, grant GeoPackageSDKTests Storage permission on the emulator or phone");
        }

    }
 

/**
 * {@inheritDoc}
 */
@Override
public boolean importGeoPackage(String name, File file, boolean override) {

    // Verify the file has the right extension
    GeoPackageValidate.validateGeoPackageExtension(file);

    // Use the provided name or the base file name as the database name
    String database;
    if (name != null) {
        database = name;
    } else {
        database = GeoPackageIOUtils.getFileNameWithoutExtension(file);
    }

    boolean success = false;
    try {
        FileInputStream geoPackageStream = new FileInputStream(file);
        success = importGeoPackage(database, override, geoPackageStream,
                null);
    } catch (FileNotFoundException e) {
        throw new GeoPackageException(
                "Failed read or write GeoPackage file '" + file
                        + "' to database: '" + database + "'", e);
    }

    return success;
}
 

/**
 * {@inheritDoc}
 */
@RequiresApi(api = Build.VERSION_CODES.Q)
@Override
public void exportGeoPackage(String database, String name, String relativePath, Uri uri) throws IOException {

    // Add the extension if not on the name
    name = GeoPackageValidate.addGeoPackageExtension(name);

    ContentValues contentValues = new ContentValues();
    contentValues.put(MediaStore.MediaColumns.DISPLAY_NAME, name);
    contentValues.put(MediaStore.MediaColumns.MIME_TYPE, GeoPackageConstants.MEDIA_TYPE);
    contentValues.put(MediaStore.MediaColumns.RELATIVE_PATH, relativePath);

    exportGeoPackage(database, uri, contentValues);
}
 

/**
 * Handle opening the file path that MAGE was launched with
 */
private void handleOpenFilePath() {

    File cacheFile = new File(openPath);

    // Handle GeoPackage files by linking them to their current location
    if (GeoPackageValidate.hasGeoPackageExtension(cacheFile)) {

        String cacheName = GeoPackageCacheUtils.importGeoPackage(this, cacheFile);
        if (cacheName != null) {
            CacheProvider.getInstance(getApplicationContext()).enableAndRefreshTileOverlays(cacheName);
        }
    }
}
 

/**
 * Create a GeoPackage
 * 
 * @param file
 *            file
 * @return true if created
 */
public static boolean create(File file) {

	boolean created = false;

	// Validate or add the file extension
	if (GeoPackageIOUtils.hasFileExtension(file)) {
		GeoPackageValidate.validateGeoPackageExtension(file);
	} else {
		file = GeoPackageIOUtils.addFileExtension(file,
				GeoPackageConstants.EXTENSION);
	}

	if (file.exists()) {
		throw new GeoPackageException(
				"GeoPackage already exists: " + file.getAbsolutePath());
	} else {
		// Create the GeoPackage Connection
		GeoPackageConnection connection = connect(file);

		// Set the GeoPackage application id and user version
		connection.setApplicationId();
		connection.setUserVersion();

		// Create the minimum required tables
		GeoPackageTableCreator tableCreator = new GeoPackageTableCreator(
				connection);
		tableCreator.createRequired();

		connection.close();
		created = true;
	}

	return created;
}
 

/**
 * Open a GeoPackage
 * 
 * @param name
 *            GeoPackage name
 * @param file
 *            GeoPackage file
 * @param validate
 *            validate the GeoPackage
 * @return GeoPackage
 * @since 3.3.0
 */
public static GeoPackage open(String name, File file, boolean validate) {

	// Validate or add the file extension
	if (validate) {
		if (GeoPackageIOUtils.hasFileExtension(file)) {
			GeoPackageValidate.validateGeoPackageExtension(file);
		} else {
			file = GeoPackageIOUtils.addFileExtension(file,
					GeoPackageConstants.EXTENSION);
		}
	}

	// Create the GeoPackage Connection and table creator
	GeoPackageConnection connection = connect(file);
	GeoPackageTableCreator tableCreator = new GeoPackageTableCreator(
			connection);

	// Create a GeoPackage
	GeoPackage geoPackage = new GeoPackageImpl(name, file, connection,
			tableCreator);

	// Validate the GeoPackage has the minimum required tables
	if (validate) {
		try {
			GeoPackageValidate.validateMinimumTables(geoPackage);
		} catch (RuntimeException e) {
			geoPackage.close();
			throw e;
		}
	}

	return geoPackage;
}
 

/**
 * 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);
}
 

/**
 * Check if the SQLite database is a GeoPackage
 * 
 * @param database
 *            SQLite database
 * @return true if a GeoPackage
 */
public static boolean isGeoPackage(GeoPackage database) {
	return GeoPackageValidate.hasMinimumTables(database);
}