Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

Firebase Android Codelab - Bangun Obrolan Ramah

tangkapan layar

Gambar: Aplikasi Obrolan Ramah Kerja.

Selamat datang di codelab Obrolan Ramah. Dalam codelab ini, Anda akan mempelajari cara menggunakan platform Firebase untuk membuat aplikasi chat di Android.

Apa yang akan Anda pelajari?

  • Cara menggunakan Firebase Authentication untuk mengizinkan pengguna masuk.
  • Cara menyinkronkan data menggunakan Firebase Realtime Database.
  • Cara menyimpan file biner di Cloud Storage for Firebase.
  • Cara menggunakan Firebase Local Emulator Suite untuk mengembangkan aplikasi Android dengan Firebase.

Apa yang Anda butuhkan?

  • Android Studio versi 4.2.
  • Sebuah Emulator Android dengan Android 5.0+.
  • Java 7 atau lebih tinggi. Untuk menginstal Java menggunakan ini petunjuk ; untuk memeriksa versi Anda, jalankan java -version .
  • Familiar dengan bahasa pemrograman Kotlin.

Mengkloning repositori

Kloning repositori GitHub dari baris perintah:

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

Impor ke Android Studio

Di Android Studio, pilih File> Open, lalu pilih build-android-start direktori ( android_studio_folder ) dari direktori tempat Anda mengunduh kode sampel.

Anda sekarang harus memiliki build-android-start proyek open di Android Studio. Jika Anda melihat peringatan tentang google-services.json file yang hilang, tidak khawatir. Ini akan ditambahkan pada langkah selanjutnya.

Periksa dependensi

Dalam codelab ini semua dependensi yang Anda perlukan telah ditambahkan untuk Anda, tetapi penting untuk memahami cara menambahkan Firebase SDK ke aplikasi Anda:

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

Dalam rangka untuk menjalankan Firebase Emulator Suite , Anda perlu menginstal dan menggunakan Firebase CLI .

Instal CLI

Opsi 1 - Instal dengan npm

Jika Anda sudah menginstal Node.js dan npm di mesin Anda, Anda dapat menginstal CLI dengan perintah berikut:

npm install -g firebase-tools@latest

Opsi 2 - Instal biner mandiri

Jika Anda tidak memiliki Node.js / NPM atau Anda baru untuk pengembangan aplikasi, Anda dapat menginstal CLI sebagai biner mandiri mengikuti petunjuk untuk platform Anda di sini .

Periksa instalasi

Setelah Anda memiliki Firebase CLI diinstal, jalankan perintah berikut untuk memastikan Anda memiliki versi 9.11.0 atau lebih tinggi:

firebase --version

Mulai emulator

Di dalam terminal, jalankan perintah berikut dari akar lokal Anda codelab-friendlychat-android direktori:

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

Anda akan melihat beberapa log seperti ini. Nilai-nilai pelabuhan didefinisikan dalam firebase.json file, yang termasuk dalam kode contoh kloning.

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

Arahkan ke http: // localhost: 4000 di browser web Anda untuk melihat Firebase Emulator Suite UI:

Beranda UI Emulator Suite

Biarkan emulators:start perintah berjalan untuk sisa codelab tersebut.

Hubungkan aplikasi Anda

Di Android Studio, terbuka MainActivity.kt , kemudian tambahkan kode berikut di dalam onCreate metode:

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

Tambahkan google-services.json

Agar aplikasi Android Anda untuk terhubung ke Firebase, Anda harus menambahkan google-services.json file di dalam app folder proyek Android Anda. Untuk tujuan codelab ini, kami telah menyediakan file JSON tiruan yang memungkinkan Anda terhubung ke Firebase Emulator Suite.

Salin mock-google-services.json berkas ke dalam build-android-start/app folder sebagai google-services.json :

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

Pada langkah terakhir codelab ini, Anda akan mempelajari cara membuat proyek Firebase nyata dan Aplikasi Android Firebase sehingga Anda dapat mengganti file JSON tiruan ini dengan konfigurasi Anda sendiri.

Jalankan aplikasinya

Sekarang setelah Anda mengimpor proyek ke Android Studio dan menambahkan file JSON konfigurasi Firebase, Anda siap menjalankan aplikasi untuk pertama kalinya.

  1. Mulai Emulator Android Anda.
  2. Di Android Studio, klik Run (menjalankan ) di bilah alat.

Aplikasi harus diluncurkan di Emulator Android Anda. Pada titik ini, Anda akan melihat daftar pesan kosong, dan mengirim dan menerima pesan tidak akan berfungsi. Pada langkah berikutnya dari codelab ini, Anda akan mengautentikasi pengguna sehingga mereka dapat menggunakan Obrolan Ramah.

Aplikasi ini akan menggunakan Firebase Realtime Database untuk menyimpan semua pesan chat. Namun, sebelum menambahkan data, kita harus memastikan bahwa aplikasi tersebut aman dan hanya pengguna yang diautentikasi yang dapat memposting pesan. Pada langkah ini, kita akan mengaktifkan Firebase Authentication dan mengonfigurasi Aturan Keamanan Realtime Database.

Tambahkan fungsi masuk dasar

Selanjutnya kita akan menambahkan beberapa kode Firebase Authentication dasar ke aplikasi untuk mendeteksi pengguna dan mengimplementasikan layar login.

Periksa pengguna saat ini

Pertama menambahkan variabel contoh berikut untuk MainActivity.kt kelas:

Aktivitas Utama.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Sekarang mari kita memodifikasi MainActivity untuk mengirim pengguna untuk masuk layar setiap kali mereka membuka aplikasi dan tidak berkepentingan. Menambahkan berikut ke onCreate() metode setelah binding melekat tampilan:

Aktivitas Utama.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
}

Kami juga ingin memeriksa apakah pengguna masuk selama onStart() :

Aktivitas Utama.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
    }
}

Kemudian menerapkan getUserPhotoUrl() dan getUserName() metode untuk mengembalikan informasi yang tepat tentang pengguna Firebase saat dikonfirmasi:

Aktivitas Utama.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
}

Kemudian menerapkan signOut() metode untuk menangani tanda tombol keluar:

Aktivitas Utama.kt

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

Sekarang kami memiliki semua logika untuk mengirim pengguna ke layar masuk bila perlu. Selanjutnya kita perlu menerapkan layar masuk untuk mengautentikasi pengguna dengan benar.

Terapkan layar Masuk

Buka file SignInActivity.kt . Di sini tombol Sign-In sederhana digunakan untuk memulai otentikasi. Di bagian ini, Anda akan menggunakan FirebaseUI untuk mengimplementasikan logika untuk masuk.

Menambahkan variabel contoh Tupoksi di SignInActivity kelas bawah // Firebase instance variables komentar:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Kemudian, edit onCreate() metode untuk menginisialisasi Firebase dengan cara yang sama Anda lakukan di MainActivity :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Tambahkan ActivityResultLauncher lapangan untuk SignInActivity :

SignInActivity.kt

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

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

Berikutnya, edit onStart() metode untuk memulai FirebaseUI tanda aliran:

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

Berikutnya, menerapkan onSignInResult metode untuk menangani tanda dalam hasil. Jika hasil dari proses masuk berhasil, terus 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)
        }
    }
}

Itu dia! Anda telah menerapkan autentikasi dengan FirebaseUI hanya dalam beberapa panggilan metode dan tanpa perlu mengelola konfigurasi sisi server apa pun.

Uji pekerjaan Anda

Jalankan aplikasi di Emulator Android Anda. Anda akan segera diarahkan ke layar masuk. Tekan Masuk dengan tombol email, kemudian membuat account. Jika semuanya diterapkan dengan benar, Anda akan diarahkan ke layar pesan.

Setelah masuk, buka Firebase Emulator Suite UI di browser Anda, kemudian klik tab Authentication untuk melihat ini pertama kali ditandatangani-in account pengguna.

Pada langkah ini, kita akan menambahkan fungsionalitas untuk membaca dan menampilkan pesan yang tersimpan di Realtime Database.

Impor pesan contoh

  1. Dalam Firebase Emulator Suite UI, pilih Realtime tab Database.
  2. Drag dan drop initial_messages.json file dari salinan lokal Anda dari repositori codelab ke penampil data.

Anda sekarang harus memiliki beberapa pesan di bawah messages simpul dari database.

Baca data

Sinkronkan pesan

Di bagian ini kami menambahkan kode yang menyinkronkan pesan yang baru ditambahkan ke UI aplikasi dengan:

  • Menginisialisasi Firebase Realtime Database dan menambahkan listener untuk menangani perubahan yang dibuat pada data.
  • Memperbarui RecyclerView adaptor sehingga pesan baru akan ditampilkan.
  • Menambahkan variabel database instance dengan instance variable lainnya Firebase di MainActivity kelas:

Aktivitas Utama.kt

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

Memodifikasi MainActivity Anda onCreate() metode di bawah komentar // Initialize Realtime Database and FirebaseRecyclerAdapter dengan kode didefinisikan di bawah. Kode ini menambahkan semua pesan yang ada dari Realtime database dan kemudian mendengarkan masukan anak baru di bawah messages path di Anda Firebase Realtime Database. Itu menambahkan elemen baru ke UI untuk setiap pesan:

Aktivitas Utama.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)
)

Berikutnya di FriendlyMessageAdapter.kt kelas mengimplementasikan bind() metode dalam kelas batin MessageViewHolder() :

Pesan RamahAdapter.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)
        }
    }
    ...
}

Kita juga perlu menampilkan pesan yang gambar, sehingga juga melaksanakan bind() metode dalam kelas batin 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)
        }
    }
}

Akhirnya, kembali MainActivity , memulai dan berhenti mendengarkan pembaruan dari Firebase Realtime Database. Update onPause() dan onResume() metode dalam MainActivity seperti yang ditunjukkan di bawah ini:

Aktivitas Utama.kt

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

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

Uji sinkronisasi pesan

  1. Klik Run (menjalankan ).
  2. Dalam Emulator Suite UI, kembali ke Realtime database tab, kemudian secara manual menambahkan pesan baru. Konfirmasikan bahwa pesan muncul di aplikasi Android Anda:

Selamat, Anda baru saja menambahkan database waktu nyata ke aplikasi Anda!

Terapkan pengiriman pesan teks

Di bagian ini, Anda akan menambahkan kemampuan bagi pengguna aplikasi untuk mengirim pesan teks. Potongan kode di bawah ini mendengarkan untuk klik peristiwa pada tombol send, menciptakan baru FriendlyMessage objek dengan isi kolom pesan, dan mendorong pesan ke database. The push() metode menambahkan ID otomatis dihasilkan untuk jalur objek mendorong ini. ID ini berurutan yang memastikan bahwa pesan baru akan ditambahkan ke akhir daftar.

Update pendengar klik tombol kirim dalam onCreate() metode dalam MainActivity kelas. Kode ini adalah di bagian bawah onCreate() metode sudah. Update onClick() tubuh untuk mencocokkan kode di bawah ini:

Aktivitas Utama.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("")
}

Terapkan pengiriman pesan gambar

Di bagian ini, Anda akan menambahkan kemampuan bagi pengguna aplikasi untuk mengirim pesan gambar. Membuat pesan gambar dilakukan dengan langkah-langkah ini:

  • Pilih gambar
  • Menangani pemilihan gambar
  • Tulis pesan gambar sementara ke Realtime Database
  • Mulai unggah gambar yang dipilih
  • Perbarui URL pesan gambar ke gambar yang diunggah, setelah pengunggahan selesai

Pilih gambar

Untuk menambahkan gambar codelab ini menggunakan Cloud Storage for Firebase. Cloud Storage adalah tempat yang baik untuk menyimpan data biner aplikasi Anda.

Tangani pemilihan gambar dan tulis pesan sementara

Setelah pengguna telah memilih gambar, pemilihan gambar Intent diluncurkan. Ini sudah diimplementasikan dalam kode di akhir onCreate() metode. Setelah selesai itu menyebut MainActivity 's onImageSelected() metode. Dengan menggunakan cuplikan kode di bawah ini, Anda akan menulis pesan dengan url gambar sementara ke database yang menunjukkan bahwa gambar sedang diunggah.

Aktivitas Utama.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)
                    })
}

Unggah gambar dan perbarui pesan

Menambahkan metode putImageInStorage() ke MainActivity . Hal ini disebut dalam onImageSelected() untuk memulai upload gambar yang dipilih. Setelah pengunggahan selesai, Anda akan memperbarui pesan untuk menggunakan gambar yang sesuai.

Aktivitas Utama.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
            )
        }
}

Uji pengiriman pesan

  1. Di Android Studio, klik tombolmenjalankan Tombol Run.
  2. Di Emulator Android Anda, masukkan pesan, lalu ketuk tombol kirim. Pesan baru harus terlihat di UI aplikasi dan di UI Firebase Emulator Suite.
  3. Di Android Emulator, ketuk gambar "+" untuk memilih gambar dari perangkat Anda. Pesan baru harus terlihat terlebih dahulu dengan gambar placeholder, lalu dengan gambar yang dipilih setelah pengunggahan gambar selesai. Pesan baru juga harus terlihat di UI Emulator Suite, khususnya sebagai objek di tab Realtime Database dan sebagai blob di tab Storage.

Anda baru saja membuat aplikasi chat real-time menggunakan Firebase!

Apa yang Anda pelajari?

  • Otentikasi Firebase
  • Basis Data Waktu Nyata Firebase
  • Penyimpanan Cloud untuk Firebase

Selanjutnya, coba gunakan apa yang Anda pelajari di codelab ini untuk menambahkan Firebase ke aplikasi Android Anda sendiri! Untuk mempelajari lebih lanjut tentang Firebase, kunjungi firebase.google.com .

Jika Anda ingin belajar bagaimana untuk mendirikan sebuah proyek Firebase nyata dan menggunakan sumber daya nyata Firebase (bukan proyek demo dan sumber daya hanya ditiru), lanjutkan ke langkah berikutnya.

Catatan: Bahkan setelah Anda membuat sebuah proyek Firebase nyata dan terutama ketika Anda memulai membangun aplikasi nyata, kami sarankan menggunakan Firebase lokal Emulator Suite untuk pengembangan dan pengujian.

Pada langkah ini, Anda akan membuat proyek Firebase nyata dan Aplikasi Android Firebase untuk digunakan dengan codelab ini. Anda juga akan menambahkan konfigurasi Firebase khusus aplikasi ke aplikasi Anda. Dan terakhir, Anda akan menyiapkan sumber daya Firebase nyata untuk digunakan dengan aplikasi Anda.

Buat proyek Firebase

  1. Dalam browser Anda, pergi ke konsol Firebase .
  2. Pilih Tambah proyek.
  3. Pilih atau masukkan nama proyek. Anda dapat menggunakan nama apa pun yang Anda inginkan.
  4. Anda tidak memerlukan Google Analytics untuk codelab ini, jadi Anda dapat melewati pengaktifannya untuk proyek Anda.
  5. Klik Buat Proyek. Ketika proyek Anda siap, klik Lanjutkan.

Tambahkan Firebase ke proyek Android Anda

Sebelum Anda memulai langkah ini, dapatkan hash SHA1 dari aplikasi Anda. Jalankan perintah berikut dari lokal Anda build-android-start direktori untuk menentukan SHA1 kunci 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

Anda akan melihat beberapa output seperti di atas. Garis penting adalah SHA1 hash. Jika Anda tidak dapat menemukan hash SHA1, lihat halaman ini untuk informasi lebih lanjut.

Kembali ke Firebase console, dan ikuti langkah-langkah berikut untuk mendaftarkan proyek Android Anda dengan proyek Firebase Anda:

  1. Dari layar ikhtisar proyek baru Anda, klik ikon Android untuk meluncurkan alur kerja penyiapan:tambahkan aplikasi android
  2. Pada layar berikutnya, masukkan com.google.firebase.codelab.friendlychat sebagai nama paket untuk aplikasi Anda.
  3. Klik Register App, lalu klik Download google-services.json untuk men-download file konfigurasi Firebase Anda.
  4. Salin google-services.json file ke dalam app direktori proyek Android Anda.
  5. Lewati langkah selanjutnya ditampilkan dalam alur kerja setup konsol (mereka sudah pernah dilakukan untuk Anda dalam build-android-start proyek).
  6. Pastikan semua dependensi tersedia untuk aplikasi Anda dengan menyinkronkan proyek Anda dengan file Gradle. Dari Android Studio toolbar, pilih File> Sync Proyek dengan Gradle Files.

Konfigurasikan Firebase Authentication

Sebelum aplikasi Anda dapat mengakses Firebase Authentication API atas nama pengguna, Anda harus mengaktifkan Firebase Authentication dan penyedia login yang ingin digunakan di aplikasi Anda.

  1. Dalam Firebase konsol , pilih Authentication dari panel navigasi kiri-side.
  2. Pilih Sign-in tab metode.
  3. Klik Email / Password, kemudian beralih beralih ke diaktifkan (biru).
  4. Klik Google, kemudian beralih beralih ke diaktifkan (biru) dan menetapkan email dukungan proyek.

Jika nanti Anda mendapatkan kesalahan dalam codelab ini dengan pesan "CONFIGURATION_NOT_FOUND", kembali ke langkah ini dan periksa kembali pekerjaan Anda.

Konfigurasikan Basis Data Waktu Nyata

Aplikasi di codelab ini menyimpan pesan chat di Firebase Realtime Database. Di bagian ini, kita akan membuat database dan mengonfigurasi keamanannya melalui bahasa konfigurasi JSON yang disebut Aturan Keamanan Firebase.

  1. Dalam Firebase konsol , pilih Realtime database dari panel navigasi kiri-side.
  2. Klik Buat Database untuk membuat Realtime database contoh baru. Bila diminta, pilih us-central1 wilayah, kemudian klik Berikutnya.
  3. Ketika diminta tentang aturan keamanan, pilih mode terkunci, kemudian klik Aktifkan.
  4. Setelah contoh database telah dibuat, pilih tab Aturan, kemudian memperbarui konfigurasi aturan dengan:
     {
       "rules": {
         "messages": {
           ".read": "auth.uid != null",
           ".write": "auth.uid != null"
         }
       }
     }
    

Untuk informasi lebih lanjut tentang bagaimana Aturan Keamanan kerja (termasuk dokumentasi pada variabel "auth"), lihat Realtime dokumentasi keamanan database .

Konfigurasi Cloud Storage untuk Firebase

  1. Dalam Firebase konsol , pilih Storage dari panel navigasi kiri-side.
  2. Klik Memulai untuk mengaktifkan Cloud Storage untuk proyek Anda.
  3. Ikuti langkah-langkah dalam dialog untuk menyiapkan keranjang Anda, menggunakan default yang disarankan.

Hubungkan ke sumber daya Firebase

Dalam langkah awal dari codelab ini, Anda menambahkan berikut untuk MainActivity.kt . Blok bersyarat ini menghubungkan proyek Android Anda ke 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)
}

Jika Anda ingin menghubungkan aplikasi Anda untuk proyek baru Anda nyata Firebase dan sumber daya nyata Firebase, Anda juga dapat menghapus blok ini atau menjalankan aplikasi Anda dalam modus rilis sehingga BuildConfig.DEBUG adalah false .