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

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

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

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

मेहमान मोड

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

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

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

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

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

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

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

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

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

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

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

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

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

ध्यान दें: 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 Sign-In की मदद से, उपयोगकर्ता अपने मौजूदा Google खाते से साइन इन कर सकता है. यह सबसे बेहतर उपयोगकर्ता अनुभव देता है और इसे इस्तेमाल करना आसान है. खास तौर पर, अगर आपने इसे पहले से ही अपने हैंडहेल्ड ऐप्लिकेशन में लागू किया है.

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

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

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

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

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

अपने ऐप्लिकेशन में Google Sign-In को इंटिग्रेट करना

अपने 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 का तरीका इस्तेमाल करके, यह देखा जा सकता है कि साइन इन हुआ है या नहीं. अगर साइन इन हो जाता है, तो GoogleSignInAccount ऑब्जेक्ट पाने के लिए, getSignInAccount तरीका कॉल किया जा सकता है. इस ऑब्जेक्ट में, साइन इन करने वाले उपयोगकर्ता की जानकारी होती है, जैसे कि उसका नाम. इन चरणों के बारे में नीचे दिए गए उदाहरण में बताया गया है:

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 Sign-In को लागू करने वाले सैंपल ऐप्लिकेशन को देखने के लिए, GitHub पर Horologist Google Sign-In सैंपल देखें.

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

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

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

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

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

   

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

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

पुष्टि करने के इस फ़्लो को नीचे दिए गए चार्ट में दिखाया गया है: