Intégration de nos propres cartes dans Google Maps

/**
 * Main Activity
 */
public class MainActivity extends ActionBarActivity implements LocationListener, OnCameraChangeListener {

// Declaration
private GoogleMap map;
private MyTileProvider tileProvider;
private int minZoom = -1;
private int maxZoom = -1;

@Override
protected void onCreate(Bundle savedInstanceState) {
@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);

   map = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map))
       .getMap();
  
   // Init Map
   if (map != null){
         // set the type to TYPE_NONE
       map.setMapType(GoogleMap.MAP_TYPE_NONE);
       // create the tileProvider
       tileProvider = new MyTileProvider(this, "test.mbtiles");
       // Add the Provider in Map
       map.addTileOverlay(new TileOverlayOptions().tileProvider(tileProvider));
       // center Map
       LatLngBounds bounds = tileProvider.getBounds();
       CameraUpdate upd = CameraUpdateFactory.newLatLngBounds(bounds,MyTileProvider.TILE_WIDTH , MyTileProvider.TILE_HEIGHT, 0);
       minZoom = tileProvider.getMinZoom();
       maxZoom = tileProvider.getMaxZoom();
       map.setOnCameraChangeListener(this);
       map.moveCamera(upd);
   }
   
}

@Override
public void onCameraChange(CameraPosition position) {
   if (minZoom != -1) {
   if (position.zoom < minZoom)
      map.animateCamera(CameraUpdateFactory.zoomTo(minZoom));
   }
   if (maxZoom != -1) {
      if (position.zoom > maxZoom)
         map.animateCamera(CameraUpdateFactory.zoomTo(maxZoom));
   }
}

@Override
protected void onDestroy() {
   super.onDestroy();
   //  we close the database
   if (tileProvider != null) {
      tileProvider.close();
   }
}

tileProvider = new MyTileProvider(this, "test.mbtiles");

@Override
protected void onCreate(Bundle savedInstanceState) {
   ...
   minZoom = tileProvider.getMinZoom()
   maxZoom = tileProvider.getMaxZoom();
   map.setOnCameraChangeListener(this);
   …
}

@Override
public void onCameraChange(CameraPosition position) {
   if (minZoom != -1) {
      if (position.zoom < minZoom) 
         map.animateCamera(CameraUpdateFactory.zoomTo(minZoom));
   }
   if (maxZoom != -1) {
      if (position.zoom > maxZoom)
         map.animateCamera(CameraUpdateFactory.zoomTo(maxZoom));
   }
}

/**
 * Tile Provider
 *
 */
public class MyTileProvider implements TileProvider, Closeable {

  // declaration
  public static final int TILE_WIDTH = 256;
  public static final int TILE_HEIGHT = 256;

  private Context mContext;
  private DatabaseHelper dbHelper;

  public MyTileProvider(Context context, String name) {
    super();
    mContext = context;
    // load bd
    openTiles(name);
  }

  /**
  * Load Db
  * @param name
  */
  private void openTiles(String name) {
    dbHelper = new DatabaseHelper(mContext, name);
    try {
      dbHelper.createDatabase();

      dbHelper.openDataBase();
   
    } catch (IOException e) {
      Log.e(getClass().getName(), e.getMessage());
    }
  }

  @Override
  public Tile getTile(int x, int y, int zoom) {
    Tile result = null;
    // convert column due to te mbtile
    int column = ((int) (Math.pow(2, zoom) - y) - 1);
    // call request in db
    Cursor data = dbHelper.getTile(x, column, zoom);
    if (data != null) {
      if (data.moveToFirst()) {
        // get the bitmap
        int clmnindex = data.getColumnIndex("tile_data");
        byte[] img = data.getBlob(clmnindex);
        result = new Tile(TILE_WIDTH, TILE_HEIGHT, img);
      }
      data.close();
    }
    if (result == null) {
      // load an empty image
      result = NO_TILE;
    }
    return result;
  }

  /**
  * Get Bounds of map present in db
  * @return
  */
  public LatLngBounds getBounds() {
    LatLngBounds result = null;
    Cursor data = dbHelper.getBoundsMap();
    if (data != null) {
       if (data.moveToFirst()) {
        int columnIndex = data.getColumnIndex("value");
        String value = data.getString(columnIndex);
        String[] values = value.split(",");
        LatLng southwest = new LatLng(Double.parseDouble(values[1]),         Double.parseDouble(values[0]));
        LatLng northeast = new LatLng(Double.parseDouble(values[3]),         Double.parseDouble(values[2]));
        result = new LatLngBounds(southwest, northeast);
      }
      data.close();
    }
    return result;
  }

  /**
  * Get Min Zoom present in db
  * @return
  */
  public int getMinZoom() {
    Integer result = -1;
    Cursor data = dbHelper.getMinZoom();
    if (data != null) {
      if (data.moveToFirst()) {
        int columnIndex = data.getColumnIndex("value");
        result = data.getInt(columnIndex);

      }
      data.close();
    }
    return result;
  }

  /**
  * Get Max Zoom present in db
  * @return
  */
  public int getMaxZoom() {
    Integer result = -1;
    Cursor data = dbHelper.getMaxZoom();
    if (data != null) {
      if (data.moveToFirst()) {
        int columnIndex = data.getColumnIndex("value");
        result = data.getInt(columnIndex);
      }
      data.close();
    }
    return result;
  }

  @Override
  public void close() {
    if (dbHelper != null) {
      dbHelper.close();
    }
  }

  @Override
  protected void finalize() throws Throwable {
    super.finalize();
    // try it.
    close();
  }

}

/**
 * Load Db
 * @param name
 */
private void openTiles(String name) {
  dbHelper = new DatabaseHelper(mContext, name);
  try {
    dbHelper.createDatabase();
    dbHelper.openDataBase();
  } catch (IOException e) {
    Log.e(getClass().getName(), e.getMessage());
  }
}

@Override
public Tile getTile(int x, int y, int zoom) {
  Tile result = null;
  // convert column due to the mbtile
  int column = ((int) (Math.pow(2, zoom) - y) - 1);
  // call request in db
  Cursor data = dbHelper.getTile(x, column, zoom);
  if (data != null) {
    if (data.moveToFirst()) {
      // get the bitmap
      int clmnindex = data.getColumnIndex("tile_data");
      byte[] img = data.getBlob(clmnindex);
      result = new Tile(TILE_WIDTH, TILE_HEIGHT, img);
    }
    data.close();
  }
  if (result == null) {
    // load an empty image
    result = NO_TILE;
  }
  return result;
}

@Override
public void close() {
  if (dbHelper != null) {
    dbHelper.close();
  }
}

/**
 * The DataBase Helper 
 */
public class DatabaseHelper extends SQLiteOpenHelper {

   // TODO change it
    private static final String DB_SUBPATH = "/databases/";
   private String dbPath;
    private String dbName;
    private static final Integer DB_VERSION = 1;
    private SQLiteDatabase myDataBase;
   private final Context myContext;

   public DatabaseHelper (Context context, String name) {
        super(context, name, null, DB_VERSION);
        this.myContext = context;
      this.dbName = name;
       this.dbPath = context.getFilesDir().getAbsolutePath() + DB_SUBPATH;
        File file = new File(dbPath);
        if (!file.exists()) {
        file.mkdirs();
        }
   }

   /**
    * Create database
    * @param name
    * @throws IOException test
    */
   public void createDatabase() throws IOException {
       boolean isExist = isDatabaseExist();

       if (!isExist) {
           this.getReadableDatabase();
           try {
               copyDataBase();
            } catch (IOException e) {
            throw new Error("Error copying database");
            }
       }
   }

   /**
    * CopyDataBase from Asset to the internal storage
    * @param name
    * @throws IOException
    */
   private void copyDataBase() throws IOException {

       // Open your local db as the input stream
        InputStream myInput = myContext.getAssets().open(dbName);
       
        // Path to the just created empty db
        String outFileName = dbPath + dbName;

       // Open the empty db as the output stream
        OutputStream myOutput = new FileOutputStream(outFileName);

       // transfer bytes from the inputfile to the outputfile
        byte[] buffer = new byte[1024];
        int length;
       while ((length = myInput.read(buffer)) > 0) {
         myOutput.write(buffer, 0, length);
        }

       // Close the streams
        myOutput.flush();
        myOutput.close();
       myInput.close();
   }

   /**
    * Test if the database already exist
    * @return
    */
   private boolean isDatabaseExist() {
      SQLiteDatabase control = null;

      try {
          String myPath = dbPath + dbName;
            control = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
        } catch (SQLiteException e) {
        control = null;
       }

       if (control != null) {
        control.close();
       }
        return control != null ? true : false;
   }

   /**
    * Open DataBase
    * @throws SQLException
    */
   public void openDataBase() throws SQLException {

        // Open the database
       String myPath = dbPath + dbName;
        myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);

   }

   /**
    * Get Tile in Database
    * @param row : the row 
    * @param column : the column,
    * @param zoom : the zoom
    * @return the byte[]
    */
   public Cursor getTile(int row, int column, int zoom) {

        return myDataBase.query("tiles", new String[] {"tile_data"}, "tile_row = ? AND tile_column = ? AND zoom_level = ?", 
        new String[]{Integer.toString(column), Integer.toString(row), Integer.toString(zoom)}, null, null, null);
   }
   
   /**
    * Get Bounds present in db
    * @return
    */
   public Cursor getBoundsMap() {
        return myDataBase.query("metadata", new String[] {"value"}, "name like \"bounds\"", null, null, null, null);
   }
   
   /**
    * get Min Zoom present in db
    * @return
    */
   public Cursor getMinZoom() {
        return myDataBase.query("metadata", new String[] {"value"}, "name like \"minzoom\"", null, null, null, null);
   }
   
   /**
    * get Max Zoom present in db
    * @return
    */
   public Cursor getMaxZoom() {
        return myDataBase.query("metadata", new String[] {"value"}, "name like \"maxzoom\"", null, null, null, null);
   }

   @Override
   public synchronized void close() {
       if (myDataBase != null)
            myDataBase.close();
        super.close();
   }

   @Override
   public void onCreate(SQLiteDatabase db) {
   }

   @Override
   public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
   }
}