Wear OS पर Maps API

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

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

Wear OS पर शुरू करना

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

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

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

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

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

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

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

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:19.0.0")

    // This dependency is necessary for ambient mode
    implementation("androidx.wear:wear:1.3.0")
}

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

स्वाइप करके हटाने की सुविधा लागू करना और बैकग्राउंड का शुरुआती रंग सेट करना

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

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

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

  <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. पक्का करें कि आपका प्रोजेक्ट Android 6.0 या उसके बाद के वर्शन को टारगेट करता हो. इसके लिए, ऐप्लिकेशन मेनिफ़ेस्ट में targetSdkVersion को 23 या उसके बाद के वर्शन पर सेट करें.
3. अपने ऐप्लिकेशन की build.gradle.kts फ़ाइल में, पहने जाने वाले डिवाइसों के लिए ज़रूरी लाइब्रेरी जोड़ें. इस पेज पर सैंपल देखें.
4. अपने ऐप्लिकेशन को दिखते रहने के बारे में Android ट्रेनिंग क्लास में बताए गए तरीके के मुताबिक, पहने जा सकने वाले डिवाइस के लिए बनाए गए ऐप्लिकेशन के मेनिफ़ेस्ट में, पहने जा सकने वाले डिवाइस के लिए शेयर की गई लाइब्रेरी की एंट्री जोड़ें.
5. अपने ऐप्लिकेशन को दिखते रहने के बारे में Android ट्रेनिंग क्लास में बताए गए तरीके के मुताबिक, WAKE_LOCK अनुमति को हैंडहेल्ड और पहने जाने वाले डिवाइसों के ऐप्लिकेशन मेनिफ़ेस्ट में जोड़ें.
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 Maps का बुनियादी वर्शन सेट अप करने का तरीका बताया गया है.

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

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

Wear OS पर Maps API का इस्तेमाल करके ऐप्लिकेशन डेवलप करने के सबसे सही तरीके

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

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