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 से साइन इन करें' सुविधा)

इस गाइड में, Wear OS पर पुष्टि करने के अन्य तरीकों (डेटा लेयर टोकन शेयर करने और OAuth) को Credential Manager के बैकअप के तौर पर माइग्रेट करने के तरीके के बारे में भी निर्देश दिए गए हैं. साथ ही, अब बंद हो चुके, स्टैंडअलोन 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 की स्क्रीन को बंद करने की उपयोगकर्ता की कार्रवाई को मैनेज करने के लिए, अपने GetCredential लॉजिक के तहत NoCredentialExceptionको कैप्चर करें. इसके बाद, अपने कस्टम ऑथ यूज़र इंटरफ़ेस (यूआई) पर जाएं.

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 पर आधारित दो फ़्लो के साथ काम करता है. इनके बारे में, अगले सेक्शन में बताया गया है:

RFC 7636 में बताए गए, Proof Key for Code Exchange (PKCE) के साथ ऑथराइज़ेशन कोड ग्रांट, जैसा कि RFC 7636 में बताया गया है
RFC 8628 में बताए गए, Device Authorization Grant (DAG)

Proof Key for Code Exchange (PKCE)

PKCE का असरदार तरीके से इस्तेमाल करने के लिए, 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 ऐप्लिकेशन पर रिले करता है.

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

Device Authorization Grant

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

इस प्रोसेस को आसान बनाने के लिए, उपयोगकर्ता के जोड़े गए मोबाइल डिवाइस पर वेब पेज खोलने के लिए, 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 ऐप्लिकेशन है, तो टोकन को ऑथराइज़ करने के लिए ब्राउज़र पर निर्भर रहने के बजाय, अपने ऐप्लिकेशन में इस इंटेंट को इंटरसेप्ट करने के लिए, यूनिवर्सल लिंक का इस्तेमाल करें.