Wear OS पर Maps API

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

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

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

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

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

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

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

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

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

पक्का करें कि आपके ऐप्लिकेशन के 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.2.0'

    // This dependency is necessary for ambient mode
    implementation 'androidx.wear:wear:1.3.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 ऑब्जेक्ट मिलता है, तो उसे एक कॉलबैक जोड़ें और कॉलबैक का व्यवहार सेट करें, ताकि खारिज करने की ज़रूरी कार्रवाई की जा सके, जैसा कि यहां दिखाया गया है:

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

    // ...
}

      

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

    // ...
}

      

मैप जोड़ना

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

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

      

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

      

ऐंबियंट मोड चालू किया जा रहा है

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

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

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

1. अपने Android SDK टूल को अपडेट करें, ताकि उसमें Android 6.0 (एपीआई 23) या उसके बाद वाला प्लैटफ़ॉर्म शामिल किया जा सके. इससे, ऐसी एपीआई उपलब्ध कराई जाती हैं जो गतिविधियों को ऐंबियंट मोड में जाने देती हैं. SDK टूल को अपडेट करने के तरीके के बारे में जानने के लिए, SDK टूल के पैकेज जोड़ने से जुड़ा Android दस्तावेज़ देखें.
2. ऐप्लिकेशन मेनिफ़ेस्ट में targetSdkVersion को 23 या उसके बाद के वर्शन पर सेट करके, पक्का करें कि आपका प्रोजेक्ट, Android 6.0 या उसके बाद के वर्शन को टारगेट करता हो.
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() को कॉल करें. एपीआई, मैप की सामान्य रेंडरिंग में बदल जाता है.

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

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

      

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

      

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

Wear OS पर Street View का इस्तेमाल करना

Street View, पहने जाने वाले डिवाइसों पर पूरी तरह से काम करता है.

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

नमूना कोड

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

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

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

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

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

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