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

1. Omówienie

Obraz: Przyjazna dla pracowników aplikacja do obsługi czatu.

Witamy w usłudze Friendly Chat. Z tego ćwiczenia w Codelabs dowiesz się, jak za pomocą platformy Firebase utworzyć aplikację do obsługi czatu na Androida.

Czego się nauczysz

• Jak umożliwić użytkownikom logowanie się za pomocą uwierzytelniania Firebase.
• Jak synchronizować dane przy użyciu 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 przy użyciu 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, używając 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 wybierz katalog build-android-start ( ) z katalogu, z którego został pobrany przykładowy kod.

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

Sprawdź 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 interfejsu 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 interfejsu 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 co podczas tworzenia projektu Firebase.

4. Połącz się 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 wyświetlić 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.

Aby wyświetlić interfejs pakietu emulatorów Firebase, otwórz w przeglądarce adres http://localhost:4000:

Do końca ćwiczeń z programowania pozostaw uruchomione polecenie emulators:start.

Połącz aplikację

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

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

5. Uruchom aplikację startową

Dodawanie pliku google-services.json

Aby Twoja aplikacja na Androida mogła połączyć się z Firebase, musisz dodać plik google-services.json w folderze app projektu na Androida. Na potrzeby tego ćwiczenia w Codelabs udostępniamy próbny 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 ćwiczenia 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 ().

Aplikacja powinna się uruchomić przy użyciu emulatora Androida. W tym momencie lista wiadomości powinna być pusta, a wysyłanie i odbieranie wiadomości nie będzie działać. W następnym kroku tego ćwiczenia z programowania uwierzytelnisz użytkowników, aby mogli korzystać z przyjaznego czatu.

6. Włącz uwierzytelnianie

Ta aplikacja będzie korzystać z 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.

Sprawdź bieżącego użytkownika

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

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Teraz zmodyfikujmy MainActivity, aby kierować użytkownika na ekran logowania, gdy otwiera aplikację bez uwierzytelnienia. Dodaj następujący kod do metody onCreate() po dołączeniu do widoku danych 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() do obsługi przycisku 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 zaimplementować ekran logowania, aby poprawnie uwierzytelnić użytkowników.

Implementacja ekranu logowania

Otwórz plik SignInActivity.kt. W tym przypadku do inicjowania uwierzytelniania służy prosty przycisk logowania. W tej sekcji wdrożysz logikę logowania za pomocą FirebaseUI.

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 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 do obsługi wyniku logowania. Jeśli logowanie przebiegło pomyślnie, przejdź do 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. Udało Ci się wdrożyć uwierzytelnianie za pomocą FirebaseUI za pomocą zaledwie kilku wywołań metody bez konieczności zarządzania konfiguracją po stronie serwera.

Sprawdzanie efektów pracy

Uruchom aplikację w emulatorze Androida. Powinien natychmiast wyświetlić się 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ę odczytu i wyświetlania wiadomości przechowywanych w bazie danych czasu rzeczywistego.

Importowanie przykładowych wiadomości

1. W interfejsie Pakietu emulatorów Firebase kliknij kartę Baza danych czasu rzeczywistego.
2. Przeciągnij plik initial_messages.json z lokalnej kopii repozytorium ćwiczeń z programowania i upuść go w przeglądarce danych.

W węźle messages bazy danych powinno być teraz kilka komunikatów.

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.
• Zaktualizowano adapter RecyclerView, aby wyświetlał 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() MainActivity w komentarzu // Initialize Realtime Database and FirebaseRecyclerAdapter za pomocą kodu zdefiniowanego poniżej. Ten kod dodaje wszystkie istniejące wiadomości z Bazy danych czasu rzeczywistego, a następnie nasłuchuje nowych wpisów podrzędnych w ścieżce messages w Bazie 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():

FriendsMessageAdapter.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ć wiadomości będące obrazami, więc zaimplementuj też metodę bind() w klasie wewnętrznej 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)
        }
    }
}

Na koniec wróć do funkcji MainActivity i zacznij nasłuchiwać aktualizacji 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 ( ).
2. W interfejsie Pakietu emulatorów wróć na kartę Baza danych czasu rzeczywistego i ręcznie dodaj nową wiadomość. Sprawdź, czy komunikat wyświetla się w aplikacji na Androida:

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

8. Wysyłanie wiadomości

Wdrażanie wysyłania SMS-ów

W tej sekcji dodasz możliwość wysyłania SMS-ów przez użytkowników aplikacji. Fragment kodu poniżej nasłuchuje zdarzeń kliknięcia przycisku wysyłania, tworzy nowy obiekt FriendlyMessage z zawartością pola wiadomości i przenosi wiadomość do bazy danych. Metoda push() dodaje automatycznie generowany identyfikator do ścieżki przekazywanego 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("")
}

Wdrażanie wysyłania wiadomości graficznych

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

• Wybierz obraz
• Obsługa wyboru 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 do przechowywania danych binarnych aplikacji.

Wybieranie obrazu i zapisywanie wiadomości tymczasowej

Gdy użytkownik wybierze obraz, zostanie wyświetlona opcja wyboru obrazu Intent. Jest on już zaimplementowany w kodzie na końcu metody onCreate(). Po zakończeniu wywołuje metodę onImageSelected() metody 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 metody MainActivity. Jest ona wywoływana w języku onImageSelected(), aby rozpocząć przesyłanie wybranego obrazu. Po zakończeniu przesyłania zaktualizujesz komunikat, używając 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 Uruchom.
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ć najpierw widoczna jako obraz zastępczy, a po zakończeniu przesyłania obrazu – z wybranym obrazem. 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

Teraz spróbuj wykorzystać informacje o tym ćwiczeniu w programie, aby dodać Firebase do swojej 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, a zwłaszcza wtedy, gdy zaczynasz tworzyć prawdziwą aplikację, do programowania i testowania zalecamy korzystanie z Pakietu emulatorów lokalnych Firebase.

10. Opcjonalnie: tworzenie i konfigurowanie projektu Firebase

W tym kroku utworzysz prawdziwy projekt Firebase i aplikację Firebase na Androida, których będziesz używać w tym ćwiczeniu. Do aplikacji musisz też dodać konfigurację Firebase dla swojej aplikacji, a na koniec skonfigurować rzeczywiste zasoby Firebase do wykorzystania w aplikacji.

Tworzenie projektu Firebase

1. W przeglądarce otwórz konsolę Firebase.
2. Wybierz 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, projekt Firebase musi być w abonamentem Blaze (opłaty według wykorzystania), co oznacza, że jest połączony z kontem rozliczeniowym Cloud.

• Do konta rozliczeniowego Cloud wymagana jest forma płatności, np. karta kredytowa.
• Jeśli dopiero zaczynasz korzystać z Firebase i Google Cloud, sprawdź, czy kwalifikujesz się do otrzymania środków w wysokości 300 USD i bezpłatnego okresu próbnego konta rozliczeniowego Cloud.
• Jeśli wykonujesz to Codelab w ramach wydarzenia, zapytaj organizatora, czy są dostępne jakieś kredyty Cloud.

Aby przenieść projekt na abonament Blaze:

1. W konsoli Firebase wybierz uaktualnienie abonamentu.
2. Wybierz abonament 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żny wiersz to hasz SHA1. Jeśli nie możesz znaleźć hasza SHA-1, więcej informacji znajdziesz na tej stronie.

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

1. Na ekranie przeglądu nowego projektu kliknij ikonę Androida, aby uruchomić przepływ pracy konfiguracji:
2. Na następnym ekranie wpisz com.google.firebase.codelab.friendlychat jako nazwę pakietu aplikacji.
3. Kliknij Zarejestruj aplikację, a następnie Pobierz google-services.json, aby pobrać plik konfiguracji Firebase.
4. Skopiuj plik google-services.json do katalogu app swojego projektu na Androida.
5. Pomiń kolejne kroki w procesie konfiguracji konsoli (zostały już wykonane w Twoim imieniu w projekcie build-android-start).
6. Synchronizuj projekt z plikami Gradle, aby upewnić się, że aplikacja ma dostęp do wszystkich zależności. Na pasku narzędzi Android Studio wybierz Plik > Synchronizuj projekt z plikami Gradle. Aby zmiany konfiguracji zostały wprowadzone, może być też konieczne uruchomienie poleceń Build/Clean Project (Utwórz/wyczyść projekt) oraz Build/Rebuild Project.

Skonfiguruj Uwierzytelnianie 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. Wybierz kartę Metoda logowania.
3. Kliknij E-mail/hasło, a następnie ustaw przełącznik w pozycji włączonej (niebieskiej).
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 dalszej części tego ćwiczenia w Codelabs wystąpi błąd i pojawi się komunikat „CONFIGURATION_NOT_FOUND”, wróć do tego kroku i dokładnie sprawdź swoją pracę.

Konfigurowanie Bazy danych czasu rzeczywistego

Aplikacja objęta tym ćwiczeniem w Codelabs przechowuje wiadomości czatu w bazie danych czasu rzeczywistego Firebase. W tej sekcji utworzymy bazę danych i skonfigurujemy jej zabezpieczenia za pomocą języka konfiguracji JSON nazywanego regułami zabezpieczeń Firebase.

1. W panelu po lewej stronie konsoli Firebase rozwiń Kompilację i wybierz Baza danych czasu rzeczywistego.
2. Kliknij Utwórz bazę danych.
3. Wybierz lokalizację bazy danych i kliknij Dalej.
   W przypadku prawdziwej aplikacji musisz wybrać lokalizację znajdującą się w pobliżu użytkowników.
4. Kliknij Rozpocznij w trybie testowym. Przeczytaj wyłączenie odpowiedzialności dotyczące reguł zabezpieczeń.
   W następnych krokach tego ćwiczenia z programowania dodasz reguły zabezpieczeń, aby zabezpieczyć 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 wybierz kartę Reguły, a następnie zaktualizuj konfigurację reguł w ten sposób:

    {
      "rules": {
        "messages": {
          ".read": "auth.uid != null",
          ".write": "auth.uid != null"
        }
      }
    }
   

Więcej informacji o działaniu reguł zabezpieczeń (w tym dokumentację zmiennej „auth”) znajdziesz w dokumentacji 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 Cloud Storage.
   Zasobniki w usługach US-WEST1, US-CENTRAL1 i US-EAST1 mogą korzystać z poziomu „Zawsze bezpłatne” 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.

Połącz z zasobami Firebase

W poprzednim kroku tego ćwiczenia z programowania dodałeś do MainActivity.kt ten kod. 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, usuń ten blokadę lub uruchom aplikację w trybie wersji, tak aby BuildConfig.DEBUG miała wartość false.