Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

Wear OS पर Maps API

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

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

Wear OS पर ऐप्लिकेशन बनाना शुरू करना

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

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

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

Wear OS पर मैप से जुड़ा अपना पहला ऐप्लिकेशन बनाना

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

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

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

dependencies {
    // ...
    // Modern Android projects use version catalogs to manage dependencies.  To include the necessary dependencies,
    // first add the following to your libs.versions.toml file:
    //
    // [versions]
    // playServicesMaps = "20.0.0"
    // wear = "1.4.0"
    // wearable = "2.9.0"
    //
    // [libraries]
    // play-services-maps = { group = "com.google.android.gms", name = "play-services-maps", version.ref = "playServicesMaps" }
    // wear = { group = "androidx.wear", name = "wear", version.ref = "wear" }
    // wearable-compile = { group = "com.google.android.wearable", name = "wearable", version.ref = "wearable" }
    // wearable-support = { group = "com.google.android.support", name = "wearable", version.ref = "wearable" }

    compileOnly(libs.wearable.compile)
    implementation(libs.wearable.support)
    implementation(libs.play.services.maps)

    // This dependency is necessary for ambient mode
    implementation(libs.wear)

    // Android Test Dependencies
    androidTestImplementation(libs.ext.junit)
    androidTestImplementation(libs.espresso.core)
    androidTestImplementation(libs.uiautomator)
    androidTestImplementation(libs.truth)
    androidTestImplementation(libs.junit)
    
    // If your project does not use a version catalog, you can use the following dependencies instead:
    //
    //    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:20.0.0")
    //    implementation("androidx.wear:wear:1.4.0")
    //    androidTestImplementation("androidx.test.ext:junit:1.3.0")
    //    androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
    //    androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0")
    //    androidTestImplementation("com.google.truth:truth:1.4.5")
    //    androidTestImplementation("junit:junit:4.13.2")
}

डिपेंडेंसी के बारे में ज़्यादा जानकारी के लिए, अपने मौजूदा प्रोजेक्ट में 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 ऑब्जेक्ट पाने के बाद, कॉलबैक जोड़ें और कॉलबैक के व्यवहार को, नीचे दिखाए गए तरीके से, बंद करने की ज़रूरी कार्रवाई करने के लिए सेट करें:

Kotlin

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


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

        // 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.
        try {
            val controller = AmbientModeSupport.attach(this)
            Log.d(MainActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)
        } catch (e: Exception) {
            Log.w(MainActivity::class.java.simpleName, "Ambient mode unavailable on this device: ${e.message}")
        }

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

    // ...
}

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.
        try {
            AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
            Log.d(MainActivity.class.getSimpleName(), "Is ambient enabled: " + controller.isAmbient());
        } catch (Exception e) {
            Log.w(MainActivity.class.getSimpleName(), "Ambient mode unavailable on this device: " + e.getMessage());
        }

        // 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) कॉलबैक तरीके का इस्तेमाल करें, GoogleMap मैप के इस्तेमाल के लिए तैयार होने पर, कॉलबैक ट्रिगर होता है. कॉलबैक का तरीका में, आप मैप में मार्कर या पॉलीलाइन जोड़ सकते हैं, लिसनर जोड़ सकते हैं या कैमरा घुमा सकते हैं. नीचे दिए गए उदाहरण में, सिडनी ऑपरा हाउस के पास एक मार्कर जोड़ा गया है:

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

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

ऐंबियंट मोड चालू करना

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

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

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

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

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

Kotlin

class AmbientActivity : AppCompatActivity(), AmbientModeSupport.AmbientCallbackProvider {

    private lateinit var mapFragment: SupportMapFragment

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

        // 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.
        try {
            val controller = AmbientModeSupport.attach(this)
            Log.d(AmbientActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)
        } catch (e: Exception) {
            Log.w(AmbientActivity::class.java.simpleName, "Ambient mode unavailable on this device: ${e.message}")
        }

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

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.
        try {
            AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
            Log.d(AmbientActivity.class.getSimpleName(), "Is ambient enabled: " + controller.isAmbient());
        } catch (Exception e) {
            Log.w(AmbientActivity.class.getSimpleName(), "Ambient mode unavailable on this device: " + e.getMessage());
        }

        // 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 Map सेट अप करने का तरीका बताया गया है.