تسجيل الدخول على Android باستخدام FirebaseUI

هذا الدرس العملي حول الترميز هو جزء من دورة "تطبيقات متقدّمة متوافقة مع نظام Android باستخدام لغة Kotlin". ستستفيد إلى أقصى حدّ من هذه الدورة التدريبية إذا تابعت دروس الترميز بالتسلسل، ولكن هذا ليس إلزاميًا. يمكنك الاطّلاع على جميع دورات الترميز في الدورة التدريبية على الصفحة المقصودة لدورات الترميز في "تطبيقات متقدمة متوافقة مع نظام Android باستخدام لغة Kotlin".

هذا الدرس التطبيقي حول الترميز هو جزء من سلسلة ترشدك إلى كيفية إتاحة تسجيل الدخول للمستخدمين . ننصحك بإكمال جميع دروس Codelab بالترتيب، لأنّها تتضمّن مهامًا يتم تنفيذها خطوة بخطوة.

تتضمّن هذه السلسلة من الجلسات العملية ما يلي:

• ‫6.1 تسجيل الدخول على Android باستخدام FirebaseUI
• ‫6.2 التنقّل الشرطي في Android مع تسجيل الدخول

مقدمة

عند إنشاء تطبيق Android، هناك العديد من المزايا التي يمكن أن يحقّقها توفير إمكانية تسجيل الدخول للمستخدمين. من خلال السماح للمستخدمين بإنشاء هوية داخل تطبيقك، يمكنك تزويدهم بطرق أكثر للتفاعل مع التطبيق.

باستخدام الحسابات المخصّصة، يمكن للمستخدمين تخصيص تجربتهم داخل التطبيق والتفاعل مع مستخدمين آخرين والاحتفاظ ببياناتهم ونقلها إذا كانوا يستخدمون التطبيق على جهاز آخر (مثل الويب أو هاتف جديد).

في هذا الدرس البرمجي، ستتعرّف على أساسيات كيفية إتاحة تسجيل الدخول إلى تطبيقك باستخدام مكتبة FirebaseUI. من بين العديد من الميزات الأخرى، تسهّل مكتبة FirebaseUI على المطوّرين الذين يريدون إنشاء مسار تسجيل الدخول، وتتولّى مهمة إدارة حسابات المستخدمين نيابةً عنك.

ما يجب معرفته

• أساسيات كيفية إنشاء تطبيق Android
• LiveData وViewModel

أهداف الدورة التعليمية

• كيفية إضافة Firebase إلى مشروعك
• كيفية إتاحة تسجيل الدخول إلى تطبيق Android
• كيفية الاطّلاع على حالة المصادقة الحالية لتطبيقك
• كيفية تسجيل خروج المستخدمين

الإجراءات التي ستنفذّها

• استخدِم وحدة تحكّم Firebase لدمج Firebase في تطبيقك.
• تنفيذ ميزة تسجيل الدخول
• إضافة تخصيصات في التطبيق للمستخدمين الذين سجّلوا الدخول
• تنفيذ عملية تسجيل خروج المستخدمين

مزيد من المعلومات حول LiveData وViewModel

بالنسبة إلى التطبيق في هذا الدرس البرمجي، يجب أن يكون لديك فهم أساسي لـ LiveData وViewModel. يمكنك قراءة النظرتَين العامتَين حول LiveData وViewModel إذا أردت الحصول على نظرة عامة موجزة حول هذين المفهومَين.

يمكنك أيضًا الاطّلاع على دورة "تطوير تطبيقات Android باستخدام لغة Kotlin" التدريبية للتعرّف على مواضيع Android الأساسية التي ستصادفك كجزء من هذا الدرس العملي. تتوفّر هذه الدورة التدريبية كـ دورة تدريبية على Udacity ودورة تدريبية على Codelabs.

في هذا الدرس العملي، ستنشئ تطبيقًا يعرض معلومات ممتعة عن Android. والأهم من ذلك، سيحتوي التطبيق على زر تسجيل الدخول/تسجيل الخروج. عندما يسجّل المستخدم الدخول إلى التطبيق، ستتضمّن أي حقيقة عن Android يتم عرضها تحية للمستخدم كطريقة لإضافة لمسة من التخصيص.

نزِّل التطبيق النموذجي، ويمكنك إجراء أحد الإجراءَين التاليَين:

تنزيل ملف Zip

... أو استنسِخ مستودع GitHub من سطر الأوامر باستخدام الأمر التالي وانتقِل إلى فرع start من المستودع:

$  git clone https://github.com/googlecodelabs/android-kotlin-login

ملاحظة مهمة: يتوفّر رمز البداية في فرع start من مستودع الرموز الذي تم تنزيله.

ملاحظة مهمة: بما أنّك ستدمج التطبيق لاستخدام Firebase، يتطلّب تطبيق البداية بعض الإعدادات لإنشائه وتشغيله. ستنفّذ هذه الخطوة في الخطوة التالية من الدرس العملي.

الخطوة 1: إنشاء مشروع Firebase

قبل أن تتمكّن من إضافة Firebase إلى تطبيق Android، عليك إنشاء مشروع على Firebase للربط بتطبيق Android.

1. في وحدة تحكُّم Firebase، انقر على إضافة مشروع.
2. اختَر اسم مشروع أو أدخِله. يمكنك تسمية مشروعك بأي اسم، ولكن حاوِل اختيار اسم ذي صلة بالتطبيق الذي تنشئه.
3. انقر على متابعة.
4. يمكنك تخطّي إعداد "إحصاءات Google" واختيار الخيار ليس الآن.
5. انقر على إنشاء مشروع لإنهاء إعداد مشروع Firebase.

الخطوة 2: تسجيل تطبيقك في Firebase

بعد إنشاء مشروع على Firebase، يمكنك إضافة تطبيق Android إليه.

1. في وسط صفحة النظرة العامة على المشروع في "وحدة تحكّم Firebase"، انقر على رمز Android لبدء خطوات الإعداد.
2. أدخِل معرّف التطبيق في تطبيقك في حقل اسم حزمة Android. تأكَّد من إدخال المعرّف الذي يستخدمه تطبيقك، لأنّه لا يمكنك إضافة هذه القيمة أو تعديلها بعد تسجيل تطبيقك في مشروعك على Firebase.

1. يُشار أحيانًا إلى رقم تعريف التطبيق باسم اسم الحزمة.
2. يمكنك العثور على رقم تعريف التطبيق هذا في ملف Gradle للوحدة (على مستوى التطبيق)، وعادةً يكون app/build.gradle (مثال على رقم التعريف: com.yourcompany.yourproject).
3. أدخِل شهادة توقيع تصحيح الأخطاء SHA-1. يمكنك إنشاء هذا المفتاح عن طريق إدخال الأمر التالي في وحدة طرفية لسطر الأوامر.

keytool -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v -storepass android

4. انقر على تسجيل التطبيق.

الخطوة 3: إضافة ملف إعداد Firebase إلى مشروعك

أضِف ملف إعداد Firebase Android إلى تطبيقك:

1. انقر على تنزيل ملف google-services.json للحصول على ملف إعداد Firebase Android (google-services.json).

• يمكنك تنزيل ملف إعداد Android في Firebase مرة أخرى في أي وقت.
• تأكَّد من عدم إضافة أحرف إضافية إلى ملف الإعداد وأنّ اسمه يجب أن يكون google-services.json فقط.

2. انقل ملف الإعداد إلى دليل الوحدة (على مستوى التطبيق) في تطبيقك.

الخطوة 4: ضبط مشروع Android لتفعيل منتجات Firebase

1. لتفعيل منتجات Firebase في تطبيقك، أضِف المكوّن الإضافي لخدمات Google إلى ملفات Gradle.

1. في ملف Gradle على مستوى الجذر (على مستوى المشروع) (build.gradle)، أضِف قواعد لتضمين المكوّن الإضافي لخدمات Google. تأكَّد أيضًا من توفّر مستودع Maven من Google.

build.gradle

buildscript {

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Add the following line:
    classpath 'com.google.gms:google-services:4.3.0'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
    // ...
  }
}

2. في ملف Gradle الخاص بالوحدة (على مستوى التطبيق) (عادةً app/build.gradle)، أضِف سطرًا إلى أسفل الملف.

app/build.gradle

apply plugin: 'com.android.application'

android {
  // ...
}

// Add the following line to the bottom of the file:
apply plugin: 'com.google.gms.google-services'  // Google Play services Gradle plugin

الخطوة 4: إضافة تبعية Firebase

في هذا الدرس العملي، السبب الرئيسي لدمج Firebase هو توفير طريقة لإنشاء المستخدمين وإدارتهم. لإجراء ذلك، عليك إضافة مكتبة Firebase التي تتيح لك تنفيذ عملية تسجيل الدخول.

1. أضِف التبعية التالية في ملف build.gradle (Module:app) حتى تتمكّن من استخدام حزمة SDK في تطبيقك. تتيح حزمة تطوير البرامج (SDK) firebase-auth إدارة المستخدمين الذين تمّت مصادقتهم في تطبيقك.

app/build.gradle:

implementation 'com.firebaseui:firebase-ui-auth:5.0.0'

2. زامِن مشروعك مع ملفات Gradle للتأكّد من توفّر جميع التبعيات لتطبيقك. إذا لم يُطلب منك ذلك، اختَر ملف > مزامنة المشروع مع ملفات Gradle في "استوديو Android" أو من شريط الأدوات.

الخطوة 5: تشغيل التطبيق وفحص الرمز

1. شغِّل التطبيق على محاكي أو جهاز فعلي للتأكّد من إعداد بيئة التطوير بنجاح.

في حال نجاح ذلك، من المفترض أن تعرض الشاشة الرئيسية معلومة مسلّية عن Android وزر تسجيل الدخول في أعلى يسار الشاشة. لن يؤدي النقر على زر تسجيل الدخول إلى أي إجراء في الوقت الحالي.

بشكل عام، هذا تطبيق بنشاط واحد يتضمّن عدّة أجزاء. تحتوي MainFragment على كل واجهة المستخدم التي تظهر على الشاشة أدناه. (ستعمل مع LoginFragment وSettingsFragment في درس تطبيقي حول الترميز لاحقًا).

2. تعرَّف على الرمز. يُرجى الانتباه إلى ما يلي على وجه الخصوص:

• ‫FirebaseUserLiveData هو الفئة التي ستنفّذها لمراقبة مستخدم Firebase الحالي المرتبط بالتطبيق. ستستخدم مثيل FirebaseAuth كنقطة دخول للحصول على معلومات المستخدم هذه في خطوة لاحقة.
• MainFragment مرتبط بـ LoginViewModel. ‫LoginViewModel هو الفئة التي ستنفّذها من أجل استخدام FirebaseUserLiveData لإنشاء متغيّر authenticationState. باستخدام المتغيّر authenticationState، يمكن لـ MainFragment بعد ذلك مراقبة القيمة لتعديل واجهة المستخدم وفقًا لذلك.

في هذه الخطوة، ستستخدم Firebase Console لإعداد طرق المصادقة التي تريد أن يتيحها تطبيقك. في هذا الدرس العملي، ستركز على السماح للمستخدمين بتسجيل الدخول باستخدام عنوان بريد إلكتروني يقدّمونه أو حسابهم على Google.

1. انتقِل إلى وحدة تحكُّم Firebase. (ملاحظة: إذا كنت لا تزال في سير عمل "إضافة Firebase"، انقر على X في أعلى يمين الصفحة للرجوع إلى وحدة التحكّم.
2. اختَر مشروعك إذا لم تكن فيه بعد.
3. افتح شريط التنقّل الأيمن واختَر تطوير > المصادقة.

4. انقر على علامة التبويب طريقة تسجيل الدخول في شريط التنقّل العلوي.

5. انقر على صف البريد الإلكتروني/كلمة المرور.
6. في النافذة المنبثقة، انقر على مفتاح التبديل مفعَّل ثم على حفظ.
7. وبالمثل، انقر على صف Google.
8. فعِّل خيار مفعّل، وأدخِل عنوان البريد الإلكتروني المخصّص لدعم المشروع، ثم انقر على حفظ.

في هذه المهمة، ستنفّذ ميزة تسجيل الدخول للمستخدمين.

1. فتح "MainFragment.kt"
2. في تخطيط MainFragment، لاحظ auth_button. وهي غير معدّة حاليًا للتعامل مع أي مدخلات من المستخدمين.
3. في onViewCreated(),، أضِف onClickListener إلى auth_button للاتصال بـ launchSignInFlow().

MainFragment.kt

binding.authButton.setOnClickListener { launchSignInFlow() }

4. ابحث عن طريقة launchSignInFlow() في MainFragment.kt. يحتوي حاليًا على TODO.
5. أكمِل الدالة launchSignInFlow() كما هو موضّح أدناه.

MainFragment.kt

private fun launchSignInFlow() {
   // Give users the option to sign in / register with their email or Google account.
   // If users choose to register with their email,
   // they will need to create a password as well.
   val providers = arrayListOf(
       AuthUI.IdpConfig.EmailBuilder().build(), AuthUI.IdpConfig.GoogleBuilder().build()

       // This is where you can provide more ways for users to register and 
       // sign in.
   )

   // Create and launch sign-in intent.
   // We listen to the response of this activity with the
   // SIGN_IN_REQUEST_CODE 
   startActivityForResult(
       AuthUI.getInstance()
           .createSignInIntentBuilder()
           .setAvailableProviders(providers)
           .build(),
       MainFragment.SIGN_IN_REQUEST_CODE
   )
}

يتيح ذلك للمستخدمين التسجيل وتسجيل الدخول باستخدام عنوان بريدهم الإلكتروني أو حسابهم على Google. إذا اختار المستخدم التسجيل باستخدام عنوان بريده الإلكتروني، سيكون عنوان البريد الإلكتروني وكلمة المرور اللذان ينشئهما فريدَين لتطبيقك، ما يعني أنّه سيتمكّن من تسجيل الدخول إلى تطبيقك باستخدام عنوان البريد الإلكتروني وكلمة المرور، ولكن لا يعني ذلك أنّه يمكنه أيضًا تسجيل الدخول إلى أي تطبيق آخر متوافق مع Firebase باستخدام بيانات الاعتماد نفسها.

6. في MainFragment.kt، يمكنك الاستماع إلى نتيجة عملية تسجيل الدخول من خلال تنفيذ طريقة onActivityResult()، كما هو موضّح أدناه. بما أنّك بدأت عملية تسجيل الدخول باستخدام SIGN_IN_REQUEST_CODE، يمكنك أيضًا الاستماع إلى نتيجة عملية تسجيل الدخول من خلال الفلترة حسب الوقت الذي يتم فيه إعادة SIGN_IN_REQUEST_CODE إلى onActivityResult(). ابدأ بإضافة بعض عبارات السجلّ لمعرفة ما إذا كان المستخدم قد سجّل الدخول بنجاح.
   

MainFragment.kt

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
   super.onActivityResult(requestCode, resultCode, data)
   if (requestCode == SIGN_IN_REQUEST_CODE) {
       val response = IdpResponse.fromResultIntent(data)
       if (resultCode == Activity.RESULT_OK) {
           // User successfully signed in
           Log.i(TAG, "Successfully signed in user ${FirebaseAuth.getInstance().currentUser?.displayName}!")
       } else {
           // Sign in failed. If response is null the user canceled the
           // sign-in flow using the back button. Otherwise check
           // response.getError().getErrorCode() and handle the error.
           Log.i(TAG, "Sign in unsuccessful ${response?.error?.errorCode}")
       }
   }
}

من المفترض أن يتمكّن تطبيقك الآن من التعامل مع تسجيل المستخدمين وتسجيل دخولهم.

7. شغِّل التطبيق وتأكَّد من أنّ النقر على الزر تسجيل الدخول يؤدي إلى ظهور شاشة تسجيل الدخول.
8. يمكنك الآن تسجيل الدخول باستخدام عنوان بريدك الإلكتروني وكلمة المرور، أو باستخدام حسابك على Google.
9. لن يحدث أي تغيير في واجهة المستخدم بعد تسجيل الدخول (ستنفّذ تعديل واجهة المستخدم في الخطوة التالية)، ولكن إذا كان كل شيء يعمل بشكل صحيح، من المفترض أن تظهر لك رسالة السجلّ Successfully signed in user ${your name}! بعد إكمال عملية التسجيل.
10. يمكنك أيضًا الانتقال إلى وحدة تحكّم Firebase ثم إلى تطوير > المصادقة > المستخدمون للتأكّد من أنّ التطبيق يتضمّن الآن مستخدمًا واحدًا مسجّلاً.
11. يُرجى العِلم أنّه عندما ينشئ المستخدمون حسابًا لتطبيقك، يكون هذا الحساب مرتبطًا بتطبيقك فقط، وليس بأي تطبيق آخر يستخدم Firebase لتوفير وظيفة تسجيل الدخول.

في هذه المهمة، ستنفّذ عملية تعديل واجهة المستخدم استنادًا إلى حالة المصادقة. عندما يكون المستخدم مسجّلاً الدخول، يمكنك تخصيص شاشته الرئيسية من خلال عرض اسمه. عليك أيضًا تعديل الزر تسجيل الدخول ليصبح الزر تسجيل الخروج عندما يكون المستخدم مسجّلاً الدخول.

1. افتح صف FirebaseUserLiveData.kt الذي تم إنشاؤه لك مسبقًا. أول ما عليك فعله هو توفير طريقة تتيح للفئات الأخرى في التطبيق معرفة متى سجّل المستخدم الدخول أو الخروج. ومع ذلك، لا يفعل الصف أي شيء حتى الآن لأنّ قيمة LiveData لا يتم تعديلها.
2. بما أنّك تستخدم مكتبة FirebaseAuth، يمكنك الاستماع إلى التغييرات التي تطرأ على المستخدم الذي سجّل الدخول باستخدام معاودة الاتصال FirebaseUser.AuthStateListener التي يتم تنفيذها لك كجزء من مكتبة FirebaseUI. يتم تشغيل هذا الإجراء عند تسجيل دخول المستخدم إلى تطبيقك أو تسجيل خروجه منه.
3. لاحظ أنّ FirebaseUserLiveData.kt تحدّد المتغيّر authStateListener. ستستخدم هذا المتغيّر لتخزين قيمة LiveData. تم إنشاء المتغيّر authStateListener حتى تتمكّن من بدء الاستماع إلى التغييرات في حالة المصادقة وإيقافها بشكل صحيح استنادًا إلى حالة تطبيقك. على سبيل المثال، إذا وضع المستخدم التطبيق في الخلفية، يجب أن يتوقف التطبيق عن الاستماع إلى تغييرات حالة المصادقة لمنع أي تسرّب محتمل للذاكرة.
4. عدِّل authStateListener لكي تتطابق قيمة FirebaseUserLiveData مع مستخدم Firebase الحالي.

FirebaseUserLiveData.kt

private val authStateListener = FirebaseAuth.AuthStateListener { firebaseAuth ->
   value = firebaseAuth.currentUser
}

5. فتح "LoginViewModel.kt"
6. في LoginViewModel.kt، أنشئ متغيّر authenticationState استنادًا إلى عنصر FirebaseUserLiveData الذي نفّذته للتو. من خلال إنشاء المتغيّر authenticationState، يمكن للفئات الأخرى الآن الاستعلام عمّا إذا كان المستخدم مسجّلاً الدخول أم لا من خلال LoginViewModel.

LoginViewModel.kt

val authenticationState = FirebaseUserLiveData().map { user ->
   if (user != null) {
       AuthenticationState.AUTHENTICATED
   } else {
       AuthenticationState.UNAUTHENTICATED
   }
}

7. فتح "MainFragment.kt."
8. في MainFragment.ktobserveAuthenticationState()، يمكنك استخدام المتغيّر authenticationState الذي أضفته للتو في LoginViewModel وتغيير واجهة المستخدم وفقًا لذلك. إذا كان هناك مستخدم مسجّل الدخول، يجب أن تعرض authButton تسجيل الخروج.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
       when (authenticationState) {
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   // TODO implement logging out user in next step
               }

                // TODO 2. If the user is logged in, 
                 // you can customize the welcome message they see by
                 // utilizing the getFactWithPersonalization() function provided

           }
           else -> {
               // TODO 3. Lastly, if there is no logged-in user, 
                // auth_button should display Login and
                //  launch the sign in screen when clicked.
           }
       }
   })
}

9. إذا كان المستخدم مسجّلاً الدخول، يمكنك أيضًا تخصيص رسالة الترحيب التي تظهر له باستخدام الدالة getFactWithPersonalization() المتوفّرة في MainFragment.
   

MainFragment.kt

binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

10. أخيرًا، إذا لم يكن هناك مستخدم مسجّل الدخول (عندما تكون قيمة authenticationState أي شيء آخر غير LoginViewModel.AuthenticationState.AUTHENTICATED)، يجب أن تعرض auth_button تسجيل الدخول وأن تفتح شاشة تسجيل الدخول عند النقر عليها. يجب أيضًا عدم تخصيص الرسالة المعروضة.

MainFragment.kt

binding.authButton.text = getString(R.string.login_button_text)
binding.authButton.setOnClickListener { launchSignInFlow() }
binding.welcomeText.text = factToDisplay

بعد إكمال جميع الخطوات، من المفترض أن تبدو طريقة observeAuthenticationState() النهائية مشابهة للرمز البرمجي أدناه.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
        // TODO 1. Use the authenticationState variable you just added 
         // in LoginViewModel and change the UI accordingly.
       when (authenticationState) {
            // TODO 2.  If the user is logged in, 
             // you can customize the welcome message they see by
             // utilizing the getFactWithPersonalization() function provided
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.welcomeText.text = getFactWithPersonalization(factToDisplay)
               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   // TODO implement logging out user in next step
               }
           }
           else -> {
                // TODO 3. Lastly, if there is no logged-in user, 
                 // auth_button should display Login and
                 // launch the sign in screen when clicked.
               binding.welcomeText.text = factToDisplay

               binding.authButton.text = getString(R.string.login_button_text)
               binding.authButton.setOnClickListener {
                   launchSignInFlow()
               }
           }
       }
   })
}

11. شغِّل تطبيقك. من المفترض أن يتم تعديل واجهة المستخدم وفقًا لما إذا كان المستخدم مسجّلاً الدخول أم لا. إذا كان كل شيء يعمل بشكل صحيح وكنت مسجّلاً الدخول، من المفترض أن ترحّب بك الشاشة الرئيسية باسمك بالإضافة إلى عرض معلومة عن Android. من المفترض أن يعرض زر تسجيل الدخول الآن تسجيل الخروج.

في هذه المهمة، ستنفّذ ميزة تسجيل الخروج.

بما أنّ التطبيق يسمح للمستخدمين بتسجيل الدخول، يجب أن يوفّر لهم أيضًا طريقة لتسجيل الخروج. في ما يلي مثال على كيفية تسجيل خروج مستخدم باستخدام سطر واحد فقط من الرمز البرمجي:

AuthUI.getInstance().signOut(requireContext())

1. فتح "MainFragment.kt"
2. في observeAuthenticationState() ضمن MainFragment.kt، أضِف منطق تسجيل الخروج لكي تعمل وظائف auth_button بشكلٍ صحيح عندما يكون هناك مستخدم مسجّل الدخول. تبدو النتيجة النهائية للطريقة على النحو الموضّح في الرمز البرمجي أدناه.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
       when (authenticationState) {
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   AuthUI.getInstance().signOut(requireContext())
               }
           }
           else -> {
               binding.welcomeText.text = factToDisplay

               binding.authButton.text = getString(R.string.login_button_text)
               binding.authButton.setOnClickListener {
                   launchSignInFlow()
               }
           }
       }
   })
}

3. شغِّل التطبيق.
4. انقر على الزر تسجيل الخروج وتأكَّد من تسجيل خروج المستخدم وتغيير حالة الزر إلى تسجيل الدخول.

يمكنك العثور على الإصدار النهائي من التطبيق المكتمل هنا https://github.com/googlecodelabs/android-kotlin-login.

في هذا الدرس العملي، تعلّمت ما يلي:

• كيفية إضافة Firebase إلى مشروعك من خلال إضافة التبعيات اللازمة في ملف Gradle وإعداد المشروع في وحدة تحكّم Firebase
• كيفية تنفيذ عملية تسجيل الدخول في تطبيقك باستخدام مكتبة FirebaseUI وتحديد الطريقة التي تريد السماح للمستخدمين بتسجيل الدخول من خلالها يُرجى العِلم أنّ أي حساب ينشئه المستخدم في تطبيقك يكون خاصًا بتطبيقك فقط، ولا تتم مشاركته مع جميع التطبيقات التي تستخدم Firebase لتوفير وظيفة تسجيل الدخول.
• كيفية مراقبة حالة المصادقة الحالية لتطبيقك باستخدام LiveData
• كيفية تسجيل خروج المستخدمين

تناول هذا الدرس التطبيقي حول الترميز الأساسيات المتعلقة بكيفية إتاحة تسجيل الدخول إلى تطبيق Android.

في هذا الدرس البرمجي، سمحت للمستخدمين بالتسجيل وتسجيل الدخول باستخدام عناوين بريدهم الإلكتروني. ومع ذلك، يمكنك استخدام مكتبة FirebaseUI أيضًا لتوفير طرق مصادقة أخرى، مثل تسجيل الدخول باستخدام رقم الهاتف. لمعرفة المزيد حول إمكانات مكتبة FirebaseUI وكيفية الاستفادة من الوظائف الأخرى التي توفّرها، اطّلِع على المراجع التالية:

• مستندات المصادقة في FirebaseUI
• عرض توضيحي ومثال على الرمز البرمجي لميزة "المصادقة" في FirebaseUI

لمزيد من المعلومات حول أفضل الممارسات المتعلّقة بتسجيل الدخول، يمكنك الاطّلاع على المراجع التالية:

الدروس التطبيقية حول الترميز:

• تحسين تطبيقك لاستخدام ميزة الملء التلقائي
• تسجيل الدخول بسلاسة باستخدام Smart Lock

مستندات مطوّري تطبيقات Android:

• إطار عمل الملء التلقائي في Android
• ‫Smart Lock لكلمات المرور على Android

فيديوهات:

• تحسين مسارات المستخدمين من خلال تسجيل الدخول

للحصول على روابط تؤدي إلى دروس برمجية أخرى في هذه الدورة التدريبية، يمكنك الانتقال إلى الصفحة المقصودة للدروس البرمجية المتقدّمة حول Android بلغة Kotlin.