Wear OS पर Maps API

पहने जाने वाले डिवाइस पर मैप

Android के लिए Maps SDK टूल का इस्तेमाल करके, आप मैप के हिसाब से पहने जाने वाले किसी ऐप्लिकेशन को बना सकते हैं, जो सीधे Wear OS by Google डिवाइस पर काम करता है. आपके ऐप्लिकेशन के उपयोगकर्ता, मैप पर सिर्फ़ अपनी कलाई पर नज़र डालकर अपनी जगह देख सकते हैं. उदाहरण के लिए, वे किसी रास्ते पर उनकी स्थिति प्लॉट कर सकते हैं, फिर विवरण के लिए ज़ूम इन कर सकते हैं या आपके ऐप्लिकेशन से मिली जानकारी विंडो देखने के लिए किसी मार्कर पर टैप कर सकते हैं.

इस पेज पर, Wear डिवाइसों पर उपलब्ध एपीआई के फ़ंक्शन के बारे में जानकारी दी गई है. इसके अलावा, ऐप्लिकेशन बनाने में भी आपकी मदद की जा सकती है.

Wear OS का इस्तेमाल शुरू करना

Android के लिए Maps SDK टूल वाला एक पहने जाने वाला ऐप्लिकेशन बनाना, बुनियादी तौर पर किसी दूसरे Android डिवाइस के लिए Google Maps ऐप्लिकेशन बनाने जैसा ही है. ये अंतर पहने जाने वाले डिवाइस के छोटे फ़ॉर्म फ़ैक्टर के लिए, आपके डिज़ाइन में शामिल हैं. इससे ऐप्लिकेशन की उपयोगिता और परफ़ॉर्मेंस को बेहतर बनाया जा सकता है.

Android Studio, Wear OS डेवलपमेंट के लिए सुझाया गया टूल है. इससे प्रोजेक्ट सेट अप, लाइब्रेरी, और पैकेजिंग से जुड़ी सुविधाएं मिलती हैं.

पहने जाने वाले डिवाइस को डिज़ाइन करने में सामान्य मदद पाने के लिए, Wear OS डिज़ाइन दिशा-निर्देश देखें. अपना पहला पहने जाने वाला ऐप्लिकेशन बनाने में मदद के लिए, पहने जाने वाले ऐप्लिकेशन बनाने के लिए गाइड देखें.

Wear OS पर, अपना पहला मैप ऐप्लिकेशन बनाना

यह क्विक गाइड यह मान लेती है कि आप Android के लिए Maps SDK टूल के बारे में जानते हैं. आपने ऐप्लिकेशन में पहने जाने वाले किसी मॉड्यूल को बनाने के लिए, Wear OS की गाइड को फ़ॉलो किया है और अब आप पहने जाने वाले मॉड्यूल में मैप जोड़ना चाहते हैं.

कपड़ों के मॉड्यूल के लिए डिपेंडेंसी जोड़ना

पक्का करें कि आपके ऐप्लिकेशन के Wear OS मॉड्यूल की build.gradle फ़ाइल में ये डिपेंडेंसी शामिल की गई हों:

dependencies {
    // ...
    compileOnly 'com.google.android.wearable:wearable:2.9.0'
    implementation 'com.google.android.support:wearable:2.9.0'
    implementation 'com.google.android.gms:play-services-maps:18.0.2'

    // This dependency is necessary for ambient mode
    implementation 'androidx.wear:wear:1.2.0'
}

डिपेंडेंसी के बारे में ज़्यादा जानकारी के लिए, अपने मौजूदा प्रोजेक्ट में Wear OS मॉड्यूल जोड़ने की गाइड देखें.

खारिज करने के लिए, स्वाइप करने का जेस्चर लागू करें और बैकग्राउंड के लिए कोई रंग सेट करें

हमारा सुझाव है कि पहने जाने वाले डिवाइस पर मैप दिखाने के लिए, SwipeDismissFrameLayout का इस्तेमाल करें. SwipeDismissFrameLayout क्लास का इस्तेमाल करके, आप स्वाइप-टू-डिमिज़ जेस्चर लागू कर सकते हैं. इससे, स्क्रीन पर बाईं ओर से स्वाइप करके उपयोगकर्ताओं को ऐप्लिकेशन से बाहर निकलने का तरीका मिल जाता है.

पसंद के मुताबिक शुरुआती बैकग्राउंड का रंग सेट करने के लिए, map:backgroundColor एक्सएमएल एट्रिब्यूट का इस्तेमाल करें, ताकि रंग की झलक तब तक दिखाई जाए, जब तक मैप की असली टाइलें लोड न हो जाएं.

अपने लेआउट की परिभाषा में SwipeDismissFrameLayout और backgroundColor एलिमेंट को SupportMapFragment के कंटेनर के तौर पर जोड़ें:

  <androidx.wear.widget.SwipeDismissFrameLayout
      android:id="@+id/map_container"
      android:layout_width="match_parent"
      android:layout_height="match_parent">
    <fragment
        android:id="@+id/map"
        android:name="com.google.android.gms.maps.SupportMapFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        map:backgroundColor="#fff0b2dd" />
  </androidx.wear.widget.SwipeDismissFrameLayout>

गतिविधि में SwipeDismissFrameLayout ऑब्जेक्ट मिलने पर, कॉलबैक जोड़ें और नीचे दिए गए तरीके से, खारिज करने की ज़रूरी कार्रवाई करें, इसके लिए कॉलबैक का व्यवहार सेट करें:

Java


public class MainActivity extends AppCompatActivity implements OnMapReadyCallback,
    AmbientModeSupport.AmbientCallbackProvider {


    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main);

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
        Log.d(MainActivity.class.getSimpleName(), "Is ambient enabled: " + controller.isAmbient());

        // Retrieve the containers for the root of the layout and the map. Margins will need to be
        // set on them to account for the system window insets.
        final SwipeDismissFrameLayout mapFrameLayout = (SwipeDismissFrameLayout) findViewById(
            R.id.map_container);
        mapFrameLayout.addCallback(new SwipeDismissFrameLayout.Callback() {
            @Override
            public void onDismissed(SwipeDismissFrameLayout layout) {
                onBackPressed();
            }
        });

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = (SupportMapFragment) getSupportFragmentManager()
            .findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    }

    // ...
}

      

Kotlin


class MainActivity : AppCompatActivity(), OnMapReadyCallback,
                     AmbientModeSupport.AmbientCallbackProvider {


    public override fun onCreate(savedState: Bundle?) {
        super.onCreate(savedState)

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main)

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        val controller = AmbientModeSupport.attach(this)
        Log.d(MainActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)

        // Retrieve the containers for the root of the layout and the map. Margins will need to be
        // set on them to account for the system window insets.
        val mapFrameLayout = findViewById<SwipeDismissFrameLayout>(R.id.map_container)
        mapFrameLayout.addCallback(object : SwipeDismissFrameLayout.Callback() {
            override fun onDismissed(layout: SwipeDismissFrameLayout) {
                onBackPressed()
            }
        })

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    // ...
}

      

मैप जोड़ना

onMapReady(GoogleMap) बनी कॉलबैक सुविधा का इस्तेमाल हमेशा की तरह करें, GoogleMap ऑब्जेक्ट का इस्तेमाल करने के लिए. कॉलबैक तब ट्रिगर होता है, जब मैप इस्तेमाल के लिए तैयार हो जाता है. कॉलबैक के तरीके में, आप मैप में मार्कर या पॉलीलाइन जोड़ सकते हैं, सुनने वालों को जोड़ सकते हैं या कैमरे की जगह बदल सकते हैं. नीचे दिए गए उदाहरण में सिडनी ऑपरा हाउस के पास एक मार्कर जोड़ा गया है:

Java


private static final LatLng SYDNEY = new LatLng(-33.85704, 151.21522);

@Override
public void onMapReady(@NonNull GoogleMap googleMap) {
    // Add a marker with a title that is shown in its info window.
    googleMap.addMarker(new MarkerOptions().position(SYDNEY)
        .title("Sydney Opera House"));

    // Move the camera to show the marker.
    googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(SYDNEY, 10));
}

      

Kotlin


private val sydney = LatLng(-33.85704, 151.21522)

override fun onMapReady(googleMap: GoogleMap) {
    // Add a marker with a title that is shown in its info window.
    googleMap.addMarker(
        MarkerOptions().position(sydney)
            .title("Sydney Opera House")
    )

    // Move the camera to show the marker.
    googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(sydney, 10f))
}

      

आस-पास की आवाज़ सुनाने वाला मोड चालू किया जा रहा है

Android के लिए Maps SDK टूल, पहने जाने वाले ऐप्लिकेशन के लिए ऐंबियंट मोड पर काम करता है. ऐंबियंट मोड के साथ काम करने वाले ऐप्लिकेशन को कभी-कभी हमेशा चालू वाले ऐप्लिकेशन कहा जाता है. जब उपयोगकर्ता ऐप्लिकेशन का इस्तेमाल नहीं कर रहा होता है, तब ऐंबियंट मोड चालू हो जाता है. साथ ही, ऐप्लिकेशन पहने जाने वाले डिवाइस पर दिखता रहता है.

Android के लिए Maps SDK टूल, मैप का आसानी से इस्तेमाल करने के लिए, आसान और कम कलर रेंडरिंग देता है. साथ ही, जब डिवाइस इंटरैक्टिव से ऐंबियंट मोड पर स्विच होता है, तब मैप स्टाइल अपने-आप अडजस्ट हो जाता है. सभी मार्कर, ऑब्जेक्ट, और यूज़र इंटरफ़ेस (यूआई) कंट्रोल, ऐंबियंट मोड में नहीं दिखते. इससे, आपके ऐप्लिकेशन की बैटरी की खपत कम हो जाती है और यह पक्का हो जाता है कि आपके चेहरे से जुड़े दूसरे ऐप्लिकेशन, जैसे कि स्मार्ट वॉच की होम स्क्रीन को एक जैसा रंग-रूप दिया जाए.

यह पक्का करने के लिए कि आपका ऐप्लिकेशन मैप के हमेशा चालू स्क्रीन मोड का इस्तेमाल करे, नीचे दिए गए कदम उठाएं:

  1. Android 6.0 (एपीआई 23) या इसके बाद के वर्शन को शामिल करने के लिए, अपने Android SDK टूल को अपडेट करें. इसकी मदद से, ऐसे एपीआई मिलते हैं जिनसे गतिविधियों को ऐंबियंट मोड में जाने की अनुमति मिलती है. अपने SDK टूल को अपडेट करने के बारे में जानने के लिए, SDK टूल पैकेज जोड़ने के बारे में Android का दस्तावेज़ देखें.
  2. पक्का करें कि आपका प्रोजेक्ट Android 6.0 या उसके बाद वाले वर्शन को टारगेट करता है. इसके लिए, ऐप्लिकेशन मेनिफ़ेस्ट में targetSdkVersion को 23 या उसके बाद के वर्शन पर सेट करें.
  3. पहने जाने वाले डिपेंडेंसी को अपने ऐप्लिकेशन की build.gradle फ़ाइल में जोड़ें. इस पेज पर मौजूद सैंपल देखें.
  4. पहने जाने वाले डिवाइस की शेयर की गई लाइब्रेरी में मौजूद एंट्री को पहने जाने वाले ऐप्लिकेशन मेनिफ़ेस्ट में जोड़ें, जैसा कि अपने ऐप्लिकेशन को साफ़ तौर पर दिखाने के लिए, Android ट्रेनिंग क्लास में बताया गया है.
  5. हैंडहेल्ड और पहने जाने वाले ऐप्लिकेशन मेनिफ़ेस्ट में WAKE_LOCK की अनुमति जोड़ें, जैसा कि अपना ऐप्लिकेशन दिखाते रहने के लिए Android ट्रेनिंग क्लास में बताया गया है.
  6. अपनी गतिविधि के onCreate() तरीके में, AmbientModeSupport.attach() तरीके को कॉल करें. इससे ऑपरेटिंग सिस्टम को पता चलता है कि ऐप्लिकेशन हमेशा चालू रहता है. इससे डिवाइस जब बंद होता है, तो स्मार्ट वॉच की होम स्क्रीन पर वापस जाने के बजाय हमेशा चालू स्क्रीन मोड पर जाना चाहिए.
  7. अपनी गतिविधि में AmbientModeSupport.AmbientCallbackProvider इंटरफ़ेस लागू करें, ताकि वह हमेशा चालू स्क्रीन मोड की स्थिति में बदलाव पा सके.
  8. ऐंबियंट मोड के साथ काम करने के लिए, अपना मैप सेट करें. आप गतिविधि की एक्सएमएल लेआउट फ़ाइल में, map:ambientEnabled="true" एट्रिब्यूट सेट करके ऐसा कर सकते हैं. इसके अलावा, आप GoogleMapOptions.ambientEnabled(true) को सेट करके प्रोग्राम की मदद से भी ऐसा कर सकते हैं. यह सेटिंग एपीआई को बताती है कि ऐंबियंट मोड में इस्तेमाल करने के लिए, इसे ज़रूरी मैप टाइल पहले से लोड करने की ज़रूरत है.
  9. जब गतिविधि ऐंबियंट मोड पर स्विच होती है, तो सिस्टम आपके दिए गए AmbientCallback में onEnterAmbient() वाले तरीके को कॉल करता है. onEnterAmbient() को ओवरराइड करें और SupportMapFragment.onEnterAmbient(ambientDetails) याMapView.onEnterAmbient(ambientDetails) पर कॉल करें. एपीआई, मैप के नॉन-इंटरैक्टिव और कम कलर रेंडरिंग के लिए स्वैप करता है.
  10. इसी तरह, onExitAmbient() पर कॉल करें SupportMapFragment.onExitAmbient() या MapView.onExitAmbient(). एपीआई, मैप की सामान्य रेंडरिंग के साथ बदल जाता है.

नीचे दिया गया कोड सैंपल, गतिविधि में ऐंबियंट मोड को चालू करता है:

Java


public class AmbientActivity extends AppCompatActivity implements
    AmbientModeSupport.AmbientCallbackProvider {

    private SupportMapFragment mapFragment;

    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main);

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
        Log.d(AmbientActivity.class.getSimpleName(), "Is ambient enabled: " + controller.isAmbient());

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = (SupportMapFragment) getSupportFragmentManager()
            .findFragmentById(R.id.map);
    }

    @Override
    public AmbientCallback getAmbientCallback() {
        return new AmbientCallback() {
            /**
             * Starts ambient mode on the map.
             * The API swaps to a non-interactive and low-color rendering of the map when the user is no
             * longer actively using the app.
             */
            @Override
            public void onEnterAmbient(Bundle ambientDetails) {
                super.onEnterAmbient(ambientDetails);
                mapFragment.onEnterAmbient(ambientDetails);
            }

            /**
             * Exits ambient mode on the map.
             * The API swaps to the normal rendering of the map when the user starts actively using the app.
             */
            @Override
            public void onExitAmbient() {
                super.onExitAmbient();
                mapFragment.onExitAmbient();
            }
        };
    }
}

      

Kotlin


class AmbientActivity : AppCompatActivity(), AmbientModeSupport.AmbientCallbackProvider {

    private lateinit var mapFragment: SupportMapFragment

    public override fun onCreate(savedState: Bundle?) {
        super.onCreate(savedState)

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main)

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        val controller = AmbientModeSupport.attach(this)
        Log.d(AmbientActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
    }

    override fun getAmbientCallback(): AmbientModeSupport.AmbientCallback {
        return object : AmbientModeSupport.AmbientCallback() {
            /**
             * Starts ambient mode on the map.
             * The API swaps to a non-interactive and low-color rendering of the map when the user is no
             * longer actively using the app.
             */
            override fun onEnterAmbient(ambientDetails: Bundle) {
                super.onEnterAmbient(ambientDetails)
                mapFragment.onEnterAmbient(ambientDetails)
            }

            /**
             * Exits ambient mode on the map.
             * The API swaps to the normal rendering of the map when the user starts actively using the app.
             */
            override fun onExitAmbient() {
                super.onExitAmbient()
                mapFragment.onExitAmbient()
            }
        }
    }
}

      

जब ऐप्लिकेशन ऐंबियंट मोड में हो, तब आप स्क्रीन को अपडेट कर सकते हैं. कॉन्टेंट अपडेट करने और ऐंबियंट मोड के बारे में ज़्यादा जानकारी पाने के लिए, अपने ऐप्लिकेशन को दिखाते रहेंपर Android ट्रेनिंग क्लास देखें.

Wear OS पर 'स्ट्रीट व्यू' का इस्तेमाल करना

स्ट्रीट व्यू, पहने जाने वाले डिवाइस पर पूरी तरह से काम करता है.

'स्ट्रीट व्यू' पैनोरामा देखते समय उपयोगकर्ताओं को ऐप्लिकेशन से बाहर निकलने की अनुमति देने के लिए, StreetViewPanorama.OnStreetViewPanorama longClickListener इंटरफ़ेस का इस्तेमाल करके, लंबे समय तक क्लिक किए जाने वाले हाथ के जेस्चर के बारे में सुनें. जब कोई उपयोगकर्ता Street View इमेज पर कहीं भी क्लिक करता है, तो आपको एक onStreetViewPanoramaLongClick(StreetViewPanoramaOrientation) इवेंट मिलता है. 'बाहर निकलें' बटन दिखाने के लिए, DismissOverlayView.show() को कॉल करें.

नमूना कोड

GitHub पर एक सैंपल ऐप्लिकेशन उपलब्ध है. इसका इस्तेमाल ऐप्लिकेशन के शुरुआती पॉइंट के तौर पर किया जा सकता है. सैंपल में आपको Wear OS पर बुनियादी Google मैप सेट अप करने का तरीका बताया गया है.

Wear OS पर Maps API में काम करने वाली सुविधाएं

इस सेक्शन में, हैंडहेल्ड डिवाइसों (फ़ोन और टैबलेट) की तुलना में, पहने जाने वाले डिवाइस पर मैप की सुविधा के बीच के फ़र्क़ को दिखाया गया है. एपीआई की जिन सुविधाओं के बारे में नीचे नहीं बताया गया है वे सभी एपीआई के दस्तावेज़ के मुताबिक काम करनी चाहिए.

फ़ंक्शन
पूरी तरह से इंटरैक्टिव मोड और लाइट मोड

Android के लिए Maps SDK टूल का इस्तेमाल, पूरी तरह इंटरैक्टिव मोड या लाइट मोड में किया जा सकता है. अगर आपको पहने जाने वाले डिवाइस पर परफ़ॉर्मेंस को ऑप्टिमाइज़ करना है और आपके ऐप्लिकेशन को हाथ के जेस्चर (स्पर्श) या मैप को पैन और ज़ूम करने जैसे इंटरैक्शन की ज़रूरत नहीं है, तो लाइट मोड पर विचार करें.

लाइट मोड में, जब उपयोगकर्ता मैप पर टैप करता है, तो Google Maps मोबाइल ऐप्लिकेशन शुरू करने का मकसद बंद होता है. इसे पहने जाने वाले किसी डिवाइस पर चालू नहीं किया जा सकता.

लाइट मोड और पूरी तरह से इंटरैक्टिव मोड के बीच अंतर की पूरी सूची देखने के लिए, लाइट मोड के दस्तावेज़ देखें.

मैप टूलबार मैप टूलबार बंद है और पहने जाने वाले डिवाइस पर चालू नहीं किया जा सकता.
यूज़र इंटरफ़ेस (यूआई) कंट्रोल यूज़र इंटरफ़ेस (यूआई) कंट्रोल पहने जाने वाले डिवाइस पर डिफ़ॉल्ट रूप से बंद रहते हैं. इसमें ज़ूम, कंपास, और मेरी जगह की जानकारी के कंट्रोल शामिल हैं. आप हमेशा की तरह UiSettings क्लास का इस्तेमाल करके, उन्हें चालू कर सकते हैं.
हाथ के जेस्चर एक टच वाली हाथ के जेस्चर उम्मीद के मुताबिक काम करते हैं. उदाहरण, मैप को पैन करने के लिए उसे खींचकर छोड़ें और ज़ूम इन करने के लिए दो बार टैप करें. ज़ूम आउट करने के लिए दो उंगलियों से टैप करें. मल्टी-टच जेस्चर (हाव-भाव) का इस्तेमाल, उपयोगकर्ता के डिवाइस के हिसाब से किया जा सकता है. मल्टी-टच जेस्चर (हाव-भाव) के उदाहरणों में, मैप को झुकाने के लिए, दो उंगलियों से पुश करें, ज़ूम करने के लिए पिंच करें, और दो उंगलियों से घुमाएं.
इनडोर मैप और इमारतें इनडोर मैप डिफ़ॉल्ट रूप से पहने जाने वाले डिवाइस पर बंद होते हैं. इन्हें चालू करने के लिए, GoogleMap.setIndoorEnabled(true) को कॉल करें. अगर इनडोर मैप चालू हैं, तो मैप पर डिफ़ॉल्ट फ़्लोर लेवल दिखेगा. लेवल पिकर का यूज़र इंटरफ़ेस (यूआई) एलिमेंट, पहने जाने वाले डिवाइस पर काम नहीं करता.
टाइल ओवरले टाइल ओवरले, पहने जाने वाले डिवाइस पर काम नहीं करते.

Wear OS पर Maps API डेवलप करने के सबसे सही तरीके

अपने ऐप्लिकेशन में सबसे अच्छा उपयोगकर्ता अनुभव देने का तरीका:

  • मैप को स्क्रीन के एक बड़े हिस्से को कवर करना चाहिए. ऐसा करने के लिए, पहने जाने वाले डिवाइस के छोटे साइज़ वाले फ़ैक्टर पर, मैप की उपयोगिता को ऑप्टिमाइज़ करना ज़रूरी है.
  • अपने ऐप्लिकेशन के उपयोगकर्ता अनुभव को डिज़ाइन करते समय, इस बात का ध्यान रखें कि पहने जाने वाले डिवाइस में बैटरी कम है. स्क्रीन को सक्रिय रखने और मैप को दिखाई देने से बैटरी परफ़ॉर्मेंस पर असर पड़ेगा.