Android
Android के लिए Google मैप्स API v2

पैरामीटर

टिप्पणियों

डिफ़ॉल्ट Google मानचित्र गतिविधि

यह गतिविधि कोड एक समर्थन मैपफ़्रेग्मेंट का उपयोग करके Google मानचित्र को शामिल करने के लिए बुनियादी कार्यक्षमता प्रदान करेगा।

Google मानचित्र V2 API में मानचित्र लोड करने का एक नया तरीका शामिल है।

अब गतिविधियों को OnMapReadyCallBack इंटरफ़ेस को कार्यान्वित करना होगा , जो कि ऑनपार्टरेडी () विधि ओवरराइड के साथ आता है जिसे हर बार जब हम SupportMapFragment चलाते हैं, निष्पादित किया जाता है। getMapAsync (OnMapReadyCallback) ; और कॉल सफलतापूर्वक पूरा हो गया है।

नक्शे का उपयोग मार्करों , बहुभुज और पोलीलाइंस उपयोगकर्ता के लिए इंटरेक्टिव जानकारी दिखाने के लिए।

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

ध्यान दें कि ऊपर का कोड एक लेआउट को फुलाता है, जिसमें कंटेनर लेआउट के अंदर एक SupportMapFragment नेस्टेड है, जिसे R.id.map की एक आईडी के साथ परिभाषित किया गया है। लेआउट फ़ाइल नीचे दिखाई गई है:

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>

कस्टम Google मानचित्र शैलियाँ

नक्शा शैली

Google मानचित्र इस कोड का उपयोग करके विभिन्न शैलियों के एक सेट के साथ आते हैं:

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

विभिन्न मानचित्र शैलियाँ हैं:

साधारण

map.setMapType(GoogleMap.MAP_TYPE_NORMAL);

ठेठ रोड मैप। सड़कें, कुछ मानव निर्मित सुविधाएँ, और महत्वपूर्ण प्राकृतिक सुविधाएँ जैसे कि नदियाँ दिखाई जाती हैं। सड़क और सुविधा लेबल भी दिखाई दे रहे हैं।

संकर

map.setMapType(GoogleMap.MAP_TYPE_HYBRID);

रोड मैप के साथ सैटेलाइट फोटोग्राफ डेटा जोड़ा गया। सड़क और सुविधा लेबल भी दिखाई दे रहे हैं।

उपग्रह

map.setMapType(GoogleMap.MAP_TYPE_SATELLITE);

सैटेलाइट फोटोग्राफ डेटा। सड़क और सुविधा लेबल दिखाई नहीं दे रहे हैं।

इलाक़ा

map.setMapType(GoogleMap.MAP_TYPE_TERRAIN);

स्थलाकृतिक डेटा। मानचित्र में रंग, समोच्च रेखाएँ और लेबल और परिप्रेक्ष्य छायांकन शामिल हैं। कुछ सड़कें और लेबल भी दिखाई दे रहे हैं।

कोई नहीं

map.setMapType(GoogleMap.MAP_TYPE_NONE);

कोई टाइल नहीं। नक्शे को खाली ग्रिड के रूप में प्रस्तुत किया जाएगा जिसमें कोई टाइल लोड नहीं होगी।

अन्य स्टाइल विकल्प

इंडोर मैप्स

उच्च ज़ूम स्तरों पर, मानचित्र इनडोर रिक्त स्थान के लिए फ़्लोर प्लान दिखाएगा। इन्हें इनडोर मानचित्र कहा जाता है, और केवल 'सामान्य' और 'उपग्रह' मानचित्र प्रकारों के लिए प्रदर्शित किया जाता है।

इनडोर मानचित्रों को सक्षम या अक्षम करने के लिए, यह इस प्रकार है:

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

हम नक्शे में कस्टम शैली जोड़ सकते हैं।

OnMapReady मेथड में निम्नलिखित कोड स्निपेट जोड़ते है

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

Res फ़ोल्डर के तहत एक फ़ोल्डर नाम कच्चा और शैलियों json फ़ाइल जोड़ें। नमूना 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
      }
    ]
  }
]

शैलियों को उत्पन्न करने के लिए json फ़ाइल इस लिंक पर क्लिक करें

मानचित्र में मार्कर जोड़ना

Google मानचित्र में मार्कर जोड़ने के लिए, उदाहरण के लिए MyLocation ऑब्जेक्ट्स के एक ArrayList से, हम इसे इस तरह से कर सकते हैं।

MyLocation धारक वर्ग:

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

यहाँ एक विधि है जो MyLocation ऑब्जेक्ट्स की एक सूची MyLocation और प्रत्येक के लिए एक मार्कर MyLocation :

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

नोट: इस उदाहरण के प्रयोजन के लिए, mMap का एक वर्ग सदस्य चर है, जहां हमने इसे onMapReady() ओवरराइड में प्राप्त मानचित्र संदर्भ को सौंपा है।

MapView: किसी मौजूदा लेआउट में GoogleMap एम्बेड करना

यदि हम प्रदान किए गए MapView वर्ग का उपयोग करते हैं, तो Google मानचित्र को Android दृश्य के रूप में मानना संभव है। इसका उपयोग MapFragment के समान है।

अपने लेआउट में निम्नानुसार MapView का उपयोग करें:

<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 -->
    />

आपकी गतिविधि को कार्य करने के लिए OnMapReadyCallback इंटरफ़ेस लागू करने की आवश्यकता है:

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

Google मानचित्र में वर्तमान स्थान दिखाएं

यहां एक पूर्ण गतिविधि वर्ग है जो वर्तमान स्थान पर एक मार्कर रखता है, और कैमरे को वर्तमान स्थिति में भी ले जाता है।

अनुक्रम में कुछ चीजें यहां चल रही हैं:

• स्थान की अनुमति की जाँच करें
• एक बार स्थान की अनुमति मिल जाने के बाद, setMyLocationEnabled() , GoogleApiClient का निर्माण करें, और इसे कनेक्ट करें
• GoogleApiClient कनेक्ट होने के बाद, स्थान अपडेट का अनुरोध करें

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>

परिणाम:

यदि AlshDialog का उपयोग करके मार्शमैलो और नूगट पर जरूरत पड़ने पर स्पष्टीकरण दिखाएं (यह मामला तब होता है जब उपयोगकर्ता ने पहले एक अनुमति अनुरोध से इनकार कर दिया था, या अनुमति दी थी और फिर बाद में इसे सेटिंग्स में रद्द कर दिया था):

ActivityCompat.requestPermissions() द्वारा मार्शमैलो और नूगट पर स्थान अनुमति के लिए उपयोगकर्ता को प्रेरित करें: ActivityCompat.requestPermissions()

कैमरा को वर्तमान स्थान पर ले जाएं और स्थान की अनुमति दी जाने पर मार्कर को लगाएं।

अपने सर्टिफिकेट कीस्टॉर फाइल के SH1-फिंगरप्रिंट को प्राप्त करना

अपने प्रमाणपत्र के लिए Google मानचित्र API कुंजी प्राप्त करने के लिए, आपको अपने डीबग / रिलीज़ कीस्टोर के SH1-फिंगरप्रिंट के साथ एपीआई कंसोल प्रदान करना होगा।

डॉक्स के यहाँ वर्णित के रूप में आप JDK के कीटूल प्रोग्राम का उपयोग करके कीस्टोर प्राप्त कर सकते हैं।

एक अन्य तरीका यह है कि इस स्निपेट को डिबग / रिलीज़ सर्टिफिकेट के साथ साइन करके और लॉग में हैश को प्रिंट करके फिंगरप्रिंट प्रोग्राम को प्राप्त करें।

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());
}

जब नक्शा क्लिक किया जाता है तो गूगल मैप्स लॉन्च न करें (लाइट मोड)

जब एक Google मानचित्र एक मैप पर क्लिक करके लाइट मोड में प्रदर्शित होता है, तो Google मैप्स एप्लिकेशन खुल जाएगा। इस कार्यक्षमता को अक्षम करने के लिए आपको MapView पर setClickable(false) कॉल करना होगा, जैसे :

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

UISettings

UISettings का उपयोग UISettings , Google मानचित्र की उपस्थिति को संशोधित किया जा सकता है।

यहाँ कुछ सामान्य सेटिंग्स का एक उदाहरण दिया गया है:

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

परिणाम:

डीबग SHA1 फ़िंगरप्रिंट प्राप्त करें

1. Android स्टूडियो खोलें
2. अपना प्रोजेक्ट खोलें
3. ग्रेडल पर क्लिक करें (राइट साइड पैनल से, आप ग्रेडल बार देखेंगे)
4. रीफ्रेश पर क्लिक करें ( ग्रैड बार से रिफ्रेश पर क्लिक करें, आपको अपने प्रोजेक्ट की लिस्ट ग्रेड लिपि दिखाई देगी)
5. अपने प्रोजेक्ट पर क्लिक करें (आपका प्रोजेक्ट नाम फॉर्म सूची (रूट))
6. कार्य पर क्लिक करें
7. Android पर क्लिक करें
8. साइन इन करें पर डबल क्लिक करें (आप रन बार में SHA1 और MD5 प्राप्त करेंगे)

InfoWindow श्रोता पर क्लिक करें

प्रत्येक मार्कर की जानकारी के लिए एक अलग कार्रवाई को कैसे परिभाषित किया जाए, इसका एक उदाहरण यहां दिया गया है। घटना पर क्लिक करें।

एक HashMap का उपयोग करें जिसमें मार्कर आईडी कुंजी है, और मूल्य उसी कार्रवाई है जिसे InfoWindow क्लिक करने पर लिया जाना चाहिए।

फिर, OnInfoWindowClickListener पर क्लिक करने वाले उपयोगकर्ता की घटना को संभालने के लिए एक OnInfoWindowClickListener का उपयोग करें, और कौन-सी कार्रवाई करें, यह निर्धारित करने के लिए HashMap का उपयोग करें।

इस सरल उदाहरण में हम एक अलग गतिविधि खोलेंगे, जिसके आधार पर मार्कर की इन्फोविन्डू पर क्लिक किया गया था।

एक्टिविटी या फ्रैगमेंट के उदाहरण चर के रूप में हैशपेयर की घोषणा करें:

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

फिर, हर बार जब आप एक मार्कर जोड़ते हैं, तो मार्कर आईडी के साथ हाशपैप में एक प्रविष्टि करें और जब यह InfoWindow पर क्लिक किया जाता है, तो यह कार्रवाई होनी चाहिए।

उदाहरण के लिए, दो मार्करों को जोड़ना और प्रत्येक के लिए एक क्रिया को परिभाषित करना:

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");

InfoWindow क्लिक श्रोता में, HashMap से कार्रवाई करें, और मार्कर की कार्रवाई के आधार पर संबंधित गतिविधि खोलें:

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

नोट यदि कोड एक खंड में है, तो GetActivity () के साथ MainActivity.this को प्रतिस्थापित करें।

ऑफसेट बदलो

आपकी आवश्यकता के अनुसार mappoint x और y मानों को बदलकर, आप Google मानचित्र के ऑफसेट कब्जे को बदल सकते हैं, डिफ़ॉल्ट रूप से यह मानचित्र दृश्य के केंद्र में होगा। नीचे विधि को कॉल करें जहां आप इसे बदलना चाहते हैं! अपने onLocationChanged अंदर इसका उपयोग करने के लिए बेहतर है जैसे 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)));
        }