Ćwiczenie z programowania w Firebase na Androida – czat z łatwością tworzenia

1. Omówienie

Zrzut ekranu

Obraz: aplikacja Working Friendly Chat

Witamy w usłudze Friendly Chat. Z tego ćwiczenia w Codelab dowiesz się, jak użyć platformy Firebase do utworzenia aplikacji do czatu na Androida.

Czego się nauczysz

  • Jak używać usługi Uwierzytelnianie Firebase, aby umożliwić użytkownikom logowanie się.
  • Jak zsynchronizować dane za pomocą Bazy danych czasu rzeczywistego Firebase.
  • Jak przechowywać pliki binarne w Cloud Storage dla Firebase
  • Jak używać Pakietu emulatorów lokalnych Firebase do tworzenia aplikacji na Androida za pomocą Firebase.

Czego potrzebujesz

  • najnowsza wersja Android Studio;
  • Emulator Androida z Androidem 5.0 lub nowszym.
  • Node.js w wersji 10 lub nowszej (do korzystania z Pakietu emulatorów).
  • Java 8 lub nowsza. Aby zainstalować Javę, wykonaj te instrukcje. Aby sprawdzić wersję, uruchom java -version.
  • znajomość języka programowania Kotlin;

2. Pobieranie przykładowego kodu

Klonowanie repozytorium

Sklonuj repozytorium GitHub z poziomu wiersza poleceń:

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

Importowanie do Android Studio

W Android Studio wybierz Plik > Otwórz, a następnie w katalogu, z którego został pobrany przykładowy kod, wybierz katalog build-android-start ( android_studio_folder).

Projekt build-android-start powinien być otwarty w Android Studio. Jeśli zobaczysz ostrzeżenie o brakującym pliku google-services.json, nie martw się. Zostanie ona dodana w późniejszym kroku.

Sprawdzanie zależności

W tym ćwiczeniu wszystkie potrzebne zależności zostały już dodane, ale warto wiedzieć, jak dodać do aplikacji pakiet SDK Firebase:

build.gradle.kts

plugins {
    id("com.android.application") version "8.0.0" apply false
    id("com.android.library") version "8.0.0" apply false
    id("org.jetbrains.kotlin.android") version "1.8.20" apply false

    // The google-services plugin is required to parse the google-services.json file
    id("com.google.gms.google-services") version "4.3.15" apply false
}

app/build.gradle.kts

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:20.5.0")

    // Firebase SDK
    implementation(platform("com.google.firebase:firebase-bom:32.0.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:8.0.2")
    implementation("com.firebaseui:firebase-ui-database:8.0.2")
}

3. Instalowanie wiersza poleceń Firebase

W tym ćwiczeniu użyjesz pakietu emulatorów Firebase do emulowania na poziomie lokalnym Uwierzytelniania Firebase, Bazy danych czasu rzeczywistego i Cloud Storage. Dzięki temu możesz tworzyć aplikacje w bezpiecznym, szybkim i bezpłatnym środowisku lokalnym.

Instalowanie wiersza poleceń Firebase

Najpierw musisz zainstalować wiersz poleceń Firebase. Jeśli używasz systemu macOS lub Linux, możesz uruchomić to polecenie cURL:

curl -sL https://firebase.tools | bash

Jeśli używasz systemu Windows, przeczytaj instrukcje instalacji, aby pobrać samodzielny plik binarny lub zainstalować program za pomocą npm.

Po zainstalowaniu interfejsu wiersza poleceń uruchomienie firebase --version powinno zwrócić wersję 9.0.0 lub nowszą:

$ firebase --version
9.0.0

Zaloguj się

Uruchom firebase login, aby połączyć interfejs wiersza poleceń z kontem Google. Otworzy się nowe okno przeglądarki, w którym możesz dokończyć proces logowania. Pamiętaj, aby wybrać to samo konto, którego użyto wcześniej podczas tworzenia projektu Firebase.

4. Łączenie z pakietem emulatorów Firebase

Uruchom emulatory

W terminalu uruchom to polecenie w głównym katalogu lokalnego katalogu codelab-friendlychat-android:

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

Powinny pojawić się takie logi. Wartości portów zostały zdefiniowane w pliku firebase.json, który był zawarty w klonowanym przykładowym kodzie.

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

Otwórz w przeglądarce adres http://localhost:4000, aby wyświetlić interfejs użytkownika pakietu emulatorów Firebase:

Interfejs użytkownika Pakietu emulatorów

Pozostaw polecenie emulators:start uruchomione do końca ćwiczenia.

Łączenie aplikacji

W Android Studio otwórz MainActivity.kt, a potem w metodzie onCreate dodaj ten kod:

// 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. Uruchamianie aplikacji startowej

Dodawanie pliku google-services.json

Aby aplikacja na Androida mogła połączyć się z Firebase, musisz dodać plik google-services.json do folderu app w projekcie na Androida. W ramach tego Codelab udostępniliśmy pusty plik JSON, który pozwoli Ci połączyć się z pakietem emulatorów Firebase.

Skopiuj plik mock-google-services.json do folderu build-android-start/app jako google-services.json:

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

W ostatnim kroku tego Codelab dowiesz się, jak utworzyć prawdziwy projekt Firebase i aplikację Firebase na Androida, aby móc zastąpić ten przykładowy plik JSON własną konfiguracją.

Uruchamianie aplikacji

Po zaimportowaniu projektu do Android Studio i dodaniu pliku konfiguracji Firebase JSON możesz uruchomić aplikację po raz pierwszy.

  1. Uruchom emulator Androida.
  2. W Android Studio na pasku narzędzi kliknij Uruchom ( execute).

Aplikacja powinna uruchomić się w Twoim emulatorze Androida. W tym momencie powinna wyświetlić się pusta lista wiadomości, a wysyłanie i odbieranie wiadomości nie będzie możliwe. W następnym kroku tego Codelab uwierzytelnisz użytkowników, aby mogli korzystać z Friendly Chat.

6. Włącz uwierzytelnianie

Ta aplikacja będzie używać Bazy danych czasu rzeczywistego Firebase do przechowywania wszystkich wiadomości czatu. Zanim jednak dodamy dane, musimy się upewnić, że aplikacja jest bezpieczna i że tylko uwierzytelnieni użytkownicy mogą publikować wiadomości. W tym kroku włączymy uwierzytelnianie Firebase i skonfigurujemy reguły zabezpieczeń Bazy danych czasu rzeczywistego.

Dodawanie podstawowej funkcji logowania

Następnie dodamy do aplikacji podstawowy kod uwierzytelniania Firebase, aby wykrywać użytkowników i wdrażać ekran logowania.

Sprawdzanie bieżącego użytkownika

Najpierw dodaj do klasy MainActivity.kt tę zmienną instancji:

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Zmień teraz regułę MainActivity, aby użytkownik był przenoszony na ekran logowania, gdy otworzy aplikację bez uwierzytelnienia. Dodaj do metody onCreate() następujące elementy po dołączeniu do widoku typu 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
}

Chcemy też sprawdzić, czy użytkownik jest zalogowany podczas 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
    }
}

Następnie zaimplementuj metody getUserPhotoUrl() i getUserName(), aby zwracać odpowiednie informacje o obecnie uwierzytelnionym użytkowniku 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
}

Następnie zaimplementuj metodę signOut(), aby obsłużyć przycisk wylogowania:

MainActivity.kt

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

Teraz mamy już całą logikę, która w razie potrzeby przekierowuje użytkownika na ekran logowania. Następnie musimy wdrożyć ekran logowania, aby prawidłowo uwierzytelniać użytkowników.

Wdrażanie ekranu logowania

Otwórz plik SignInActivity.kt. W tym przykładzie do zainicjowania uwierzytelniania służy prosty przycisk Logowanie. W tej sekcji za pomocą FirebaseUI zaimplementujesz logikę logowania.

Dodaj zmienną instancji Auth w klasie SignInActivity pod komentarzem // Firebase instance variables:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Następnie zmodyfikuj metodę onCreate(), aby zainicjować Firebase w taki sam sposób jak w funkcji MainActivity:

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Dodaj pole ActivityResultLauncher do pola SignInActivity:

SignInActivity.kt

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

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

Następnie zmień metodę onStart(), aby rozpocząć proces logowania w 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()
    }
}

Następnie zaimplementuj metodę onSignInResult, aby obsłużyć wynik logowania. Jeśli udało się zalogować, wykonaj te czynności: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)
        }
    }
}

To wszystko. Uwierzytelnianie za pomocą FirebaseUI zostało zaimplementowane za pomocą kilku wywołań metody i bez konieczności zarządzania konfiguracją po stronie serwera.

Sprawdzanie efektów pracy

Uruchom aplikację w emulatorze Androida. Powinieneś zostać natychmiast przekierowany na ekran logowania. Kliknij przycisk Zaloguj się za pomocą adresu e-mail, a następnie utwórz konto. Jeśli wszystko jest prawidłowo zaimplementowane, powinieneś/powinnaś zostać przekierowany/a na ekran wiadomości.

Po zalogowaniu się otwórz w przeglądarce interfejs sterowania pakietu Emulator Suite Firebase, a potem kliknij kartę Uwierzytelnianie, aby wyświetlić pierwsze zalogowane konto użytkownika.

7. Czytanie wiadomości

W tym kroku dodamy funkcję odczytywania i wyświetlania wiadomości przechowywanych w Baza danych czasu rzeczywistego.

Importowanie przykładowych wiadomości

  1. W interfejsie Firebase Emulator Suite wybierz kartę Baza danych czasu rzeczywistego.
  2. Przeciągnij i upuść plik initial_messages.json z lokalnej kopii repozytorium codelab do podglądu danych.

W węźle messages bazy danych powinno być teraz kilka wiadomości.

Odczytywanie danych

Synchronizacja wiadomości

W tej sekcji dodajemy kod, który synchronizuje nowo dodane wiadomości z interfejsem aplikacji:

  • Inicjowanie Bazy danych czasu rzeczywistego Firebase i dodawanie listenera do obsługi zmian w danych.
  • Zaktualizowanie adaptera RecyclerView, aby wyświetlały się nowe wiadomości.
  • Dodawanie zmiennych instancji bazy danych wraz z innymi zmiennymi instancji Firebase w klasie MainActivity:

MainActivity.kt

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

Zmodyfikuj metodę onCreate() klasy MainActivity pod komentarzem // Initialize Realtime Database and FirebaseRecyclerAdapter, używając kodu określonego poniżej. Ten kod dodaje wszystkie istniejące wiadomości z Bazy danych czasu rzeczywistego, a potem nasłuchuje nowych wpisów podrzędnych na ścieżce messages w Baza danych czasu rzeczywistego Firebase. Dodaje do interfejsu nowy element dla każdej wiadomości:

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

Następnie w klasie FriendlyMessageAdapter.kt zaimplementuj metodę bind() w klasie wewnętrznej 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)
        }
    }
    ...
}

Musimy też wyświetlać komunikaty w postaci obrazów, więc w klasie wewnętrznej ImageMessageViewHolder() zaimplementuj też metodę bind():

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

W tym samym pliku MainActivity możesz też rozpocząć i zatrzymać nasłuchiwanie aktualizacji z Bazy danych czasu rzeczywistego Firebase. Zaktualizuj metody onPause() i onResume() w MainActivity w ten sposób:

MainActivity.kt

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

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

Testowanie synchronizacji wiadomości

  1. Kliknij Wykonaj execute.
  2. W interfejsie Emulator Suite wróć do karty Realtime Database, a potem ręcznie dodaj nową wiadomość. Sprawdź, czy wiadomość jest widoczna w aplikacji na Androida:

Gratulacje! Właśnie dodałeś do aplikacji bazę danych w czasie rzeczywistym.

8. Wysyłanie wiadomości

Implementacja wysyłania SMS-ów

W tej sekcji dodasz możliwość wysyłania SMS-ów przez użytkowników aplikacji. Fragment kodu poniżej wykrywa zdarzenia kliknięcia przycisku wysyłania, tworzy nowy obiekt FriendlyMessage z zawartością pola wiadomości i przesyła wiadomość do bazy danych. Metoda push() dodaje automatycznie wygenerowany identyfikator do ścieżki przesyłanego obiektu. Identyfikatory te są uporządkowane chronologicznie, co zapewnia, że nowe wiadomości będą dodawane na końcu listy.

Zaktualizuj listenera kliknięcia przycisku wysyłania w metodzie onCreate() w klasie MainActivity. Ten kod znajduje się już na dole metody onCreate(). Zaktualizuj treść elementu onClick(), aby odpowiadała poniższemu kodowi:

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

Wdrożenie wysyłania wiadomości z obrazem

W tej sekcji dodasz możliwość wysyłania wiadomości z obrazami przez użytkowników aplikacji. Aby utworzyć wiadomość z obrazem:

  • Wybierz obraz
  • Wybór obrazu
  • Zapisywanie tymczasowego komunikatu z obrazem w BTD
  • Rozpocznij przesyłanie wybranego obrazu
  • po zakończeniu przesyłania zaktualizować adres URL wiadomości z obrazem na adres URL przesłanego obrazu

Wybierz obraz

Aby dodawać obrazy, ten samouczek używa Cloud Storage dla Firebase. Cloud Storage to dobre miejsce na przechowywanie danych binarnych aplikacji.

Obsługa wyboru obrazu i pisania tymczasowej wiadomości

Gdy użytkownik wybierze obraz, zostanie wyświetlona opcja wyboru obrazu Intent. Jest to już zaimplementowane w kodzie na końcu metody onCreate(). Po zakończeniu wywołuje metodę onImageSelected() klasy MainActivity. Za pomocą poniższego fragmentu kodu zapiszesz do bazy danych wiadomość z tymczasowym adresem URL obrazu, która wskazuje, że obraz jest przesyłany.

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

Przesyłanie obrazu i aktualizowanie wiadomości

Dodaj metodę putImageInStorage() do MainActivity. Jest on wywoływany w funkcji onImageSelected(), aby zainicjować przesłanie wybranego obrazu. Po zakończeniu przesyłania zaktualizuj wiadomość, aby użyć odpowiedniego obrazu.

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

Testowanie wysyłania wiadomości

  1. W Android Studio kliknij przycisk executeUruchom.
  2. W Emulatorze Androida wpisz wiadomość, a potem kliknij przycisk wysyłania. Nowa wiadomość powinna być widoczna w interfejsie aplikacji i w interfejsie pakietu emulatorów Firebase.
  3. W Emulatorze Androida kliknij obraz „+”, aby wybrać obraz z urządzenia. Nowa wiadomość powinna być widoczna najpierw z obrazem zastępczym, a potem z wybranym obrazem po zakończeniu przesyłania. Nowa wiadomość powinna być też widoczna w interfejsie Emulator Suite, konkretnie jako obiekt na karcie „Baza danych w czasie rzeczywistym” i jako blob na karcie „Pamięć”.

9. Gratulacje!

Właśnie utworzyliśmy aplikację do czatu w czasie rzeczywistym za pomocą Firebase.

Czego się nauczyłeś

  • Uwierzytelnianie Firebase
  • Baza danych czasu rzeczywistego Firebase
  • Cloud Storage dla Firebase

Następnie wykorzystaj wiedzę zdobytą w tym samouczku, aby dodać Firebase do własnej aplikacji na Androida. Więcej informacji o Firebase znajdziesz na stronie firebase.google.com.

Jeśli chcesz dowiedzieć się, jak skonfigurować prawdziwy projekt Firebase i używać prawdziwych zasobów Firebase (zamiast projektu demonstracyjnego i tylko emulowanych zasobów), przejdź do następnego kroku.

Uwaga: nawet po skonfigurowaniu prawdziwego projektu Firebase i szczególnie, gdy zaczniesz tworzyć prawdziwą aplikację, zalecamy korzystanie z Pakiet emulatorów lokalnych Firebase do tworzenia i testowania.

10. Opcjonalnie: utwórz i skonfiguruj projekt Firebase

W tym kroku utworzysz prawdziwy projekt Firebase i aplikację Firebase na Androida, które będą używane w tym CodeLab. Dodasz też do aplikacji konfigurację Firebase, która będzie do niej przypisana. Na koniec skonfigurujesz prawdziwe zasoby Firebase, których będziesz używać w aplikacji.

Tworzenie projektu Firebase

  1. W przeglądarce otwórz konsolę Firebase.
  2. Kliknij Dodaj projekt.
  3. Wybierz lub wpisz nazwę projektu. Możesz użyć dowolnej nazwy.
  4. W tym przypadku nie potrzebujesz Google Analytics, więc możesz pominąć ten krok.
  5. Kliknij Utwórz projekt. Gdy projekt będzie gotowy, kliknij Dalej.

Przejdź na wyższy abonament Firebase

Aby korzystać z Cloud Storage dla Firebase, musisz mieć projekt Firebase w abonamentem Blaze (opłaty według wykorzystania), co oznacza, że jest on połączony z kontem rozliczeniowym Cloud.

Aby przenieść projekt na abonament Blaze:

  1. W konsoli Firebase wybierz uaktualnienie abonamentu.
  2. Wybierz pakiet Blaze. Postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby połączyć konto rozliczeniowe Cloud z projektem.
    Jeśli w ramach tego przejścia na wyższy poziom abonamentu musisz utworzyć konto rozliczeniowe Cloud, konieczne może być powrót do procesu przejścia w konsoli Firebase, aby go dokończyć.

Dodawanie Firebase do projektu na Androida

Zanim wykonasz ten krok, uzyskaj hasz SHA1 swojej aplikacji. Aby określić SHA1 klucza debugowania, uruchom to polecenie w lokalnym katalogu build-android-start:

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

Powinny się wyświetlić dane wyjściowe podobne do tych powyżej. Ważna linia to SHA1. Jeśli nie możesz znaleźć haszu SHA-1, więcej informacji znajdziesz na tej stronie.

Wróć do konsoli Firebase i wykonaj te czynności, aby zarejestrować projekt na Androida w projekcie Firebase:

  1. Na ekranie podsumowania nowego projektu kliknij ikonę Androida, aby uruchomić proces konfiguracji: dodawanie aplikacji na Androida,
  2. Na następnym ekranie wpisz com.google.firebase.codelab.friendlychat jako nazwę pakietu swojej aplikacji.
  3. Kliknij kolejno Zarejestruj aplikację i Pobierz plik google-services.json, aby pobrać plik konfiguracji Firebase.
  4. Skopiuj plik google-services.json do katalogu app projektu na Androida.
  5. Pomiń kolejne kroki w procesie konfiguracji konsoli (zostały już wykonane w Twoim imieniu w projekcie build-android-start).
  6. Upewnij się, że wszystkie zależności są dostępne dla aplikacji, synchronizując projekt z plikami Gradle. Na pasku narzędzi Android Studio kliknij Plik > Synchronizuj projekt z plikami Gradle. Aby zmiany w konfiguracji zaczęły obowiązywać, może być też konieczne wykonanie poleceń Build/Clean Project i Build/Rebuild Project.

Konfigurowanie Uwierzytelniania Firebase

Zanim aplikacja będzie mogła uzyskiwać dostęp do interfejsów API Uwierzytelniania Firebase w imieniu użytkowników, musisz włączyć Uwierzytelnianie Firebase i usługodawców logowania, których chcesz używać w aplikacji.

  1. W konsoli Firebase w panelu nawigacyjnym po lewej stronie kliknij Uwierzytelnianie.
  2. Kliknij kartę Metoda logowania.
  3. Kliknij E-mail/hasło, a następnie ustaw przełącznik w pozycji włączonej (niebieski).
  4. Kliknij Google, a następnie przełącz przełącznik w pozycję włączenia (niebieski) i ustaw adres e-mail zespołu pomocy projektu.

Jeśli w późniejszej części tego ćwiczenia pojawią się błędy z komunikatem „CONFIGURATION_NOT_FOUND”, wróć do tego kroku i sprawdź dokładnie swoją pracę.

Konfigurowanie Bazy danych czasu rzeczywistego

Aplikacja w tym ćwiczeniu przechowuje wiadomości czatu w Baza danych czasu rzeczywistego Firebase. W tej sekcji utworzymy bazę danych i skonfigurujemy jej zabezpieczenia za pomocą języka konfiguracji JSON o nazwie Reguły zabezpieczeń Firebase.

  1. W panelu po lewej stronie w konsoli Firebase rozwiń Tworzenie, a potem kliknij Baza danych w czasie rzeczywistym.
  2. Kliknij Utwórz bazę danych.
  3. Wybierz lokalizację bazy danych, a potem kliknij Dalej.
    W przypadku prawdziwej aplikacji wybierz lokalizację blisko użytkowników.
  4. Kliknij Rozpocznij w trybie testowym. Przeczytaj wyłączenie odpowiedzialności dotyczące reguł bezpieczeństwa.
    W kolejnych krokach tego laboratorium kodu dodasz reguły bezpieczeństwa, aby chronić swoje dane. Nie udostępniaj ani nie udostępniaj publicznie aplikacji bez dodania reguł bezpieczeństwa dla bazy danych.
  5. Kliknij Utwórz.
  6. Po utworzeniu instancji bazy danych kliknij kartę Reguły, a potem zaktualizuj konfigurację reguł, korzystając z tych opcji:
     {
   "rules": {
     "messages": {
       ".read": "auth.uid != null",
       ".write": "auth.uid != null"
     }
   }
 }

Więcej informacji o działaniu reguł zabezpieczeń (w tym dokumentacja zmiennej „auth”) znajdziesz w dokumentacji dotyczącej zabezpieczeń Bazy danych czasu rzeczywistego.

Konfigurowanie Cloud Storage dla Firebase

  1. W panelu po lewej stronie konsoli Firebase rozwiń Kompilacja, a potem kliknij Storage.
  2. Kliknij Rozpocznij.
  3. Wybierz lokalizację domyślnego zasobnika Storage.
    Zasobniki w regionach US-WEST1, US-CENTRAL1 i US-EAST1 mogą korzystać z poziomu Always Free w Google Cloud Storage. Zasobniki w innych lokalizacjach podlegają cennikom i zasadom korzystania z Google Cloud Storage.
  4. Kliknij Rozpocznij w trybie testowym. Przeczytaj wyłączenie odpowiedzialności dotyczące reguł bezpieczeństwa.
    W dalszej części tego Codelab dodasz reguły bezpieczeństwa, które ochronią Twoje dane. Nie udostępniaj ani nie udostępniaj publicznie aplikacji bez dodania reguł bezpieczeństwa dla zasobnika Storage.
  5. Kliknij Utwórz.

Łączenie z zasobami Firebase

W poprzednim kroku tego Codelab dodaliśmy do pliku MainActivity.kt następujące dane: Ten blok warunkowy połączył Twój projekt na Androida z pakietem emulatorów 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)
}

Jeśli chcesz połączyć aplikację z nowym prawdziwym projektem Firebase i jego prawdziwymi zasobami Firebase, możesz usunąć ten blok kodu lub uruchomić aplikację w trybie wydania, aby wartość BuildConfig.DEBUG była false.