אימות בגאדג'טים לבישים

אפליקציות Wear OS יכולות לפעול באופן עצמאי, ללא אפליקציה נלווית. כלומר, אפליקציית Wear OS צריכה לנהל את האימות בעצמה כשהיא ניגשת לנתונים מהאינטרנט. עם זאת, גודל המסך הקטן של השעון ויכולות הקלט המוגבלות מגבילות את אפשרויות האימות שבהן אפליקציה ל-Wear OS יכולה להשתמש.

במדריך הזה מפורטות שיטות האימות המומלצות לאפליקציות ל-Wear OS, וגם שיטות חלופיות במקרים שבהם השיטות האלה לא מתאימות לתרחיש לדוגמה של האפליקציה.

למידע נוסף על תכנון חוויית כניסה טובה, אפשר לעיין במדריך בנושא חוויית משתמש בכניסה.

מצב אורח

לא דורשים אימות לכל הפונקציונליות. במקום זאת, כדאי לספק למשתמש כמה תכונות שאפשר בלי לדרוש ממנו להיכנס לחשבון.

משתמשים עשויים למצוא ולהתקין את האפליקציה שלכם ל-Wear בלי להשתמש באפליקציה לנייד, ולכן יכול להיות שאין להם חשבון והם לא יודעים אילו תכונות היא מציעה. חשוב לוודא שהפונקציונליות של מצב האורח מציגה בצורה מדויקת את התכונות של האפליקציה.

יכול להיות שחלק מהמכשירים יישארו נעולים למשך זמן ארוך יותר

במכשירים נתמכים עם Wear OS 5 ואילך, המערכת מזהה אם המשתמש עונד את המכשיר על פרק כף היד. אם המשתמש משבית את זיהוי פרק כף היד ואז מסיר את המכשיר מהפרק, המערכת שומרת על ביטול הנעילה של המכשיר למשך זמן ארוך יותר מאשר במקרה אחר.

אם האפליקציה שלכם דורשת רמת אבטחה גבוהה יותר – למשל, כשמוצגים בה נתונים רגישים או פרטיים – תחילה צריך לבדוק אם זיהוי פרק כף היד מופעל:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

אם ערך ההחזרה של השיטה הזו הוא false, צריך לבקש מהמשתמש להיכנס לחשבון באפליקציה לפני שמוצג תוכן ספציפי למשתמש.

שיטות אימות מומלצות

אפשר להשתמש בשיטות האימות הבאות כדי לאפשר לאפליקציות נפרדות ל-Wear OS לקבל את פרטי הכניסה לאימות המשתמשים.

העברת אסימונים באמצעות שכבת הנתונים

אפליקציית התלווה לטלפון יכולה להעביר נתוני אימות לאפליקציית Wear OS בצורה מאובטחת באמצעות שכבת הנתונים של Wearables. העברת פרטי הכניסה כהודעות או כפריטי נתונים.

בדרך כלל לא נדרשת כל פעולה מצד המשתמש. עם זאת, חשוב להימנע מאימות בלי להודיע למשתמש שהוא נכנס לחשבון. תוכלו להודיע למשתמש באמצעות מסך פשוט שניתן לסגור, שבו מוצגת ההודעה שהחשבון שלו מועבר מהנייד.

חשוב: באפליקציית Wear צריכה להיות לפחות שיטת אימות אחת נוספת, כי האפשרות הזו פועלת רק בשעונים מותאמים ל-Android כשאפליקציית Wear לנייד מותקנת. לספק שיטת אימות חלופית למשתמשים שאין להם את האפליקציה לנייד המתאימה, או שהמכשיר שלהם עם 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, ראו שליחת נתונים וסנכרון שלהם ב-Wear OS.

שימוש ב-OAuth 2.0

ב-Wear OS יש תמיכה בשני תהליכים שמבוססים על OAuth 2.0, שמפורטים בהמשך:

• הענקת קוד הרשאה עם מפתח הוכחה להחלפת קוד (PKCE), כפי שמוגדר ב-RFC 7636
• הרשאת Device Authorization, כפי שמוגדרת ב-RFC 8628

הערה: כדי לוודא שהאפליקציה לא תיסגר כשהשעון עובר למצב אווירה, צריך להפעיל את התכונה 'תמיד מופעל' באמצעות AmbientModeSupport.attach בפעילות שמבצעת את האימות. למידע נוסף על שיטות מומלצות במצב אווירה, ראו איך שומרים על האפליקציה גלויה ב-Wear.

מפתח הוכחה לחילופי קודים (PKCE)

כדי להשתמש ב-PKCE בצורה יעילה, צריך להשתמש ב-RemoteAuthClient.

כדי לבצע בקשת אימות מאפליקציית Wear OS לספק OAuth, יוצרים אובייקט OAuthRequest. האובייקט הזה מורכב מכתובת URL של נקודת הקצה של 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 מאמת את המשתמש ומקבל ממנו הסכמה להרשאות המבוקשות. התשובה נשלחת לכתובת ה-URL להפניה אוטומטית שנוצרה.

אחרי הרשאה מוצלחת או כושלת, שרת OAuth 2.0 מפנה לכתובת ה-URL שצוינה בבקשה. אם המשתמש יאשר את בקשת הגישה, התשובה תכלול קוד הרשאה. אם המשתמש לא יאשר את הבקשה, התשובה תכיל הודעת שגיאה.

התגובה היא בצורת מחרוזת שאילתה, והיא נראית כמו אחת מהדוגמאות הבאות:

  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

הפעולה הזו טוענת דף שמפנה את המשתמש לאפליקציית האפליקציה. אפליקציית האפליקציה מאמתת את כתובת ה-URL של התגובה ומעבירה את התגובה לאפליקציית השעון של הצד השלישי באמצעות ה-API ‏onAuthorizationResponse.

לאחר מכן, אפליקציית השעון יכולה להחליף את קוד האימות באסימון גישה.

הערה: אחרי היצירה של OAuthRequest, תוכלו למצוא את כתובת ה-URL להפניה אוטומטית על ידי גישה למאפיין redirectUrl.

הענקת הרשאה למכשיר

כשמשתמשים בהענקת הרשאת אימות למכשיר, המשתמש פותח את ה-URI לאימות במכשיר אחר. לאחר מכן, שרת ההרשאות מבקש מהם לאשר או לדחות את הבקשה.

כדי להקל על התהליך, אפשר להשתמש ב-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.

דרישות מוקדמות

לפני שתוכלו להתחיל לשלב את 'כניסה באמצעות חשבון Google' באפליקציה שלכם ל-Wear OS, עליכם להגדיר פרויקט ב-Google API Console ולהגדיר את הפרויקט ב-Android Studio. מידע נוסף זמין במאמר תחילת השילוב של כניסה באמצעות חשבון Google באפליקציה ל-Android.

אם אתם משתמשים בכניסה באמצעות חשבון Google באפליקציה או באתר שמתקשרים עם שרת לקצה העורפי, יש שתי דרישות מוקדמות נוספות:

• יוצרים מזהה לקוח של אפליקציית אינטרנט ב-OAuth 2.0 בשביל שרת הקצה העורפי. מזהה הלקוח הזה שונה ממזהה הלקוח של האפליקציה. מידע נוסף זמין במאמר הפעלת גישה בצד השרת.
• לזהות את המשתמש שמחובר כרגע בשרת באופן מאובטח, על ידי שליחת אסימון המזהה של המשתמש באמצעות HTTPS. במאמר אימות באמצעות שרת לקצה העורפי מוסבר איך לאמת את המשתמש בשרת לקצה העורפי.

איך משלבים את 'כניסה באמצעות חשבון Google' באפליקציה

כדי לשלב את הכניסה באמצעות חשבון Google באפליקציה שלכם ל-Wear OS, עליכם לעיין בשלבים הבאים שמפורטים בקטעים הבאים ולהטמיע אותם:

1. מגדירים את הכניסה באמצעות חשבון Google.
2. מוסיפים לחצן לכניסה באמצעות חשבון Google.
3. הפעלת תהליך הכניסה כשמקישים על לחצן הכניסה.

הגדרת Google Sign-In וליצור את האובייקט GoogleApiClient

בשיטה onCreate() של פעילות הכניסה, מגדירים את Google Sign-In לבקש את נתוני המשתמשים שנדרשים לאפליקציה. לאחר מכן יוצרים אובייקט GoogleApiClient עם גישה ל-Google Sign-In API ולאפשרויות שציינתם. השלבים האלה מפורטים בדוגמה הבאה:

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);

יצירת כוונה לכניסה לחשבון והפעלת תהליך הכניסה

כדי לטפל בהקשות על לחצן הכניסה בשיטה onCLick(), יוצרים כוונה לכניסה באמצעות השיטה getSignInIntent(). לאחר מכן מפעילים את הכוונה באמצעות השיטה startActivityForResult().

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

המשתמש מתבקש לבחור חשבון Google שבו יתבצע הכניסה. אם ביקשת הרשאות מעבר לפרופיל, לאימייל ול-OpenID, המשתמש יתבקש גם להעניק גישה למשאבים האלה.

לבסוף, ב-method‏ onActivityResult של הפעילות, מאחזרים את תוצאת הכניסה באמצעות getSignInResultFromIntent. אחרי שאתם מאחזרים את תוצאת הכניסה, אתם יכולים לבדוק אם הכניסה בוצעה בהצלחה באמצעות השיטה isSuccess. אם הכניסה תתבצע בהצלחה, תוכלו להפעיל את השיטה getSignInAccount כדי לקבל אובייקט GoogleSignInAccount שמכיל מידע על המשתמש שמחובר, כמו שם המשתמש. השלבים האלה מוצגים בדוגמה הבאה:

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

@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();
        }
    }
}