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

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

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

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

शुरुआती बातें

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

मेहमान मोड

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

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

कुछ डिवाइसों को लंबे समय तक अनलॉक रखा जा सकता है

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

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

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

Credential Manager

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

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

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

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

Wear OS पर पासकी

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

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

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

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

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

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

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

सेटअप

  1. अपने ऐप्लिकेशन मॉड्यूल की build.gradle फ़ाइल में, टारगेट एपीआई लेवल को 35 पर सेट करें:

    android {
    defaultConfig {
        targetSdkVersion(35)
    }
}

  2. अपने ऐप्लिकेशन या मॉड्यूल की build.gradle फ़ाइल में ये लाइनें जोड़ें. इसके लिए, androidx.credentials रिलीज़ रेफ़रंस से सबसे नए स्टेबल वर्शन का इस्तेमाल करें.

    androidx.credentials:credentials:1.5.0
androidx.credentials:credentials-play-services-auth:1.5.0

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

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

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

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

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

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

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

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

yourCoroutineScope.launch {
    try {
      val response = credentialManager.getCredential(activity, request)
      signInWithCredential(response.credential)
    } catch (e: GetCredentialCancellationException) {
      navigateToFallbackAuthMethods()
    }
}

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

डेटा लेयर टोकन शेयर करना

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

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

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

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

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

Wear OS ऐप्लिकेशन पर डेटा में हुए बदलावों के इवेंट को सुनें. उदाहरण के लिए:

val dataClient: DataClient = Wearable.getDataClient(context)
dataClient.addListener{ dataEvents ->
    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.
            }
        }
    }
}

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

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

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

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

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

नीचे दिया गया कोड, पुष्टि करने का अनुरोध बनाने का उदाहरण दिखाता है:

val request = OAuthRequest.Builder(this.applicationContext)
    .setAuthProviderUrl(Uri.parse("https://...."))
    .setClientId(clientId)
    .setCodeChallenge(codeChallenge)
    .build()

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

val client = RemoteAuthClient.create(this)
client.sendAuthorizationRequest(request,
    { command -> command?.run() },
    object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it, and use it in
            // network requests.
        }

        override fun onAuthorizationError(errorCode: Int) {
            // Handle any errors.
        }
    }
)

यह अनुरोध, साथी ऐप्लिकेशन को कॉल ट्रिगर करता है. इसके बाद, उपयोगकर्ता के मोबाइल फ़ोन पर वेब ब्राउज़र में अनुमति देने वाला यूज़र इंटरफ़ेस दिखता है. 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.
val verificationUri = "..." // Extracted from the Device Authorization Response.
RemoteActivityHelper.startRemoteActivity(
    this,
    Intent(Intent.ACTION_VIEW)
        .addCategory(Intent.CATEGORY_BROWSABLE)
        .setData(Uri.parse(verificationUri)),
    null
)
// Poll the authorization server to find out if the user completed the user
// authorization step on their mobile device.

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

'Google से साइन इन करें' की लेगसी सुविधा से ट्रांज़िशन करना

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

// Define a basic SDK check.
fun isCredentialManagerAvailable(): Boolean {
 return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.VANILLA_ICE_CREAM
}

// Elsewhere in the code, use it to selectively disable the legacy option.
Button(
  onClick = {
    if (isCredentialManagerAvailable()) {
      Log.w(TAG, "Devices on API level 35 or higher should use
                  Credential Manager for Sign in with Google")
    } else {
      navigateToSignInWithGoogle()
    }},
  enabled = !isCredentialManagerAvailable(),
  label = { Text(text = stringResource(R.string.sign_in_with_google)) },
  secondaryLabel = { Text(text = "Disabled on API level 35+")
  }
)