पहने जाने वाले डिवाइसों पर पुष्टि करें

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

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

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

मेहमान मोड

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

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

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

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

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

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

पुष्टि करने के लिए सुझाए गए तरीके

Wear OS के स्टैंडअलोन ऐप्लिकेशन चालू करने के लिए, पुष्टि करने के इन तरीकों का इस्तेमाल करें उपयोगकर्ता की पुष्टि करने वाले क्रेडेंशियल पाएं.

डेटा लेयर का इस्तेमाल करके टोकन पास करना

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

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

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

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

val token = "..." // Auth token to transmit to the wearable 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)

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

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 interstitial screen to notify the user they are being signed in.
                // Then, store the token and use it in network requests.
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

ध्यान दें: OAuthRequest बन जाने के बाद, redirectUrl को ऐक्सेस करके, अपना रीडायरेक्ट यूआरएल देखा जा सकता है.

डिवाइस को अनुमति देना

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

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

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

Wear OS पर, साइन इन करने के अन्य तरीके भी काम करते हैं. इनके बारे में नीचे दिए गए सेक्शन में बताया गया है.

Google साइन-इन

'Google साइन इन', उपयोगकर्ता को उनके मौजूदा Google खाते से साइन इन करने की सुविधा देता है. यह सबसे बेहतर उपयोगकर्ता अनुभव देता है और इसे इस्तेमाल करना आसान है. खास तौर पर, अगर आपने इसे पहले से ही अपने हैंडहेल्ड ऐप्लिकेशन में लागू किया है.

पुष्टि करने के लिए सुझाए गए तरीकों के बारे में ऊपर बताए गए तरीके अपनाने के बाद, Google साइन इन करना अगला पसंदीदा तरीका है, क्योंकि यह iOS पर भी अच्छी तरह से काम करता है. नीचे दिए गए सेक्शन में, 'Google साइन इन' को बुनियादी तौर पर इंटिग्रेट करने का तरीका बताया गया है.

ज़रूरी शर्तें

अपने Wear OS ऐप्लिकेशन में Google Sign-In को इंटिग्रेट करने से पहले, आपको Google API Console प्रोजेक्ट को कॉन्फ़िगर करना होगा और अपना Android Studio प्रोजेक्ट सेट अप करना होगा. ज़्यादा जानकारी के लिए, देखें अपने Android ऐप्लिकेशन में 'Google साइन इन' को इंटिग्रेट करना शुरू करें.

अगर आप किसी ऐसे ऐप्लिकेशन या साइट के साथ 'Google साइन इन' का इस्तेमाल करते हैं जो संपर्क करने के लिए, यहां दो अतिरिक्त ज़रूरी शर्तें पूरी की गई हैं:

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

अपने ऐप्लिकेशन में 'Google साइन इन' को इंटिग्रेट करें

अपने Wear OS ऐप्लिकेशन में Google Sign-In को इंटिग्रेट करने के लिए, नीचे दिए गए चरणों को देखें और उन्हें लागू करें. इन चरणों के बारे में, यहां दिए गए सेक्शन में बताया गया है:

1. 'Google साइन-इन' को कॉन्फ़िगर करना.
2. 'Google साइन इन' बटन जोड़ें.
3. साइन-इन बटन के होने पर, साइन-इन फ़्लो शुरू करें टैप किया गया.

Google Sign-In को कॉन्फ़िगर करना और GoogleApiClient ऑब्जेक्ट बनाना

साइन इन करने की गतिविधि के onCreate() तरीके में, Google Sign-In को कॉन्फ़िगर करें, ताकि वह आपके ऐप्लिकेशन के लिए ज़रूरी उपयोगकर्ता डेटा का अनुरोध कर सके. इसके बाद, Google Sign-In API और आपके तय किए गए विकल्पों का ऐक्सेस वाला GoogleApiClient ऑब्जेक्ट बनाएं. यह तरीका नीचे दिए गए उदाहरण में दिखाए गए हैं:

public class MyNewActivity extends AppCompatActivity {

    private static final int RC_SIGN_IN = 9001;

    private GoogleSignInClient mSignInClient;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        GoogleSignInOptions options =
                new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                        .build();

        mSignInClient = GoogleSignIn.getClient(this, options);
    }
}

अपने ऐप्लिकेशन में 'Google साइन इन' बटन जोड़ना

Google साइन इन बटन जोड़ने के लिए, यह तरीका अपनाएं:

1. अपने ऐप्लिकेशन के लेआउट में SignInButton जोड़ें:

 <com.google.android.gms.common.SignInButton
 android:id="@+id/sign_in_button"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" />

2. अपने ऐप्लिकेशन के onCreate() तरीके में, बटन के OnClickListener को रजिस्टर करें, ताकि टैप करने पर उपयोगकर्ता साइन इन कर सके:

Kotlin

findViewById<View>(R.id.sign_in_button).setOnClickListener(this)

Java

findViewById(R.id.sign_in_button).setOnClickListener(this);

साइन-इन इंटेंट बनाएं और साइन-इन की प्रोसेस शुरू करें

getSignInIntent() तरीके का इस्तेमाल करके, साइन इन करने का इंटेंट बनाकर, onCLick() तरीके में साइन इन बटन पर टैप करने की सुविधा को मैनेज करें. इसके बाद, startActivityForResult() तरीके से इंटेंट शुरू करें.

Intent intent = mSignInClient.getSignInIntent();
startActivityForResult(intent, RC_SIGN_IN);

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

आख़िर में, गतिविधि के onActivityResult तरीका, इससे साइन इन का नतीजा वापस पाएं getSignInResultFromIntent. साइन-इन का नतीजा मिलने के बाद, ये काम किए जा सकते हैं यह जांच करें कि isSuccess तरीका. अगर साइन-इन सफल होता है, तो आप पाने का getSignInAccount तरीका GoogleSignInAccount ऑब्जेक्ट, जिसमें साइन इन करने वाले व्यक्ति की जानकारी है जैसे उपयोगकर्ता का नाम. यह तरीका नीचे दिए गए उदाहरण में दिखाया गया है:

Kotlin

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    super.onActivityResult(requestCode, resultCode, data)

    // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...).
    if (requestCode == RC_SIGN_IN) {
        Auth.GoogleSignInApi.getSignInResultFromIntent(data)?.apply {
            if (isSuccess) {
                // Get account information.
                fullName = signInAccount?.displayName
                mGivenName = signInAccount?.givenName
                mFamilyName = signInAccount?.familyName
                mEmail = signInAccount?.email
            }
        }
    }
}

Java

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...).
    if (requestCode == RC_SIGN_IN) {
        GoogleSignInResult signInResult = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
        if (signInResult.isSuccess()) {
            GoogleSignInAccount acct = signInResult.getSignInAccount();

            // Get account information.
            fullName = acct.getDisplayName();
            givenName = acct.getGivenName();
            familyName = acct.getFamilyName();
            email = acct.getEmail();
        }
    }
}

'Google साइन-इन' को लागू करने वाले ऐप्लिकेशन का नमूना देखने के लिए, GitHub पर हॉरोलॉजिस्ट Google साइन-इन सैंपल.

कस्टम कोड की मदद से पुष्टि करना

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

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

इस सेटअप के लिए, पुष्टि करने का फ़्लो इस तरह काम करता है:

1. उपयोगकर्ता, Wear OS ऐप्लिकेशन की मदद से कोई ऐसी कार्रवाई करता है जिसके लिए अनुमति की ज़रूरत होती है.
2. Wear OS ऐप्लिकेशन, उपयोगकर्ता को पुष्टि करने वाली एक स्क्रीन दिखाता है और उसे निर्देश देता है उपयोगकर्ता को किसी खास यूआरएल से कोड डालना होगा.
3. उपयोगकर्ता किसी मोबाइल डिवाइस, टैबलेट या पीसी पर स्विच करता है और फिर कोई ब्राउज़र लॉन्च करता है, Wear OS ऐप्लिकेशन में दिए गए यूआरएल पर ले जाता है और लॉग इन करता है.
4. उपयोगकर्ता को कुछ समय के लिए एक अंकों वाला कोड मिलता है. उसे Wear OS ऐप्लिकेशन की पुष्टि करने वाली स्क्रीन पर, Wear OS के ऑनबोर्ड कीबोर्ड का इस्तेमाल करके डालना होता है:

   

5. यहां से, सबूत के तौर पर डाले गए कोड का इस्तेमाल करके, यह साबित किया जा सकता है कि कोड सही है उपयोगकर्ता और Wear OS डिवाइस पर सेव और सुरक्षित पुष्टि वाले टोकन के लिए कोड को एक्सचेंज कर सकता है पुष्टि किए गए कॉल के लिए.

ध्यान दें: उपयोगकर्ता जो कोड जनरेट करता है वह सिर्फ़ अंकों से बना होना चाहिए. इसमें कोई वर्ण नहीं होना चाहिए.

इस ऑथराइज़ेशन फ़्लो को इस चार्ट में दिखाया गया है: