Wear OS पर Maps API

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

      

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

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 का इस्तेमाल करके ऐप्लिकेशन बनाने के सबसे सही तरीके

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

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