Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

पहने जाने वाले डिवाइसों पर पुष्टि करने की सुविधा: क्रेडेंशियल मैनेजर

Wear OS ऐप्लिकेशन, साथ में काम करने वाले ऐप्लिकेशन के बिना भी काम कर सकते हैं. इसका मतलब है कि इंटरनेट से डेटा ऐक्सेस करते समय, Wear OS ऐप्लिकेशन को पुष्टि करने की प्रोसेस खुद मैनेज करनी होती है. हालांकि, घड़ी की छोटी स्क्रीन और कम इनपुट क्षमताओं की वजह से, Wear OS ऐप्लिकेशन के लिए पुष्टि करने के विकल्प सीमित हो जाते हैं.

इस गाइड में, Wear OS ऐप्लिकेशन के लिए पुष्टि करने के सुझाए गए तरीके, Credential Manager के बारे में निर्देश दिए गए हैं.

साइन-इन करने का बेहतर अनुभव डिज़ाइन करने के बारे में ज़्यादा जानने के लिए, साइन-इन यूएक्स गाइड देखें.

शुरुआत में ध्यान रखने वाली बातें

इसे लागू करने से पहले, इन बातों का ध्यान रखें.

मेहमान मोड

सभी सुविधाओं के लिए, पुष्टि करने की ज़रूरत न हो. इसके बजाय, उपयोगकर्ताओं को साइन इन करने की ज़रूरत के बिना, ज़्यादा से ज़्यादा सुविधाएं उपलब्ध कराएं.

ऐसा हो सकता है कि उपयोगकर्ता, मोबाइल ऐप्लिकेशन का इस्तेमाल किए बिना ही, आपके Wear OS ऐप्लिकेशन को ढूंढकर इंस्टॉल कर लें. इसलिए, हो सकता है कि उनके पास कोई खाता न हो और उन्हें यह भी न पता हो कि आपका ऐप्लिकेशन कौनसी सुविधाएं देता है. पक्का करें कि मेहमान मोड की सुविधा से, आपके ऐप्लिकेशन की सुविधाओं के बारे में सटीक जानकारी मिलती हो.

कुछ डिवाइस ज़्यादा समय तक अनलॉक रह सकते हैं

Wear OS 5 या इसके बाद के वर्शन पर काम करने वाले डिवाइसों पर, सिस्टम यह पता लगाता है कि उपयोगकर्ता ने डिवाइस को अपनी कलाई पर पहना है या नहीं. अगर उपयोगकर्ता, कलाई पर डिवाइस पहनने की सुविधा बंद कर देता है और फिर डिवाइस को अपनी कलाई से हटा लेता है, तो सिस्टम डिवाइस को ज़्यादा समय तक अनलॉक रखता है.

अगर आपके ऐप्लिकेशन को सुरक्षा के ज़्यादा लेवल की ज़रूरत है, जैसे कि संवेदनशील या निजी डेटा दिखाने के दौरान, तो सबसे पहले यह देखें कि कलाई पर डिवाइस पहनने की सुविधा चालू है या नहीं:

fun isWristDetectionAutoLockingEnabled(context: Context): Boolean {
    // Use the keyguard manager to check for the presence of a lock mechanism
    val keyguardManager = context.getSystemService<KeyguardManager>()
    val isSecured = keyguardManager?.isDeviceSecure == true

    // Use OEM-specific system settings to verify that on-body autolock is enabled.
    val isWristDetectionOn = android.provider.Settings.Global.getInt(
        context.contentResolver, PIXEL_WRIST_AUTOLOCK_SETTING_STATE,
        0
    ) == 1

    return isSecured && isWristDetectionOn
}WristDetectionUtility.kt

अगर इस तरीके की रिटर्न वैल्यू false है, तो उपयोगकर्ता को उसके हिसाब से कॉन्टेंट दिखाने से पहले, अपने ऐप्लिकेशन में किसी खाते में साइन इन करने के लिए कहें.

Credential Manager

Wear OS पर पुष्टि करने के लिए, Credential Manager को एपीआई के तौर पर इस्तेमाल करने का सुझाव दिया जाता है. यह उपयोगकर्ताओं को, Wear OS ऐप्लिकेशन में स्टैंडअलोन सेटिंग में साइन इन करने के लिए ज़्यादा सुरक्षित एनवायरमेंट उपलब्ध कराता है. इसके लिए, उन्हें जोड़े गए फ़ोन की ज़रूरत नहीं होती और न ही उन्हें अपना पासवर्ड याद रखना पड़ता है.

इस दस्तावेज़ में, डेवलपर को Credential Manager का समाधान लागू करने के लिए ज़रूरी जानकारी दी गई है. इसमें, पुष्टि करने के स्टैंडर्ड मैकेनिज़्म शामिल हैं. ये मैकेनिज़्म हैं:

पासकी
पासवर्ड
फ़ेडरेटेड आइडेंटिटी (जैसे, 'Google से साइन इन करें' सुविधा)

इस गाइड में, Credential Manager के बैकअप के तौर पर, Wear OS पर पुष्टि करने के अन्य तरीकों (डेटा लेयर टोकन शेयरिंग और OAuth) को माइग्रेट करने के तरीके के बारे में भी निर्देश दिए गए हैं. साथ ही, अब बंद हो चुके, Google से साइन इन करने के स्टैंडअलोन बटन से, Credential Manager के एम्बेड किए गए वर्शन पर ट्रांज़िशन को मैनेज करने के खास निर्देश भी दिए गए हैं.

Wear OS की सीमाएं और अंतर

डेवलपर को Wear OS पर इन सीमाओं और अंतरों के बारे में पता होना चाहिए:

Credential Manager, Wear OS 3 और इसके बाद के वर्शन पर उपलब्ध है.
Wear OS पर क्रेडेंशियल नहीं बनाए जा सकते
क्रेडेंशियल को रीस्टोर करने और हाइब्रिड साइन-इन फ़्लो, दोनों के लिए कोई सहायता उपलब्ध नहीं है.
सिर्फ़ Wear OS इंटिग्रेशन वाले क्रेडेंशियल प्रोवाइडर को मोबाइल से फिर से इस्तेमाल किया जा सकता है.

Wear OS पर पासकी

डेवलपर को Wear OS Credential Manager के लिए, पासकी लागू करने का सुझाव दिया जाता है. पासकी, एंड-यूज़र ऑथेंटिकेशन के लिए इंडस्ट्री का नया स्टैंडर्ड है. इससे उपयोगकर्ताओं को कई अहम फ़ायदे मिलते हैं.

पासकी इस्तेमाल करना आसान है

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

पासकी ज़्यादा सुरक्षित होती हैं

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

पासकी लागू करना

इसमें, सभी तरह के लागू करने के लिए सेटअप और निर्देश शामिल हैं.

सेटअप

अपने ऐप्लिकेशन मॉड्यूल की build.gradle फ़ाइल में, टारगेट एपीआई लेवल को 35 पर सेट करें:
```
android {
    defaultConfig {
        targetSdk(35)
    }
}
```
`androidx.credentials` रिलीज़ रेफ़रंस से, सबसे नए और स्थिर वर्शन का इस्तेमाल करके, अपने ऐप्लिकेशन या मॉड्यूल की build.gradle फ़ाइल में ये लाइनें जोड़ें.
```
androidx.credentials:credentials:1.6.0
androidx.credentials:credentials-play-services-auth:1.6.0
```

पुष्टि करने के पहले से मौजूद तरीके

Credential Manager एक यूनिफ़ाइड एपीआई है. इसलिए, Wear OS के लिए इसे लागू करने के चरण, किसी भी अन्य डिवाइस टाइप के लिए एक जैसे होते हैं.

पासकी और पासवर्ड की सुविधा लागू करने के लिए, मोबाइल के लिए दिए गए निर्देशों का इस्तेमाल करें.

Credential Manager में 'Google से साइन इन करें' सुविधा जोड़ने के चरण मोबाइल डेवलपमेंट के हिसाब से दिए गए हैं . हालांकि, Wear OS पर भी ये चरण एक जैसे होते हैं.

ध्यान दें कि Wear OS पर क्रेडेंशियल नहीं बनाए जा सकते. इसलिए, आपको मोबाइल के निर्देशों में बताए गए क्रेडेंशियल बनाने के तरीके लागू करने की ज़रूरत नहीं है.

पुष्टि करने के बैकअप तरीके

Wear OS ऐप्लिकेशन के लिए, पुष्टि करने के दो अन्य तरीके भी इस्तेमाल किए जा सकते हैं: OAuth 2.0 (कोई भी वैरिएंट) और मोबाइल ऑथ टोकन डेटा लेयर शेयरिंग. हालांकि, इन तरीकों के लिए Credential Manager API में इंटिग्रेशन पॉइंट नहीं हैं. फिर भी, इन्हें Credential Manager के यूएक्स फ़्लो में फ़ॉलबैक के तौर पर शामिल किया जा सकता है. ऐसा तब किया जा सकता है, जब उपयोगकर्ता Credential Manager की स्क्रीन को बंद कर दें.

Credential Manager की स्क्रीन को बंद करने की उपयोगकर्ता की कार्रवाई को मैनेज करने के लिए, NoCredentialException लॉजिक के तहत GetCredential को कैप्चर करें और अपने कस्टम ऑथ यूज़र इंटरफ़ेस (यूआई) पर जाएं.

try {
    val getCredentialResponse: GetCredentialResponse =
        credentialManager.getCredential(activity, createGetCredentialRequest())
    return authenticate(getCredentialResponse.credential)
} catch (_: GetCredentialCancellationException) {
    navigateToSecondaryAuthentication()
}CredentialManager.kt

इसके बाद, आपका कस्टम ऑथ यूज़र इंटरफ़ेस (यूआई), साइन-इन यूएक्स गाइड में बताए गए, पुष्टि करने के अन्य तरीकों में से कोई भी तरीका उपलब्ध करा सकता है.

डेटा लेयर टोकन शेयरिंग

फ़ोन का साथ में काम करने वाला ऐप्लिकेशन, Wearable Data Layer API का इस्तेमाल करके, Wear OS ऐप्लिकेशन को पुष्टि करने का डेटा सुरक्षित तरीके से ट्रांसफ़र कर सकता है. क्रेडेंशियल को मैसेज या डेटा आइटम के तौर पर ट्रांसफ़र करें.

पुष्टि करने के इस तरीके के लिए, आम तौर पर उपयोगकर्ता को कोई कार्रवाई करने की ज़रूरत नहीं होती. हालांकि, उपयोगकर्ता को यह बताए बिना पुष्टि न करें कि उसे साइन इन किया जा रहा है. उपयोगकर्ता को ऐसी स्क्रीन का इस्तेमाल करके बताया जा सकता है जिसे बंद किया जा सकता है. इस स्क्रीन पर दिखाया जाता है कि उसका खाता, मोबाइल से ट्रांसफ़र किया जा रहा है.

अहम जानकारी: आपके Wear OS ऐप्लिकेशन में, पुष्टि करने का कम से कम एक और तरीका उपलब्ध होना चाहिए. ऐसा इसलिए, क्योंकि यह विकल्प सिर्फ़ Android से जोड़ी गई घड़ियों पर काम करता है. इसके लिए, साथ में काम करने वाला मोबाइल ऐप्लिकेशन इंस्टॉल होना चाहिए. ऐसे उपयोगकर्ताओं के लिए पुष्टि करने का कोई दूसरा तरीका उपलब्ध कराएं जिनके पास साथ में काम करने वाला मोबाइल ऐप्लिकेशन नहीं है या जिनका Wear OS डिवाइस, iOS डिवाइस से जोड़ा गया है.

मोबाइल ऐप्लिकेशन से डेटा लेयर का इस्तेमाल करके, पास टोकन भेजें. इसका तरीका, यहां दिए गए उदाहरण में दिखाया गया है:

val token = "..." // Auth token to transmit to the Wear OS device.
val putDataReq: PutDataRequest = PutDataMapRequest.create("/auth").run {
    dataMap.putString("token", token)
    asPutDataRequest()
}
val putDataTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(putDataReq)DataLayerActivity.kt

Wear OS ऐप्लिकेशन पर, डेटा में बदलाव के इवेंट सुनें. इसका तरीका, यहां दिए गए उदाहरण में दिखाया गया है:

class AuthDataListenerService : WearableListenerService() {
    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents.forEach { event ->
            if (event.type == DataEvent.TYPE_CHANGED) {
                val dataItemPath = event.dataItem.uri.path ?: ""

                if (dataItemPath.startsWith("/auth")) {
                    val token = DataMapItem.fromDataItem(event.dataItem)
                        .dataMap
                        .getString("token")
                    // Display an interstitial screen to notify the user that they're being signed
                    // in. Then, store the token and use it in network requests.
                    handleSignInSequence(token)
                }
            }
        }
    }

    /** placeholder sign in handler. */
    fun handleSignInSequence(token: String?) {}
}DataLayerService.kt

Wearable Data Layer का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, Wear OS पर डेटा भेजना और सिंक करना लेख पढ़ें.

OAuth 2.0 का इस्तेमाल करना

Wear OS, OAuth 2.0 पर आधारित दो फ़्लो के साथ काम करता है. इनके बारे में, यहां दिए गए सेक्शन में बताया गया है:

ऑथराइज़ेशन कोड ग्रांट, जिसमें कोड एक्सचेंज के लिए प्रूफ़ की (पीकेसीई) का इस्तेमाल किया जाता है. इसके बारे में, आरएफ़सी 7636 में बताया गया है आरएफ़सी 7636
डिवाइस ऑथराइज़ेशन ग्रांट (डीएजी). इसके बारे में, आरएफ़सी 8628 में बताया गया है

ध्यान दें: Wear OS डिवाइस के ऐंबियंट मोड में जाने पर, आपके ऐप्लिकेशन के बंद होने की संभावना को कम करने के लिए, हमेशा चालू रहने की सुविधा चालू करें. इसके लिए, अपने ऐप्लिकेशन के लिए AmbientLifecycleObserver लागू करें. ऐंबियंट मोड में सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, हमेशा चालू रहने वाले ऐप्लिकेशन और सिस्टम ऐंबियंट मोड लेख पढ़ें.

कोड एक्सचेंज के लिए प्रूफ़ की (पीकेसीई)

पीकेसीई का असरदार तरीके से इस्तेमाल करने के लिए, RemoteAuthClient का इस्तेमाल करें. इसके बाद, OAuth प्रोवाइडर को अपने Wear OS ऐप्लिकेशन से ऑथराइज़ेशन का अनुरोध भेजने के लिए, OAuthRequest ऑब्जेक्ट बनाएं. इस ऑब्जेक्ट में, टोकन पाने के लिए आपके OAuth एंडपॉइंट का यूआरएल और CodeChallenge ऑब्जेक्ट शामिल होता है.

यहां दिए गए कोड में, ऑथराइज़ेशन का अनुरोध बनाने का एक उदाहरण दिखाया गया है:

val oauthRequest = OAuthRequest.Builder(context)
    .setAuthProviderUrl(uri)
    .setCodeChallenge(codeChallenge)
    .setClientId(CLIENT_ID)
    .build()OAuthPKCE.kt

ऑथराइज़ेशन का अनुरोध बनाने के बाद, sendAuthorizationRequest() तरीके का इस्तेमाल करके, इसे साथ में काम करने वाले ऐप्लिकेशन को भेजें:

RemoteAuthClient.create(context).sendAuthorizationRequest(
    request = oauthRequest,
    executor = { command -> command?.run() },
    clientCallback = object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it, and use it in requests.
            continuation.resume(parseCodeFromResponse(response))
        }
        override fun onAuthorizationError(request: OAuthRequest, errorCode: Int) {
            // Handle Errors
            continuation.resume(Result.failure(IOException("Authorization failed")))
        }
    }
)OAuthPKCE.kt

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

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

जवाब, क्वेरी स्ट्रिंग के फ़ॉर्मैट में होता है और यह इनमें से किसी एक उदाहरण की तरह दिखता है:

  https://wear.googleapis.com/3p_auth/com.your.package.name?code=xyz
  https://wear.googleapis-cn.com/3p_auth/com.your.package.name?code=xyz

इससे एक पेज लोड होता है, जो उपयोगकर्ता को साथ में काम करने वाले ऐप्लिकेशन पर ले जाता है. साथ में काम करने वाला ऐप्लिकेशन, जवाब के यूआरएल की पुष्टि करता है और onAuthorizationResponse API का इस्तेमाल करके, जवाब को आपके Wear OS ऐप्लिकेशन पर रिले करता है.

इसके बाद, घड़ी का ऐप्लिकेशन, ऑथराइज़ेशन कोड को ऐक्सेस टोकन के लिए एक्सचेंज कर सकता है.

डिवाइस ऑथराइज़ेशन ग्रांट

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

इस प्रोसेस को आसान बनाने के लिए, RemoteActivityHelper का इस्तेमाल करके, उपयोगकर्ता के जोड़े गए मोबाइल डिवाइस पर वेब पेज खोलें. इसका तरीका, यहां दिए गए उदाहरण में दिखाया गया है:

// Request access from the authorization server and receive Device Authorization Response.
private fun verifyDeviceAuthGrant(verificationUri: String) {
    RemoteActivityHelper(context).startRemoteActivity(
        Intent(Intent.ACTION_VIEW).apply {
            addCategory(Intent.CATEGORY_BROWSABLE)
            data = Uri.parse(verificationUri)
        },
        null
    )
}OAuthDAG.kt

अगर आपके पास iOS ऐप्लिकेशन है, तो टोकन को ऑथराइज़ करने के लिए ब्राउज़र पर निर्भर रहने के बजाय, अपने ऐप्लिकेशन में इस इंटेंट को इंटरसेप्ट करने के लिए यूनिवर्सल लिंक का इस्तेमाल करें.