Firebase Android Codelab - בנה צ'אט ידידותי

1. סקירה כללית

צילום מסך

תמונה: אפליקציית Working Friendly Chat.

ברוכים הבאים למעבדת הקוד של Friendly Chat. במעבדת קוד זה תלמד כיצד להשתמש בפלטפורמת Firebase כדי ליצור אפליקציית צ'אט באנדרואיד.

מה תלמד

  • כיצד להשתמש באימות Firebase כדי לאפשר למשתמשים להיכנס.
  • כיצד לסנכרן נתונים באמצעות מסד הנתונים בזמן אמת של Firebase.
  • כיצד לאחסן קבצים בינאריים ב-Cloud Storage for Firebase.
  • כיצד להשתמש ב-Firebase Local Emulator Suite כדי לפתח אפליקציית אנדרואיד עם Firebase.

מה אתה צריך

  • Android Studio גרסה 4.2+.
  • Android Emulator עם אנדרואיד 5.0 ומעלה.
  • Java 7 ומעלה. כדי להתקין ג'אווה להשתמש אלה ההוראות ; כדי לבדוק את הגרסה שלך, לרוץ java -version .
  • היכרות עם שפת התכנות קוטלין.

2. קבל את הקוד לדוגמה

שכפל את המאגר

שכבו את מאגר GitHub משורת הפקודה:

$ git clone https://github.com/firebase/codelab-friendlychat-android

ייבא לאנדרואיד סטודיו

בשנת סטודיו אנדרואיד, בחר File> Open, ולאחר מכן בחר את build-android-start ספרייה ( android_studio_folder ) מהספרייה שבה הורדת את הקוד לדוגמה.

כעת אתה אמור לקבל את build-android-start הפרויקט פתוח בסטודיו אנדרואיד. אם אתה רואה אזהרה על google-services.json קובץ חסר, אל תדאג. זה יתווסף בשלב מאוחר יותר.

בדוק תלות

במעבדת הקוד הזה כבר נוספו עבורך כל התלות שתצטרך, אבל חשוב להבין כיצד להוסיף את Firebase SDK לאפליקציה שלך:

build.gradle

buildscript {
    // ...

    dependencies {
        classpath 'com.android.tools.build:gradle:4.1.2'

        // The google-services plugin is required to parse the google-services.json file
        classpath 'com.google.gms:google-services:4.3.5'
    }
}

app/build.gradle

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'com.google.gms.google-services'
}

android {
    // ...
}

dependencies {
    // ...

    // Google Sign In SDK
    implementation 'com.google.android.gms:play-services-auth:19.0.0'

    // Firebase SDK
    implementation platform('com.google.firebase:firebase-bom:26.6.0')
    implementation 'com.google.firebase:firebase-database-ktx'
    implementation 'com.google.firebase:firebase-storage-ktx'
    implementation 'com.google.firebase:firebase-auth-ktx'

    // Firebase UI Library
    implementation 'com.firebaseui:firebase-ui-auth:7.2.0'
    implementation 'com.firebaseui:firebase-ui-database:7.2.0'
}

3. התקן את Firebase CLI

על מנת להפעיל את Suite Emulator Firebase , אתה צריך להתקין ולהפעיל את Firebase CLI .

התקן את ה-CLI

אפשרות 1 - התקנה עם npm

אם כבר התקנת את Node.js ו-npm במחשב שלך, תוכל להתקין את ה-CLI עם הפקודה הבאה:

npm install -g firebase-tools@latest

אפשרות 2 - התקן בינארי עצמאי

אם אתה לא צריך Node.js / NPM או איננו מכיר את פיתוח אפליקציה, תוכל להתקין את CLI כמו בינארי עצמאי בעקבות ההוראות לפלטפורמה שלך כאן .

בדוק את ההתקנה

ברגע שיש לך את Firebase CLI מותקן, להריץ את הפקודה הבאה כדי לוודא שיש לך גרסה 9.11.0 ומעלה:

firebase --version

4. התחבר ל-Firebase Emulator Suite

הפעל את האמולטורים

בטרמינל שלך, הפעל את הפקודה הבאה משורש המקומי codelab-friendlychat-android בספרייה:

firebase emulators:start --project=demo-friendlychat-android

אתה אמור לראות כמה יומנים כאלה. ערכי היציאה הוגדרו firebase.json הקובץ, אשר נכלל בקוד לדוגמא המשובט.

$ firebase emulators:start --project=demo-friendlychat-android
i  emulators: Starting emulators: auth, database, storage
i  emulators: Detected demo project ID "demo-friendlychat-android", emulated services will use a demo configuration and attempts to access non-emulated services for this project will fail.
i  database: Database Emulator logging to database-debug.log
i  ui: Emulator UI logging to ui-debug.log

┌─────────────────────────────────────────────────────────────┐
│ ✔  All emulators ready! It is now safe to connect your app. │
│ i  View Emulator UI at http://localhost:4000                │
└─────────────────────────────────────────────────────────────┘

┌────────────────┬────────────────┬────────────────────────────────┐
│ Emulator       │ Host:Port      │ View in Emulator UI            │
├────────────────┼────────────────┼────────────────────────────────┤
│ Authentication │ localhost:9099 │ http://localhost:4000/auth     │
├────────────────┼────────────────┼────────────────────────────────┤
│ Database       │ localhost:9000 │ http://localhost:4000/database │
├────────────────┼────────────────┼────────────────────────────────┤
│ Storage        │ localhost:9199 │ http://localhost:4000/storage  │
└────────────────┴────────────────┴────────────────────────────────┘
  Emulator Hub running at localhost:4400
  Other reserved ports: 4500

Issues? Report them at https://github.com/firebase/firebase-tools/issues and attach the *-debug.log files.

נווט אל http: // localhost: 4000 בדפדפן האינטרנט שלך כדי להציג את ממשק המשתמש Suite Emulator Firebase:

Emulator Suite UI בית

השאירו את emulators:start את הפעלת פקודה עבור שאר codelab.

חבר את האפליקציה שלך

בשנת סטודיו אנדרואיד, פתוח MainActivity.kt , ולאחר מכן להוסיף את הקוד הבא בתוך onCreate השיטה:

// When running in debug mode, connect to the Firebase Emulator Suite.
// "10.0.2.2" is a special IP address which allows the Android Emulator
// to connect to "localhost" on the host computer. The port values (9xxx)
// must match the values defined in the firebase.json file.
if (BuildConfig.DEBUG) {
    Firebase.database.useEmulator("10.0.2.2", 9000)
    Firebase.auth.useEmulator("10.0.2.2", 9099)
    Firebase.storage.useEmulator("10.0.2.2", 9199)
}

5. הפעל את אפליקציית המתנע

הוסף את google-services.json

כדי שהאפליקציה אנדרואיד שלך להתחבר Firebase, אתה חייב להוסיף google-services.json קובץ בתוך app התיקייה של פרויקט Android שלך. למטרות מעבדת קוד זה, סיפקנו קובץ JSON מדומה שיאפשר לך להתחבר ל-Firebase Emulator Suite.

העתק את mock-google-services.json קובץ לתוך build-android-start/app תיקייה כמו google-services.json :

cp mock-google-services.json build-android-start/app/google-services.json

בשלב האחרון של מעבדת הקוד הזה, תלמד כיצד ליצור פרויקט Firebase אמיתי ואפליקציית Firebase Android כך שתוכל להחליף את קובץ ה-JSON המדומה הזה בתצורה משלך.

הפעל את האפליקציה

כעת, לאחר שייבאת את הפרויקט ל-Android Studio והוספת קובץ JSON לתצורת Firebase, אתה מוכן להפעיל את האפליקציה בפעם הראשונה.

  1. הפעל את אמולטור האנדרואיד שלך.
  2. בשנת סטודיו אנדרואיד, לחץ על הפעלה (לבצע ) בסרגל הכלים.

האפליקציה אמורה להפעיל באמולטור אנדרואיד שלך. בשלב זה, אתה אמור לראות רשימת הודעות ריקה, ושליחה וקבלה של הודעות לא יפעלו. בשלב הבא של מעבדת הקוד הזה, תאמת משתמשים כדי שיוכלו להשתמש ב-Friendly Chat.

6. הפעל אימות

אפליקציה זו תשתמש ב-Firebase Realtime Database כדי לאחסן את כל הודעות הצ'אט. עם זאת, לפני שנוסיף נתונים, עלינו לוודא שהאפליקציה מאובטחת ושרק משתמשים מאומתים יכולים לפרסם הודעות. בשלב זה, נפעיל את אימות Firebase ונקבע את כללי האבטחה של מסדי נתונים בזמן אמת.

הוסף פונקציונליות כניסה בסיסית

בשלב הבא נוסיף קוד אימות Firebase בסיסי לאפליקציה כדי לזהות משתמשים וליישם מסך כניסה.

בדוק את המשתמש הנוכחי

ראשית להוסיף את המשתנה למשל הבאים אל MainActivity.kt בכיתה:

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

עכשיו בואו לשנות MainActivity לשלוח את המשתמש במסך הכניסה בכל פעם שהם פותחים את האפליקציה הם לא מאומתת. מוסיפים את הבאה אל onCreate() שיטה לאחר binding מצורפת הנוף:

MainActivity.kt

// Initialize Firebase Auth and check if the user is signed in
auth = Firebase.auth
if (auth.currentUser == null) {
    // Not signed in, launch the Sign In activity
    startActivity(Intent(this, SignInActivity::class.java))
    finish()
    return
}

אנחנו גם רוצים לבדוק אם המשתמש מחובר במהלך onStart() :

MainActivity.kt

public override fun onStart() {
    super.onStart()
    // Check if user is signed in.
    if (auth.currentUser == null) {
        // Not signed in, launch the Sign In activity
        startActivity(Intent(this, SignInActivity::class.java))
        finish()
        return
    }
}

ואז ליישם את getUserPhotoUrl() ו getUserName() שיטות להחזיר את המידע המתאים על המשתמש Firebase המאומת כעת:

MainActivity.kt

private fun getPhotoUrl(): String? {
    val user = auth.currentUser
    return user?.photoUrl?.toString()
}

private fun getUserName(): String? {
    val user = auth.currentUser
    return if (user != null) {
        user.displayName
    } else ANONYMOUS
}

ואז ליישם את signOut() שיטה להתמודד על הלחצן יציאה:

MainActivity.kt

private fun signOut() {
    AuthUI.getInstance().signOut()
    startActivity(Intent(this, SignInActivity::class.java))
    finish()
}

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

יישם את מסך הכניסה

פתח את הקובץ SignInActivity.kt . כאן נעשה שימוש בלחצן כניסה פשוט להפעלת אימות. בסעיף זה, תשתמש ב-FirebaseUI כדי ליישם את ההיגיון לכניסה.

הוספת משתנה למשל המחבר את SignInActivity ייצוגית לפי // Firebase instance variables תגובה:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

ואז, לערוך את onCreate() שיטה לאתחל Firebase באותו אופן שעשית MainActivity :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

הוסף ActivityResultLauncher שדה SignInActivity :

SignInActivity.kt

// ADD THIS
private val signIn: ActivityResultLauncher<Intent> =
        registerForActivityResult(FirebaseAuthUIActivityResultContract(), this::onSignInResult)

override fun onCreate(savedInstanceState: Bundle?) {
    // ...
}

הבא, ערוך את onStart() השיטה לבעוט את שלט FirebaseUI בזרימה:

SignInActivity.kt

public override fun onStart() {
    super.onStart()

    // If there is no signed in user, launch FirebaseUI
    // Otherwise head to MainActivity
    if (Firebase.auth.currentUser == null) {
        // Sign in with FirebaseUI, see docs for more details:
        // https://firebase.google.com/docs/auth/android/firebaseui
        val signInIntent = AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setLogo(R.mipmap.ic_launcher)
                .setAvailableProviders(listOf(
                        AuthUI.IdpConfig.EmailBuilder().build(),
                        AuthUI.IdpConfig.GoogleBuilder().build(),
                ))
                .build()

        signIn.launch(signInIntent)
    } else {
        goToMainActivity()
    }
}

הבא, ליישם את onSignInResult לשיטה שתטפל שלט התוצאה. אם התוצאה של signin הייתה מוצלחת, ממשיך MainActivity :

SignInActivity.kt

private fun onSignInResult(result: FirebaseAuthUIAuthenticationResult) {
    if (result.resultCode == RESULT_OK) {
        Log.d(TAG, "Sign in successful!")
        goToMainActivity()
    } else {
        Toast.makeText(
                this,
                "There was an error signing in",
                Toast.LENGTH_LONG).show()

        val response = result.idpResponse
        if (response == null) {
            Log.w(TAG, "Sign in canceled")
        } else {
            Log.w(TAG, "Sign in error", response.error)
        }
    }
}

זהו זה! הטמעת אימות עם FirebaseUI בכמה קריאות שיטה בלבד וללא צורך בניהול כל תצורה בצד השרת.

בדוק את העבודה שלך

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

לאחר הכניסה, פתח את Firebase Emulator Suite UI בדפדפן שלך, ולאחר מכן לחץ על כרטיסיית האימות כדי לראות שנכנס לראשונה זה חשבון משתמש.

7. קרא הודעות

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

ייבא הודעות לדוגמה

  1. בממשק משתמש Suite Emulator Firebase, בחר בכרטיסיית מסד זמן האמת.
  2. גרור ושחרר את initial_messages.json קובץ העותק המקומי של מאגר codelab לתוך נתונים הצופה.

כעת אתה אמור להיות כמה הודעות תחת messages הצומת של מסד הנתונים.

קרא נתונים

סנכרן הודעות

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

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

MainActivity.kt

// Firebase instance variables
// ...
private lateinit var db: FirebaseDatabase
private lateinit var adapter: FriendlyMessageAdapter

שינוי של MainActivity שלך onCreate() שיטה תחת ההערה // Initialize Realtime Database and FirebaseRecyclerAdapter עם הקוד כהגדרתו להלן. קוד זה מוסיף את כל ההודעות הקיימות ממסד נתונים בזמן אמת ולאחר מכן מאזין ערכים ילד חדש תחת messages הנתיב מסד זמן אמת Firebase שלך. זה מוסיף אלמנט חדש לממשק המשתמש עבור כל הודעה:

MainActivity.kt

// Initialize Realtime Database
db = Firebase.database
val messagesRef = db.reference.child(MESSAGES_CHILD)

// The FirebaseRecyclerAdapter class and options come from the FirebaseUI library
// See: https://github.com/firebase/FirebaseUI-Android
val options = FirebaseRecyclerOptions.Builder<FriendlyMessage>()
    .setQuery(messagesRef, FriendlyMessage::class.java)
    .build()
adapter = FriendlyMessageAdapter(options, getUserName())
binding.progressBar.visibility = ProgressBar.INVISIBLE
manager = LinearLayoutManager(this)
manager.stackFromEnd = true
binding.messageRecyclerView.layoutManager = manager
binding.messageRecyclerView.adapter = adapter

// Scroll down when a new message arrives
// See MyScrollToBottomObserver for details
adapter.registerAdapterDataObserver(
    MyScrollToBottomObserver(binding.messageRecyclerView, adapter, manager)
)

הבא FriendlyMessageAdapter.kt בכיתה ליישם את bind() שיטה בתוך הכיתה הפנימי MessageViewHolder() :

FriendlyMessageAdapter.kt

inner class MessageViewHolder(private val binding: MessageBinding) : ViewHolder(binding.root) {
    fun bind(item: FriendlyMessage) {
        binding.messageTextView.text = item.text
        setTextColor(item.name, binding.messageTextView)

        binding.messengerTextView.text = if (item.name == null) ANONYMOUS else item.name
        if (item.photoUrl != null) {
            loadImageIntoView(binding.messengerImageView, item.photoUrl!!)
        } else {
            binding.messengerImageView.setImageResource(R.drawable.ic_account_circle_black_36dp)
        }
    }
    ...
}

אנחנו גם צריכים להציג הודעות שאינן תמונות, כך גם ליישם את bind() השיטה בתוך הכיתה הפנימית ImageMessageViewHolder() :

FriendlyMessageAdapter.kt

inner class ImageMessageViewHolder(private val binding: ImageMessageBinding) :
    ViewHolder(binding.root) {
    fun bind(item: FriendlyMessage) {
        loadImageIntoView(binding.messageImageView, item.imageUrl!!)

        binding.messengerTextView.text = if (item.name == null) ANONYMOUS else item.name
        if (item.photoUrl != null) {
            loadImageIntoView(binding.messengerImageView, item.photoUrl!!)
        } else {
            binding.messengerImageView.setImageResource(R.drawable.ic_account_circle_black_36dp)
        }
    }
}

לבסוף, חוזר MainActivity , להתחיל ולהפסיק להאזין עדכונים מ- Database Firebase זמן אמת. עדכן את onPause() ו onResume() שיטות MainActivity כמוצג להלן:

MainActivity.kt

public override fun onPause() {
    adapter.stopListening()
    super.onPause()
}

public override fun onResume() {
    super.onResume()
    adapter.startListening()
}

בדוק סנכרון הודעות

  1. לחץ Run (לבצע ).
  2. בממשק המשתמש Suite Emulator, לחזור ללשונית מסד זמן אמת, אז באופן ידני להוסיף הודעה חדשה. אשר שההודעה מופיעה באפליקציית Android שלך:

מזל טוב, זה עתה הוספת מסד נתונים בזמן אמת לאפליקציה שלך!

8. שלח הודעות

יישום שליחת הודעות טקסט

בחלק זה, תוסיף את היכולת של משתמשי האפליקציה לשלוח הודעות טקסט. קטע הקוד מתחת מאזין אירועים לחצו על כפתור השליחה, יוצר חדש FriendlyMessage אובייקט עם התוכן של שדה ההודעה, ודוחף את המסר למסד נתון. push() השיטה מוסיפה מזהה שנוצר באופן אוטומטי למסלול של אובייקט הדחף. המזהים האלה הם עוקבים מה שמבטיח שההודעות החדשות יתווספו לסוף הרשימה.

עדכן את המאזין בלחיצת כפתור השליחה onCreate() שיטה של MainActivity בכיתה. קוד זה הוא בחלק התחתון של onCreate() השיטה כבר. עדכן את onClick() הגוף כדי להתאים את הקוד הבא:

MainActivity.kt

// Disable the send button when there's no text in the input field
// See MyButtonObserver for details
binding.messageEditText.addTextChangedListener(MyButtonObserver(binding.sendButton))

// When the send button is clicked, send a text message
binding.sendButton.setOnClickListener {
    val friendlyMessage = FriendlyMessage(
        binding.messageEditText.text.toString(),
        getUserName(),
        getPhotoUrl(),
        null /* no image */
    )
    db.reference.child(MESSAGES_CHILD).push().setValue(friendlyMessage)
    binding.messageEditText.setText("")
}

יישום שליחת הודעת תמונה

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

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

בחר תמונה

כדי להוסיף תמונות מעבד קוד זה משתמש ב-Cloud Storage for Firebase. אחסון בענן הוא מקום טוב לאחסון הנתונים הבינאריים של האפליקציה שלך.

טפל בבחירת תמונה וכתוב הודעה זמנית

ברגע שהמשתמש שבחר תמונה, בחירת תמונת Intent משוגרות. זה כבר מיושם קוד בסוף של onCreate() שיטה. בסיום אותה מכנה MainActivity של onImageSelected() שיטה. באמצעות קטע הקוד למטה, תכתוב הודעה עם כתובת אתר של תמונה זמנית למסד הנתונים המציינת שהתמונה מועלית.

MainActivity.kt

private fun onImageSelected(uri: Uri) {
    Log.d(TAG, "Uri: $uri")
    val user = auth.currentUser
    val tempMessage = FriendlyMessage(null, getUserName(), getPhotoUrl(), LOADING_IMAGE_URL)
    db.reference
            .child(MESSAGES_CHILD)
            .push()
            .setValue(
                    tempMessage,
                    DatabaseReference.CompletionListener { databaseError, databaseReference ->
                        if (databaseError != null) {
                            Log.w(
                                    TAG, "Unable to write message to database.",
                                    databaseError.toException()
                            )
                            return@CompletionListener
                        }

                        // Build a StorageReference and then upload the file
                        val key = databaseReference.key
                        val storageReference = Firebase.storage
                                .getReference(user!!.uid)
                                .child(key!!)
                                .child(uri.lastPathSegment!!)
                        putImageInStorage(storageReference, uri, key)
                    })
}

העלה תמונה ועדכן הודעה

מוסיפים את שיטת putImageInStorage() כדי MainActivity . זה נקרא ב onImageSelected() כדי להפעיל את ההעלאה של התמונה הנבחרת. לאחר השלמת ההעלאה תעדכן את ההודעה כדי להשתמש בתמונה המתאימה.

MainActivity.kt

private fun putImageInStorage(storageReference: StorageReference, uri: Uri, key: String?) {
    // First upload the image to Cloud Storage
    storageReference.putFile(uri)
        .addOnSuccessListener(
            this
        ) { taskSnapshot -> // After the image loads, get a public downloadUrl for the image
            // and add it to the message.
            taskSnapshot.metadata!!.reference!!.downloadUrl
                .addOnSuccessListener { uri ->
                    val friendlyMessage =
                        FriendlyMessage(null, getUserName(), getPhotoUrl(), uri.toString())
                    db.reference
                        .child(MESSAGES_CHILD)
                        .child(key!!)
                        .setValue(friendlyMessage)
                }
        }
        .addOnFailureListener(this) { e ->
            Log.w(
                TAG,
                "Image upload task was unsuccessful.",
                e
            )
        }
}

בדיקת שליחת הודעות

  1. ב-Android Studio, לחץ עללבצע כפתור הפעלה.
  2. באמולטור אנדרואיד, הזן הודעה ולאחר מכן הקש על כפתור השליחה. ההודעה החדשה צריכה להיות גלויה בממשק המשתמש של האפליקציה ובממשק המשתמש של Firebase Emulator Suite.
  3. באמולטור אנדרואיד, הקש על תמונת "+" כדי לבחור תמונה מהמכשיר שלך. ההודעה החדשה צריכה להיות גלויה תחילה עם תמונת מציין מיקום, ולאחר מכן עם התמונה שנבחרה לאחר השלמת העלאת התמונה. ההודעה החדשה צריכה להיות גלויה גם ב-Emulator Suite UI, במיוחד כאובייקט בכרטיסייה Realtime Database וכבלוב בכרטיסייה Storage.

9. מזל טוב!

זה עתה בנית אפליקציית צ'אט בזמן אמת באמצעות Firebase!

מה שלמדת

  • אימות Firebase
  • מסד נתונים בזמן אמת של Firebase
  • אחסון בענן עבור Firebase

לאחר מכן, נסה להשתמש במה שלמדת במעבדת הקוד הזה כדי להוסיף את Firebase לאפליקציית Android משלך! כדי ללמוד עוד על Firebase, לבקר firebase.google.com .

אם אתה רוצה ללמוד איך להקים פרויקט אמיתי Firebase ולהשתמש במשאבי Firebase אמיתיים (במקום פרויקט הדגמה ומשאבים לחיקוי בלבד), המשך לשלב הבא.

הערה: גם לאחר הגדרת פרויקט אמיתי Firebase ובמיוחד כשאתה להתחיל בבניית אפליקציה אמיתית, אנו ממליצים להשתמש Suite Emulator Firebase המקומי עבור פיתוח ובדיקות.

10. אופציונלי: צור והגדר פרוייקט Firebase

בשלב זה, תיצור פרויקט Firebase אמיתי ואפליקציית Firebase ל-Android לשימוש עם מעבדת קוד זה. אתה גם תוסיף את תצורת Firebase הספציפית לאפליקציה שלך לאפליקציה שלך. ולבסוף, תגדיר משאבי Firebase אמיתיים לשימוש עם האפליקציה שלך.

צור פרויקט Firebase

  1. בדפדפן, עבור אל קונסולת Firebase .
  2. פרויקט בחרהוסף.
  3. בחר או הזן שם פרויקט. אתה יכול להשתמש בכל שם שאתה רוצה.
  4. אינך זקוק ל-Google Analytics עבור מעבדת הקוד הזה, אז אתה יכול לדלג על הפעלתו עבור הפרויקט שלך.
  5. לחץ על צור הפרויקט. כאשר הפרויקט שלכם מוכן, לחץ על המשך.

הוסף את Firebase לפרויקט Android שלך

לפני שתתחיל בשלב זה, קבל את ה-hash SHA1 של האפליקציה שלך. הפעל את הפקודה הבאה מתוך המקומי build-android-start ספרייה לקבוע את SHA1 של המפתח debug שלך:

./gradlew signingReport

Store: /Users/<username>/.android/debug.keystore
Alias: AndroidDebugKey
MD5: A5:88:41:04:8F:06:59:6A:AE:33:76:87:AA:AD:19:23
SHA1: A7:89:F5:06:A8:07:A1:22:EC:90:6A:A6:EA:C3:D4:8B:3A:30:AB:18
SHA-256: 05:A2:2A:35:EE:F2:51:23:72:4D:72:67:A5:6A:8A:58:22:2C:00:A6:AB:F6:45:D5:A1:82:D8:90:A4:69:C8:FE
Valid until: Wednesday, August 10, 2044

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

חזור למסוף Firebase ובצע את השלבים הבאים כדי לרשום את פרויקט ה-Android שלך בפרויקט Firebase שלך:

  1. ממסך הסקירה הכללית של הפרויקט החדש שלך, לחץ על סמל אנדרואיד כדי להפעיל את זרימת העבודה של ההגדרה: הוסף אפליקציית אנדרואיד
  2. במסך הבא, זן com.google.firebase.codelab.friendlychat לשם החבילה עבור האפליקציה שלך.
  3. לחץ לרשום את האפליקציה, ולאחר מכן לחץ על הורדה google-services.json להוריד קובץ התצורה Firebase שלך.
  4. העתק את google-services.json קובץ לתוך app ספרייה של פרויקט Android שלך.
  5. דלג על הצעדים הבאים המוצגים עבודת ההתקנה של הקונסולה (הם כבר נעשו בשבילך את build-android-start הפרויקט).
  6. ודא שכל התלות זמינה לאפליקציה שלך על ידי סנכרון הפרויקט שלך עם קבצי Gradle. מסרגל הכלים סטודיו אנדרואיד, בחר קובץ> סינכרון פרויקט עם Gradle קבצים.

הגדר את אימות Firebase

לפני שהאפליקציה שלך תוכל לגשת לממשקי ה-API של Firebase Authentication בשם המשתמשים שלך, עליך להפעיל את Firebase Authentication ואת ספקי הכניסה שבהם ברצונך להשתמש באפליקציה שלך.

  1. בשנות ה קונסולת Firebase , בחר אימות מלוח הניווט השמאלי.
  2. בחר כניסת כרטיסיית שיטה.
  3. לחץ דוא"ל / סיסמה, אז את המתג למצב מופעל (כחול).
  4. לחץ גוגל, אז את המתג למצב מופעל (כחול) ולהגדיר דוא"ל תמיכה בפרויקט.

אם אתה מקבל שגיאות מאוחר יותר במעבדת הקוד הזה עם ההודעה "CONFIGURATION_NOT_FOUND", חזור לשלב זה ובדוק שוב את עבודתך.

הגדר מסד נתונים בזמן אמת

האפליקציה במעבדת קוד זה מאחסנת הודעות צ'אט במסד הנתונים של Firebase Realtime. בסעיף זה, ניצור מסד נתונים ונקבע את האבטחה שלו באמצעות שפת תצורה של JSON הנקראת Firebase Security Rules.

  1. בשנות ה קונסולת Firebase , בחר Database זמן אמת מלוח הניווט השמאלי.
  2. לחץ ליצור מסד נתונים כדי ליצור מופע באתר בזמן אמת חדשות. כאשר תתבקש, בחר us-central1 באזור, ולאחר מכן לחץ על הבא.
  3. כאשר יתבקש על כללי ביטחון, לבחור במצב נעול, ולאחר מכן לחץ על Enable.
  4. לאחר המופע באתר נוצר, בחר את הכרטיסייה הכללית, ולאחר מכן לעדכן את תצורת הכללים עם הבאים:
     {
       "rules": {
         "messages": {
           ".read": "auth.uid != null",
           ".write": "auth.uid != null"
         }
       }
     }
    

לקבלת מידע נוסף על אופן עבודת כללי אבטחה (כולל תיעוד על משתנה "האימות"), לראות את תיעוד אבטחת מסד זמן האמת .

הגדר אחסון בענן עבור Firebase

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

התחבר למשאבי Firebase

בשלב מוקדם יותר של codelab זו, שהוספת את הצעדים הבאים לקבלת MainActivity.kt . הבלוק המותנה הזה חיבר את פרויקט האנדרואיד שלך ל-Firebase Emulator Suite.

// REMOVE OR DISABLE THIS
if (BuildConfig.DEBUG) {
    Firebase.database.useEmulator("10.0.2.2", 9000)
    Firebase.auth.useEmulator("10.0.2.2", 9099)
    Firebase.storage.useEmulator("10.0.2.2", 9199)
}

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