Check out what’s new from Firebase@ Google I/O 2021, and join our alpha program for early access to the new Remote Config personalization feature. Learn more

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

צילום מסך

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

ברוך הבא ל- codelab צ'אט ידידותי. במפתח קוד זה תלמד כיצד להשתמש בפלטפורמת Firebase ליצירת אפליקציית צ'אט באנדרואיד.

מה תלמד

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

מה אתה צריך

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

שיבט את המאגר

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

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

ייבא ל- Android Studio

ב- Android Studio בחרו File > Open ואז בחרו בספריית build-android-start ( תיקיית אנדרואיד_סטודיו ) מהספרייה בה הורדת את קוד הדוגמה.

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

בדוק תלות

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

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

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

// Apply the 'google-services' plugin
apply plugin: 'com.google.gms.google-services'

על מנת להפעיל את Firebase Emulator Suite , עליך להתקין ולהשתמש ב- 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 המקומית 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 בדפדפן האינטרנט שלך כדי להציג את ממשק המשתמש של Firebase Emulator Suite:

ממשק משתמש ביתי של חבילת אמולטור

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

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

ב- Android Studio, פתח את 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

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

העתק את 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 App, כך שתוכל להחליף את קובץ ה- JSON הלעג הזה בתצורה משלך.

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

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

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

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

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

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

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

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

ראשית הוסף את המשתנה המופע הבא למחלקה MainActivity.kt :

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

עכשיו בואו MainActivity את 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 כדי ליישם את ההיגיון בכניסה.

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

בדוק את עבודתך

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

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

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

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

  1. בממשק המשתמש של Firebase Emulator Suite, בחר בכרטיסיית מסד נתונים בזמן אמת .
  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

שנה את שיטת onCreate() של MainActivity תחת התגובה // 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 , התחל MainActivity להקשיב לעדכונים ממאגר המידע בזמן אמת של Firebase. עדכן את onPause() ו- onResume() ב- MainActivity כמוצג להלן:

MainActivity.kt

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

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

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

  1. לחץ על הפעלה (לבצע ).
  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("")
}

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

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

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

בחר תמונה

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

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

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

MainActivity.kt

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    Log.d(TAG, "onActivityResult: requestCode=$requestCode, resultCode=$resultCode")
    if (requestCode == REQUEST_IMAGE) {
        if (resultCode == RESULT_OK && data != null) {
            val uri = data.data
            Log.d(TAG, "Uri: " + uri.toString())
            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 . זה נקרא onActivityResult() כדי להתחיל בהעלאת התמונה שנבחרה. לאחר השלמת ההעלאה תעדכן את ההודעה לשימוש בתמונה המתאימה.

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

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

מה שלמדת

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

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

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

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

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

צור פרויקט Firebase

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

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

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

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

אתה אמור לראות קצת פלט כמו לעיל. הקו החשוב הוא ה- Hash של 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. מסרגל הכלים של Android Studio, בחר קובץ > סנכרן פרויקט עם קבצי Gradle .

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

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

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

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

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

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

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

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

הגדר תצורה של אחסון ענן עבור Firebase

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

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

בשלב קודם של קוד קוד זה הוספת את הדברים הבאים ל- MainActivity.kt . חסם מותנה זה חיבר את פרויקט Android שלך לחבילת האמולטור של 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 .