Android
Google Maps API v2 pour Android

Paramètres

Remarques

Activité Google Map par défaut

Ce code d'activité fournira des fonctionnalités de base pour inclure une carte Google Map utilisant un SupportMapFragment.

L'API Google Maps V2 comprend un tout nouveau moyen de charger des cartes.

Les activités doivent maintenant implémenter l'interface OnMapReadyCallBack, qui vient avec une substitution de la méthode onMapReady () qui est à chaque fois exécuté , nous courons SupportMapFragment. getMapAsync (OnMapReadyCallback) ; et l'appel est terminé avec succès.

Les cartes utilisent des marqueurs , des polygones et des lignes linéaires pour afficher des informations interactives à l'utilisateur.

MapsActivity.java:

public class MapsActivity extends AppCompatActivity implements OnMapReadyCallback {

    private GoogleMap mMap;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_maps);
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    }

    @Override
    public void onMapReady(GoogleMap googleMap) {
        mMap = googleMap;

        // Add a marker in Sydney, Australia, and move the camera.
        LatLng sydney = new LatLng(-34, 151);
        mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
        mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));
    }
}

Notez que le code ci-dessus gonfle une mise en page, qui a un SupportMapFragment imbriqué dans la présentation du conteneur, défini avec un ID de R.id.map . Le fichier de disposition est illustré ci-dessous:

activity_maps.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:map="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/map"
        tools:context="com.example.app.MapsActivity"
        android:name="com.google.android.gms.maps.SupportMapFragment"/>

</LinearLayout>

Styles Google Map personnalisés

Style de carte

Google Maps est fourni avec un ensemble de styles différents à appliquer à l'aide de ce code:

// Sets the map type to be "hybrid"
map.setMapType(GoogleMap.MAP_TYPE_HYBRID);

Les différents styles de carte sont les suivants:

Ordinaire

map.setMapType(GoogleMap.MAP_TYPE_NORMAL);

Carte routière typique. Les routes, certaines caractéristiques créées par l'homme et d'importantes caractéristiques naturelles telles que les rivières sont représentées. Les étiquettes de route et de caractéristique sont également visibles.

Hybride

map.setMapType(GoogleMap.MAP_TYPE_HYBRID);

Données de photographie satellite avec cartes routières ajoutées. Les étiquettes de route et de caractéristique sont également visibles.

Satellite

map.setMapType(GoogleMap.MAP_TYPE_SATELLITE);

Données de photographie par satellite. Les étiquettes de route et de caractéristique ne sont pas visibles.

Terrain

map.setMapType(GoogleMap.MAP_TYPE_TERRAIN);

Données topographiques. La carte comprend les couleurs, les lignes de contour et les étiquettes, ainsi que les ombres de perspective. Certaines routes et étiquettes sont également visibles.

Aucun

map.setMapType(GoogleMap.MAP_TYPE_NONE);

Pas de tuiles La carte sera rendue comme une grille vide sans tuiles chargées.

AUTRES OPTIONS DE STYLE

Cartes intérieures

À des niveaux de zoom élevés, la carte affichera les plans d’étage des espaces intérieurs. Celles-ci sont appelées cartes d'intérieur et ne sont affichées que pour les types de carte «normale» et «satellite».

pour activer ou désactiver les cartes intérieures, voici comment cela se passe:

GoogleMap.setIndoorEnabled(true).
GoogleMap.setIndoorEnabled(false).

Nous pouvons ajouter des styles personnalisés aux cartes.

Dans la méthode onMapReady, ajoutez l'extrait de code suivant

mMap = googleMap;
    try {
        // Customise the styling of the base map using a JSON object defined
        // in a raw resource file.
        boolean success = mMap.setMapStyle(
                MapStyleOptions.loadRawResourceStyle(
                        MapsActivity.this, R.raw.style_json));

        if (!success) {
            Log.e(TAG, "Style parsing failed.");
        }
    } catch (Resources.NotFoundException e) {
        Log.e(TAG, "Can't find style.", e);
    }

sous le dossier res , créez un nom de dossier brut et ajoutez le fichier styles json. Exemple de fichier style.json

    [
  {
    "featureType": "all",
    "elementType": "geometry",
    "stylers": [
      {
        "color": "#242f3e"
      }
    ]
  },
  {
    "featureType": "all",
    "elementType": "labels.text.stroke",
    "stylers": [
      {
        "lightness": -80
      }
    ]
  },
  {
    "featureType": "administrative",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#746855"
      }
    ]
  },
  {
    "featureType": "administrative.locality",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#d59563"
      }
    ]
  },
  {
    "featureType": "poi",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#d59563"
      }
    ]
  },
  {
    "featureType": "poi.park",
    "elementType": "geometry",
    "stylers": [
      {
        "color": "#263c3f"
      }
    ]
  },
  {
    "featureType": "poi.park",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#6b9a76"
      }
    ]
  },
  {
    "featureType": "road",
    "elementType": "geometry.fill",
    "stylers": [
      {
        "color": "#2b3544"
      }
    ]
  },
  {
    "featureType": "road",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#9ca5b3"
      }
    ]
  },
  {
    "featureType": "road.arterial",
    "elementType": "geometry.fill",
    "stylers": [
      {
        "color": "#38414e"
      }
    ]
  },
  {
    "featureType": "road.arterial",
    "elementType": "geometry.stroke",
    "stylers": [
      {
        "color": "#212a37"
      }
    ]
  },
  {
    "featureType": "road.highway",
    "elementType": "geometry.fill",
    "stylers": [
      {
        "color": "#746855"
      }
    ]
  },
  {
    "featureType": "road.highway",
    "elementType": "geometry.stroke",
    "stylers": [
      {
        "color": "#1f2835"
      }
    ]
  },
  {
    "featureType": "road.highway",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#f3d19c"
      }
    ]
  },
  {
    "featureType": "road.local",
    "elementType": "geometry.fill",
    "stylers": [
      {
        "color": "#38414e"
      }
    ]
  },
  {
    "featureType": "road.local",
    "elementType": "geometry.stroke",
    "stylers": [
      {
        "color": "#212a37"
      }
    ]
  },
  {
    "featureType": "transit",
    "elementType": "geometry",
    "stylers": [
      {
        "color": "#2f3948"
      }
    ]
  },
  {
    "featureType": "transit.station",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#d59563"
      }
    ]
  },
  {
    "featureType": "water",
    "elementType": "geometry",
    "stylers": [
      {
        "color": "#17263c"
      }
    ]
  },
  {
    "featureType": "water",
    "elementType": "labels.text.fill",
    "stylers": [
      {
        "color": "#515c6d"
      }
    ]
  },
  {
    "featureType": "water",
    "elementType": "labels.text.stroke",
    "stylers": [
      {
        "lightness": -20
      }
    ]
  }
]

Pour générer des fichiers json styles, cliquez sur ce lien

Ajouter des marqueurs à une carte

Pour ajouter des marqueurs à une carte Google, par exemple à partir d’une ArrayList d’objets MyLocation , nous pouvons le faire de cette manière.

La classe de titulaire MyLocation :

public class MyLocation {
  LatLng latLng;
  String title;
  String snippet;
}

Voici une méthode qui prendrait une liste d'objets MyLocation et placerait un marqueur pour chacun d'eux:

private void LocationsLoaded(List<MyLocation> locations){
 
 for (MyLocation myLoc : locations){
    mMap.addMarker(new MarkerOptions()
     .position(myLoc.latLng)
     .title(myLoc.title)
     .snippet(myLoc.snippet)
     .icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_MAGENTA));
 }
}

Remarque: Pour les besoins de cet exemple, mMap est une variable membre de classe de l'activité, dans laquelle nous l'avons affectée à la référence de carte reçue dans le onMapReady() .

MapView: incorporation d'un GoogleMap dans une mise en page existante

Il est possible de traiter un GoogleMap comme une vue Android si nous utilisons la classe MapView fournie. Son utilisation est très similaire à MapFragment.

Dans votre mise en page, utilisez MapView comme suit:

<com.google.android.gms.maps.MapView 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:map="http://schemas.android.com/apk/res-auto"
    android:id="@+id/map"
    android:layout_width="match_parent"
    android:layout_height="match_parent" 
    <!-- 
    map:mapType="0" Specifies a change to the initial map type
    map:zOrderOnTop="true"  Control whether the map view's surface is placed on top of its window
    map:useVieLifecycle="true" When using a MapFragment, this flag specifies whether the lifecycle of the map should be tied to the fragment's view or the fragment itself
    map:uiCompass="true" Enables or disables the compass
    map:uiRotateGestures="true" Sets the preference for whether rotate gestures should be enabled or disabled
    map:uiScrollGestures="true" Sets the preference for whether scroll gestures should be enabled or disabled
    map:uiTiltGestures="true" Sets the preference for whether tilt gestures should be enabled or disabled
    map:uiZoomGestures="true" Sets the preference for whether zoom gestures should be enabled or disabled
    map:uiZoomControls="true" Enables or disables the zoom controls
    map:liteMode="true" Specifies whether the map should be created in lite mode
    map:uiMapToolbar="true" Specifies whether the mapToolbar should be enabled
    map:ambientEnabled="true" Specifies whether ambient-mode styling should be enabled
    map:cameraMinZoomPreference="0.0" Specifies a preferred lower bound for camera zoom
    map:cameraMaxZoomPreference="1.0" Specifies a preferred upper bound for camera zoom -->
    />

Votre activité doit implémenter l'interface OnMapReadyCallback pour fonctionner:

/**
* This shows how to create a simple activity with a raw MapView and add a marker to it. This
* requires forwarding all the important lifecycle methods onto MapView.
*/
public class RawMapViewDemoActivity extends AppCompatActivity implements OnMapReadyCallback {

    private MapView mMapView;

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

        mMapView = (MapView) findViewById(R.id.map);
        mMapView.onCreate(savedInstanceState);

        mMapView.getMapAsync(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        mMapView.onResume();
    }

    @Override
    public void onMapReady(GoogleMap map) {
        map.addMarker(new MarkerOptions().position(new LatLng(0, 0)).title("Marker"));
    }

    @Override
    protected void onPause() {
        mMapView.onPause();
        super.onPause();
    }

    @Override
    protected void onDestroy() {
        mMapView.onDestroy();
        super.onDestroy();
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();
        mMapView.onLowMemory();
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mMapView.onSaveInstanceState(outState);
    }
}

Afficher la position actuelle dans une carte Google

Voici une classe d'activité complète qui place un marqueur à l'emplacement actuel et déplace également la caméra vers la position actuelle.

Il se passe quelque chose dans l'ordre ici:

• Vérifier l'autorisation de localisation
• Une fois l'autorisation d'emplacement accordée, appelez setMyLocationEnabled() , créez GoogleApiClient et connectez-le.
• Une fois que GoogleApiClient est connecté, demandez des mises à jour de l'emplacement

public class MapLocationActivity extends AppCompatActivity
        implements OnMapReadyCallback,
        GoogleApiClient.ConnectionCallbacks,
        GoogleApiClient.OnConnectionFailedListener,
        LocationListener {

    GoogleMap mGoogleMap;
    SupportMapFragment mapFrag;
    LocationRequest mLocationRequest;
    GoogleApiClient mGoogleApiClient;
    Location mLastLocation;
    Marker mCurrLocationMarker;

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

        getSupportActionBar().setTitle("Map Location Activity");

        mapFrag = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFrag.getMapAsync(this);
    }

    @Override
    public void onPause() {
        super.onPause();

        //stop location updates when Activity is no longer active
        if (mGoogleApiClient != null) {
            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
        }
    }

    @Override
    public void onMapReady(GoogleMap googleMap)
    {
        mGoogleMap=googleMap;
        mGoogleMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);

        //Initialize Google Play Services
        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(this,
                    Manifest.permission.ACCESS_FINE_LOCATION)
                    == PackageManager.PERMISSION_GRANTED) {
                //Location Permission already granted
                buildGoogleApiClient();
                mGoogleMap.setMyLocationEnabled(true);
            } else {
                //Request Location Permission
                checkLocationPermission();
            }
        }
        else {
            buildGoogleApiClient();
            mGoogleMap.setMyLocationEnabled(true);
        }
    }

    protected synchronized void buildGoogleApiClient() {
        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API)
                .build();
        mGoogleApiClient.connect();
    }

    @Override
    public void onConnected(Bundle bundle) {
        mLocationRequest = new LocationRequest();
        mLocationRequest.setInterval(1000);
        mLocationRequest.setFastestInterval(1000);
        mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
        if (ContextCompat.checkSelfPermission(this,
                Manifest.permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
            LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
        }
    }

    @Override
    public void onConnectionSuspended(int i) {}

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {}

    @Override
    public void onLocationChanged(Location location)
    {
        mLastLocation = location;
        if (mCurrLocationMarker != null) {
            mCurrLocationMarker.remove();
        }

        //Place current location marker
        LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude());
        MarkerOptions markerOptions = new MarkerOptions();
        markerOptions.position(latLng);
        markerOptions.title("Current Position");
        markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_MAGENTA));
        mCurrLocationMarker = mGoogleMap.addMarker(markerOptions);

        //move map camera
        mGoogleMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
        mGoogleMap.animateCamera(CameraUpdateFactory.zoomTo(11));

        //stop location updates
        if (mGoogleApiClient != null) {
            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
        }
    }

    public static final int MY_PERMISSIONS_REQUEST_LOCATION = 99;
    private void checkLocationPermission() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {

            // Should we show an explanation?
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                    Manifest.permission.ACCESS_FINE_LOCATION)) {

                // Show an explanation to the user *asynchronously* -- don't block
                // this thread waiting for the user's response! After the user
                // sees the explanation, try again to request the permission.
                new AlertDialog.Builder(this)
                        .setTitle("Location Permission Needed")
                        .setMessage("This app needs the Location permission, please accept to use location functionality")
                        .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialogInterface, int i) {
                                //Prompt the user once explanation has been shown
                                ActivityCompat.requestPermissions(MapLocationActivity.this,
                                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                                        MY_PERMISSIONS_REQUEST_LOCATION );
                            }
                        })
                        .create()
                        .show();


            } else {
                // No explanation needed, we can request the permission.
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                        MY_PERMISSIONS_REQUEST_LOCATION );
            }
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        switch (requestCode) {
            case MY_PERMISSIONS_REQUEST_LOCATION: {
                // If request is cancelled, the result arrays are empty.
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                    // permission was granted, yay! Do the
                    // location-related task you need to do.
                    if (ContextCompat.checkSelfPermission(this,
                            Manifest.permission.ACCESS_FINE_LOCATION)
                            == PackageManager.PERMISSION_GRANTED) {

                        if (mGoogleApiClient == null) {
                            buildGoogleApiClient();
                        }
                        mGoogleMap.setMyLocationEnabled(true);
                    }

                } else {

                    // permission denied, boo! Disable the
                    // functionality that depends on this permission.
                    Toast.makeText(this, "permission denied", Toast.LENGTH_LONG).show();
                }
                return;
            }

            // other 'case' lines to check for other
            // permissions this app might request
        }
    }

}

activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:map="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/map"
        tools:context="com.example.app.MapLocationActivity"
        android:name="com.google.android.gms.maps.SupportMapFragment"/>

</LinearLayout>

Résultat:

Affiche des explications si nécessaire sur Marshmallow et Nougat à l'aide d'un AlertDialog (ce cas se produit lorsque l'utilisateur a précédemment refusé une demande d'autorisation, ou lui a accordé l'autorisation et l'a ensuite révoqué dans les paramètres):

Invitez l'utilisateur à obtenir l'autorisation Location sur Marshmallow et Nougat en appelant ActivityCompat.requestPermissions() :

Déplacez la caméra vers l'emplacement actuel et placez le marqueur lorsque l'autorisation de localisation est accordée:

Obtention de l'empreinte SH1 de votre fichier de clés de certificat

Pour obtenir une clé API Google Maps pour votre certificat, vous devez fournir à la console API l’empreinte SH1 de votre fichier de clés de débogage / édition.

Vous pouvez obtenir le fichier de clés à l'aide du programme keytool du JDK, comme décrit ici dans les documents.

Une autre approche consiste à obtenir l'empreinte digitale par programmation en exécutant cet extrait de code avec votre application signée avec le certificat de débogage / édition et en imprimant le hachage dans le journal.

PackageInfo info;
try {
    info = getPackageManager().getPackageInfo("com.package.name", PackageManager.GET_SIGNATURES);
    for (Signature signature : info.signatures) {
        MessageDigest md;
        md = MessageDigest.getInstance("SHA");
        md.update(signature.toByteArray());
        String hash= new String(Base64.encode(md.digest(), 0));
        Log.e("hash", hash);
    }
} catch (NameNotFoundException e1) {
    Log.e("name not found", e1.toString());
} catch (NoSuchAlgorithmException e) {
    Log.e("no such an algorithm", e.toString());
} catch (Exception e) {
    Log.e("exception", e.toString());
}

Ne lancez pas Google Maps lorsque la carte est cliquée (mode lite)

Lorsqu'une carte Google est affichée en mode allégé, un clic sur une carte ouvre l'application Google Maps. Pour désactiver cette fonctionnalité, vous devez appeler setClickable(false) sur MapView , par exemple :

final MapView mapView = (MapView)view.findViewById(R.id.map);
mapView.setClickable(false);

UISettings

En utilisant les UISettings , l'apparence de Google Map peut être modifiée.

Voici un exemple de paramètres communs:

    mGoogleMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
    mGoogleMap.getUiSettings().setMapToolbarEnabled(true);
    mGoogleMap.getUiSettings().setZoomControlsEnabled(true);
    mGoogleMap.getUiSettings().setCompassEnabled(true);

Résultat:

Obtenir l'empreinte SHA1 du débogage

1. Ouvrir Android Studio
2. Ouvrez votre projet
3. Cliquez sur Gradle (du panneau latéral droit, vous verrez Barre Gradle )
4. Cliquez sur Actualiser (Cliquez sur Actualiser dans Gradle Bar , vous verrez les scripts de liste de votre projet)
5. Cliquez sur votre projet (Votre formulaire Nom du projet Liste (racine))
6. Cliquez sur les tâches
7. Cliquez sur Android
8. Cliquez deux fois sur la signatureSignaler (vous obtiendrez SHA1 et MD5 dans la barre d' exécution)

InfoWindow Click Listener

Voici un exemple de la façon de définir une action différente pour chaque événement de clic InfoWindow du marqueur.

Utilisez un HashMap dans lequel l'ID du marqueur est la clé et la valeur correspond à l'action correspondante à effectuer lorsque l'utilisateur clique sur InfoWindow.

Ensuite, utilisez un OnInfoWindowClickListener pour gérer l'événement d'un utilisateur qui clique sur InfoWindow et utilisez HashMap pour déterminer l'action à entreprendre.

Dans cet exemple simple, nous allons ouvrir une activité différente en fonction de laquelle l'utilisateur a cliqué sur InfoWindow.

Déclarez le HashMap comme variable d’instance de l’activité ou du fragment:

 //Declare HashMap to store mapping of marker to Activity
HashMap<String, String> markerMap = new HashMap<String, String>();

Ensuite, chaque fois que vous ajoutez un marqueur, effectuez une entrée dans HashMap avec l'ID de marqueur et l'action à effectuer lorsque l'utilisateur clique sur InfoWindow.

Par exemple, ajouter deux marqueurs et définir une action à entreprendre pour chacun:

Marker markerOne = googleMap.addMarker(new MarkerOptions().position(latLng1)
        .title("Marker One")
        .snippet("This is Marker One");
String idOne = markerOne.getId();
markerMap.put(idOne, "action_one");

Marker markerTwo = googleMap.addMarker(new MarkerOptions().position(latLng2)
        .title("Marker Two")
        .snippet("This is Marker Two");
String idTwo = markerTwo.getId();
markerMap.put(idTwo, "action_two");

Dans InfoWindow, cliquez sur le port d'écoute, obtenez l'action de HashMap et ouvrez l'activité correspondante en fonction de l'action du marqueur:

 mGoogleMap.setOnInfoWindowClickListener(new GoogleMap.OnInfoWindowClickListener() {
  @Override
  public void onInfoWindowClick(Marker marker) {

    String actionId = markerMap.get(marker.getId());

    if (actionId.equals("action_one")) {
      Intent i = new Intent(MainActivity.this, ActivityOne.class);
      startActivity(i);
    } else if (actionId.equals("action_two")) {
      Intent i = new Intent(MainActivity.this, ActivityTwo.class);
      startActivity(i);
    }
  }
});

Remarque Si le code est dans un fragment, remplacez MainActivity.this par getActivity ().

Changer le décalage

En modifiant les valeurs de x et y de mappoint, vous pouvez modifier la possibilité de décalage de google map. Par défaut, elle sera au centre de la vue de carte. Appelez ci-dessous la méthode où vous voulez le changer! Mieux vaut l'utiliser dans votre onLocationChanged comme changeOffsetCenter(location.getLatitude(),location.getLongitude());

 public void changeOffsetCenter(double latitude,double longitude) {
            Point mappoint = mGoogleMap.getProjection().toScreenLocation(new LatLng(latitude, longitude));
            mappoint.set(mappoint.x, mappoint.y-100); // change these values as you need , just hard coded a value if you want you can give it based on a ratio like using DisplayMetrics  as well
            mGoogleMap.animateCamera(CameraUpdateFactory.newLatLng(mGoogleMap.getProjection().fromScreenLocation(mappoint)));
        }