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

צילום מסך

תמונה: אפליקציית צ'אט ידידותית לעבודה.

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

מה תלמד

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

מה אתה צריך

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

שיבוט את המאגר

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

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

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

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

כעת אתה אמור לקבל את 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'
}

על מנת להפעיל את 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

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

בטרמינל שלך, הפעל את הפקודה הבאה משורש המקומי 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:

בית ממשק משתמש אמולטור סוויטה

השאירו את 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)
}

הוסף google-services.json

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

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

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

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

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

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

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

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

יישום זה ישתמש במסד הנתונים בזמן אמת של Firebase לאחסון כל הודעות הצ'אט. אך לפני שנוסיף נתונים, עלינו לוודא שהאפליקציה מאובטחת וכי רק משתמשים מאומתים יכולים לפרסם הודעות. בשלב זה נאפשר את אימות 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 בדפדפן שלך, ולאחר מכן לחץ על כרטיסיית האימות כדי לראות שנכנס לראשונה זה חשבון משתמש.

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

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

  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 שלך:

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

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

בחלק זה, תוסיף את היכולת של משתמשי האפליקציה לשלוח הודעות טקסט. קטע הקוד מתחת מאזין אירועים לחצו על כפתור השליחה, יוצר חדש 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("")
}

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

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

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

בחר תמונה

כדי להוסיף תמונות, codelab זה משתמש באחסון ענן עבור 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. במאמן Android שלך, הזן הודעה ולאחר מכן הקש על כפתור השליחה. ההודעה החדשה צריכה להיות גלויה בממשק המשתמש של האפליקציה ובממשק המשתמש של Firebase Emulator Suite.
  3. באמולטור Android, הקש על תמונת "+" כדי לבחור תמונה מהמכשיר שלך. ההודעה החדשה צריכה להיות גלויה תחילה עם תמונת מציין מקום, ולאחר מכן עם התמונה שנבחרה לאחר השלמת העלאת התמונה. ההודעה החדשה אמורה להיות גלויה גם בממשק המשתמש של Emulator Suite, במיוחד כאובייקט בכרטיסייה מסד נתונים בזמן אמת וכבלוק בכרטיסייה אחסון.

רק בנית יישום צ'אט בזמן אמת באמצעות Firebase!

מה שלמדת

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

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

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

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

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

צור פרויקט Firebase

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

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

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

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

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

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

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

  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 . בלוק מותנה זה חיבר את פרויקט ה- Android שלך לחבילת Emulator של Firebase.

// 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 .