The many ways to trigger and customize messages

Released almost 2 years ago, In-App-Messaging is a Firebase product that developers can use to send targeted messages (in form of dialogs) to their users. Setting it up and sending a test message is pretty straight forward, but there’s more that can be done to improve the User Experience.
In this blog post, I’ll show some of the different ways to trigger and customize in-app messages.

Getting Started 👶

As mentioned above, sending a test message from Firebase In-App-Messaging (abbreviated as FIAM from this point on) is pretty simple and can be done in 4 steps:

1. Add the FIAM and Analytics dependencies to your build.gradle(app):

implementation "com.google.firebase:firebase-inappmessaging-ktx:$fiamVersion"
implementation "com.google.firebase:firebase-analytics-ktx:$analyticsVersion"

2. Run the app to find your Installation ID in the logcat:

I/FIAM.Headless: Starting InAppMessaging runtime with Installation ID YOUR_INSTALLATION_ID

3. Go to the In-App Messaging tab on the Firebase Console, click on “New Campaign” and enter a Title for that campaign.

4. Click “Test on your Device”, enter your Installation ID and click on “Test” to send the message.

Once you relaunch the app, you should now see your test message being displayed :)

Now if you wish to send the message to the users of your app, you can go ahead and finish composing that campaign, as explained in the Firebase Documentation.

Seasonal Campaigns 🐰🎄

This is my favorite FIAM feature and perhaps the most used one. It allows you to schedule messages to be shown during a specified time range. So you can use it to inform your users about Easter discounts, Christmas sales or even that great deal that your company is offering during a pandemic. You can also specify how often the message is shown to the user.

The good part is that you don’t need to write any code to achieve that. You can do it all straight from the Firebase Console. When composing your campaign, you’ll come across Step 3 — Scheduling your message. That’s where you can set a start date and an end date.

You’ll notice that the messages are triggered by Analytics events (which is why we added analytics to the app). Two events that are logged automatically by Firebase Analytics are on_foreground and app_launch, so these will always be available for you to choose from when composing a campaign. If you’ve previously logged events to Firebase Analytics, those events will also be available to choose from. Otherwise, you can also create a new event right there.

Trigger messages with Analytics events 💬

Let’s say we have an e-commerce app and we want to show users a dialog when they’re about to perform a checkout. When composing the campaign on the Firebase Console, we’ll set it to only be triggered on the begin_checkout event:

We could log the begin_checkout event to Firebase Analytics when the user clicks on the checkout button:

And our message should be displayed to the user. :)

Alternatively, you can trigger the event without actually logging the data to Firebase Analytics, by calling:

Firebase.inAppMessaging.triggerEvent("begin_checkout")

Customize the message behavior 🔧

Now if the user clicks on the “Get Code” button from our in-app-message, we might want to take an action, such as notifying our backend about the fact that we should now give that user a discount.

We can do that by adding the promo code as custom metadata on Step 5 when we’re composing the campaign on the Console:

And then we can obtain that promo code on the app by adding a click listener to our FIAM instance:

Customize the way it looks 🎨

Maybe you have created a unique and kick-ass custom design for your app dialogs and would like to apply it to your In-App-Message.

You can do so by calling setMessageDisplayComponent() on the onResume() lifecycle event of your Activity and checking what type of message the app received and then get the metadata (title, caption, actions, etc) included so that you can use it on your custom dialog.

And that’s all for now. If you would like to learn more about Firebase In-App-Messaging, you can check the Documentation.

Thanks for reading. If you have thoughts on FIAM or Firebase in general, leave a comment bellow or reach out to me on Twitter and I’ll be happy to have a chat about it. :)

Using Firebase In-App-Messaging on an Android app was originally published in ProAndroidDev on Medium, where people are continuing the conversation by highlighting and responding to this story.

Coroutines and extension functions for the rescue

If you’re developing an Android app and you’re storing images in cloud storage for Firebase to later display in your app, you’re probably using an image loading library such as Glide, Picasso, Fresco, or firebase-ui-storage. Yes, these libraries can do the job, but what if I told you there’s a more pleasant and efficient way?

In this article, I’ll introduce you to the new kid in town, Coil, and I’ll show you how to use it to load your cloud storage images with less boilerplate code.
I’ll assume you’re already familiar with cloud storage for Firebase and already know how to use it in an Android app. If not, you may want to take a look at the Documentation.

Coil (Coroutines Image Loader)

Coil is an open-source Image Loading Library for Android. Unlike the other pre-existing libraries (Glide, Picasso, etc), Coil was built entirely in Kotlin and is backed by Coroutines. It’s also:

• Easy to use: Because it leverages some Kotlin language features, such as Kotlin Extension Functions, which allows you to keep your code simple and concise.
• Lightweight: It adds ~2000 methods to your APK, which is almost the same as Picasso and a little less than Glide.
• Fast: Its speed compares fairly to Picasso and Glide, as shown in this benchmark.

Getting Started

Because Coil uses Java 8, one of the prerequisites is that you enable Java 8 in your Android project. You can do so in your module’s build.gradle file:

Then you add it as a dependency on that same file:

dependencies {
    // ... other dependencies
    implementation 'io.coil-kt:coil:0.11.0'
}

Usage

The simplest way to use Coil is by calling the ImageView.load() extension functions that the library provides:

// URL
imageView.load("https://www.example.com/image.jpg")

// Resource
imageView.load(R.drawable.image)

You can also specify a placeholder or any other additional configuration on a trailing lambda:

imageView.load("https://www.example.com/image.jpg") {
    placeholder(R.drawable.image)
    transformations(CircleCropTransformation())
}

Apart from the extension functions, Coil also provides other ways to load images, such as Requests and Image Loaders, which I won’t go through for brevity. But you can learn more about them in their Documentation.

Coil Plus Cloud Storage for Firebase

Let’s say you have an image stored on Cloud Storage for Firebase, which can be accessed using the path “users/me/profile.png”. To display this image on an ImageView in your Android App, you may need to get its download URL first and then pass it to Coil, as the docs suggest:

It looks simple, right? But what if I told you that even this can be simplified?
That’s where firecoil comes in.

firecoil: Firebase and Coil

firecoil is an open-source library that allows you to load images with Coil by simply providing the StorageReference of said image. To use firecoil, you’ll need to add the jitpack maven to your project’s build.gradle file:

repositories {
    // ...
    maven { url 'https://jitpack.io' }
}

Next add the firecoil dependency to your module’s build.gradle file:

implementation 'com.github.rosariopfernandes:firecoil:0.2.0'

Now with firecoil you no longer need to get the download URL. You can simply pass your StorageReference to the ImageView.load() extension function provided by the library:

Since firecoil is built on top of Coil, you can also use a trailing lambda to specify additional configuration:

That’s it! With this simple and concise snippet, your app should now have beautiful images displayed.

Resources

• Coil on GitHub: https://github.com/coil-kt/coil
• firecoil on GitHub: https://github.com/rosariopfernandes/firecoil
• Coil Documentation: https://coil-kt.github.io/coil/
• firecoil Documentation: https://firebaseopensource.com/projects/rosariopfernandes/firecoil
• Glide vs. Picasso vs. Coil Benchmark: https://proandroiddev.com/coil-vs-picasso-vs-glide-get-ready-go-774add8cfd40

Loading Images From Cloud Storage on Android using Coil was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

Firebase News: April 26th — May 09th

This is Article 02 of “Firebase News” — a series of articles where you can find the most recent news from the Firebase World. A new article is posted every 1–2weeks discussing (most of) the changes made on the official tools, SDKs, sample apps and some of the 3rd party libraries. Also expect to see what’s new on: the official Firebase blog, the Firebase Developers Medium publication, the Firebase Youtube Channel and the Firebase Open Source site.

Disclaimer: I do not work for Firebase, Google or any other organization here mentioned. Views, thoughts, and opinions expressed in this article belong solely to me, and not necessarily to these organizations.

Firebase Admin SDKs

Python Admin SDK

Version 4.2.0 was released and it introduces a newtenant_mgt module that provides APIs to work with Multi-tenancy. You can read more about Multi-tenant applications in this blog post by Hiranya Jayathilaka.

Node.js Admin SDK

Starting in version 8.12.0, developers using the NodeJS Admin SDK can now retrieve and delete users in bulk, using the newly added getUsers() and deleteUsers() functions. Learn more about it on this other blog post by Hiranya.

.Net Admin SDK

Version 1.12.0 of the .Net Admin SDK has 2 new methods to manage Firebase session cookies: CreateSessionCookieAsync() and VerifySessionCookieAsync().

Firebase Open Source

Two (2) new Kotlin projects have been added to firebaseopensource.com :

• firebase-kotlin-sdk from GitLiveApp. As the name suggests, this project is an unofficial Kotlin SDK for Firebase. Unlike the official Firebase KTX, this project does not extend the Java SDK, instead, it was built on top of it, with Kotlin-first design in mind. It also supports writing for Kotlin multiplatform, which means you can use the same code for Android, iOS and JavaScript.
• kotfirebase by raipankaj - a Kotlin wrapper for the Firebase SDK. The project aims to bring the usage of each API down to one line of code.

Firebase Youtube Channel

We have four (4) new videos on the Youtube Channel:

Other Minor Releases

Android

• Firebase Installations 16.3.0 and Firebase Instance ID 20.1.7 improved the detection of invalid FirebaseOptions values.
• Crashlytics Gradle plugin version 2.1.0 - minor bug fixes.
• App Distribution Gradle plugin version 1.4.1 - bug fixes.
• Analytics 17.4.1 - the Event SELECT_CONTENT has been un-deprecated.

iOS

Version 6.24.0 - bug fixes to Analytics, Authentication, Crashlytics, Realtime Database, Cloud Firestore, In App Messaging, FCM and Remote Config.

Firebase Tools 8.2.0

Version 8.2.0 - Minor improvements and dependency updates.

Firebase Extensions

• storage-resize-images 0.1.7 - fixed a bug that prevents resized images from being shown in the Firebase Console.
  Fixed an issue where the extensions would resize the wrong image, due to caching errors.
• firestore-translate-text 0.1.2 - target languages can now be reconfigured.
• firestore-send-email 0.1.4 - the “default FROM” parameter now accepts a name before the email. E.g: Friendly User <foobar@example.com>

Learn how to implement One Tap sign-in and sign-up on your existing Firebase Android app

Google has recently introduced One Tap sign-in and sign-up on Android. This service allows your app’s new users to create an account, securely with just a single tap on a beautiful dialog.
Users who already have an account can also have the same experience, so they don’t need to remember the username or password they had previously used when they created an account in that app.
You can read more about One Tap in this other post.

Here’s what that beautiful dialog looks like:

In this post, I’ll show you how to connect the One Tap UI with Firebase Authentication.

Firebase Auth with Google Sign-In

I’ll assume that you’ve already implemented Google Sign-in using Firebase Auth on your Android app, so I’ll not go over the steps on how to do that. But if you haven’t, you can still do so by following this guide on the documentation. Also, I’ll be using some of the methods created on this same documentation, so in case you see a method/property that you don’t recognize, please be sure to look for it on that page or on the sample app I’ve created.

Google’s One Tap UI comes bundled in com.google.android.gms:play-services-auth , which you might already be using, since this library is needed when you’re implementing Google Sign-In. Just check the dependencies on your build.gradle(app) file to make sure you’re using version 18.0.0 or higher.

Now the next thing we need to do is declare some variables and initialize them on the Activity’s onCreate() or (in my case) the fragment’s onViewCreated():

Notice that on our BeginSignInRequest we’re setting filterByAuthorizedAccounts to true. This means the OneTap UI will only display accounts that have previously logged in to this app. If you’re displaying the Google Sign -In option on a Sign up screen, you should set filterByAuthorizedAccounts to false instead, so that the UI displays all user accounts available on that Android device.

Those variables that we just declared will be used to initiate the One Tap sign-in flow on our updateUI() method (the one called from onStart()):

If the OnFailureListener gets executed, it means the user has never logged in to this app before or another error occurred. One other error that might happen is the 24-hour cooldown period, which the OneTap UI uses as a way to limit the prompts that it shows. If you face this error during development, the documentation recommends:

“… reset the cooldown by clearing Google Play services’ app storage.”

But otherwise, if the SuccessListener gets executed instead, startIntentSenderForResult() will display the One Tap UI for users to select the account they wish to use in order to continue. So we need to update our onActivityResult code in order to receive and handle the result coming from One Tap:

Note that if the user closes the One Tap UI, getSignInCredentialFromIntent() returns an ApiException with the status code CommonStatusCodes.CANCELED. In that case, we set our variable back to false and we don’t prompt the user again. Although using this variable may work fine, you can also use SharedPreferences instead, if you prefer.

And that’s it! You can now run your app and test the One Tap UI. This is what the One Tap UI with Google Sign-In should look like:

Firebase Auth with Email/Password

If your app also provides Email/Password authentication, One Tap UI can also help your users signing in to your app using that method. You’ll need to update the BeginSignInRequest we created earlier and handle the result in the onActivityResult() function:

This password request feature is backed by the Autofill framework which was introduced in Android 8.0 (API level 26), so you’ll need to optimize your app for Autofill. This means you should add android:autofillHints to your EditText’s XML as shown below:

And this should do it. Now in order to test this feature, you’ll need to enable Autofill on your testing device, if you’re not already using it. To do that, make sure your device is running Android 8.0 (or above) and navigate to Settings > System > Language and Input > Autofill and select an Autofill framework.

Once you login for the first time on the app, Autofill will prompt if you want to save your credentials. If you accept, the next time you login to the app, One Tap UI should display your saved credentials:

Additionally, if you also have a website or a web app on the same Firebase project, you can also enable automatic sign-in between apps and websites, which will allow your users to sign-in to your web app with the password they saved on the mobile app and vice-versa.

And that’s all for today. I hope this helps you implement One Tap sign-in and sign-up in your Firebase Apps. You can find the sample app on Github:

rosariopfernandes/FirebaseAuthOneTapUI

Firebase Auth + One Tap UI on Android was originally published in Firebase Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Firebase News: April 19th — 25th

The Hello World

This is Article 01 of “Firebase News” - a series of articles where you can find the most recent news from the Firebase World. A new article will be posted every 1–2weeks discussing (most of) the changes made on the official tools, SDKs, sample apps and some of the 3rd party libraries. Also expect to see what’s new on: the official Firebase blog, the Firebase Developers Medium publication, the Firebase Youtube Channel and the Firebase Open Source site.

Disclaimer: I do not work for Firebase, Google or any other organization here mentioned. Views, thoughts, and opinions expressed in this article belong solely to me, and not necessarily to these organizations.

Firebase Android SDK

Let’s start with the Android SDK, one of my personal favorites.

A bunch of libraries from the Android SDK were updated. Most notably:

Authentication got a KTX library

General Availability of the KTX libraries was announced by the end of March 2020 and recently, Authentication got its KTX library.

This means that if you use Kotlin to build your Android Apps, you can update your code to be more concise and idiomatic while leveraging some of the Kotlin language features.
To get started with Authentication KTX, simply add the -ktx suffix to the gradle dependency and make sure you’re using version 19.3.1 or above:

dependencies {
  // Other dependencies

  implementation "com.google.firebase:firebase-auth-ktx:19.3.1"
}

This allows you to use some of the new Extension Functions:

You can find more Extensions included in the Auth KTX on the reference docs.

Firebase Crashlytics SDK out of beta

This year, Firebase announced a new Crashlytics SDK, which should replace Fabric’s Crashlytics. The new SDK, that just graduated from beta, is more consistent with the other Firebase SDKs and offers improved APIs. It also includes a SDK for NDK and a gradle Plugin. This gradle plugin should replace the previous fabric plugin that was necessary to use the Crashlytics SDK.

What I personally like about this SDK is the fact that it offers a Singleton just like all the other Firebase libraries. This makes it easier to mock a Crashlytics instance when writing tests for you app. So instead of Fabric.with(getContext(), Crashlytics()), you’ll now be using FirebaseCrashlytics.getInstance().

And to learn how to upgrade to the new Firebase Crashlytics SDK, you can check the migration guide.

Atomic field value increments for the Realtime Time Database

This is a feature that I was hoping for. As you might know, it is hard to keep counters or any other field that might suffer concurrent modifications. In order to solve this problem, you can either make use of Cloud Functions or update your fields using Transactions. Starting in version 19.3.0, you can now use ServerValue.increment(double) to increment your counters atomically.

For example, if you were to increment a user’s score in the database, you can simply do:

val reference: DatabaseReference = ...
reference.child("userId").updateChildren(
  hashMapOf("score" to ServerValue.increment(5)) //incrementing by 5
)

Firebase iOS SDK

Obviously, the iOS SDK couldn’t be left behind. Like the Android SDK, it also got:

• The new Crashlytics SDK out of beta;
• Realtime Database’s atomic field value increments with ServerValue.increment().

Server Admin SDKs

Node.js

• Since this SDK depends on the JavaScript client SDK, it has inherited the admin.database.ServerValue.increment() for atomic field value increments.
• ML Kit for Firebase now provides an API for creating, updating, getting, listing, publishing, unpublishing, and deleting Firebase-hosted custom ML models. You can use this API by calling admin.machineLearning() learn more on the Firebase Documentation.
• Another API that was recently added is the Remote Config API, which enables developers to programmatically manage the set of JSON-formatted parameters and conditions known as the Remote Config template. The API can be used by admin.remoteConfig() and you can see all the available functions on the Reference Docs.

Python

Just like the Node.js Admin SDK, the Python Admin SDK also got the api to manage hosted ML modules. You can use it by importing the ml module: from firebase_admin import ml. More usage details on the Firebase Documentation.

.NET

The Admin .NET Authentication SDK has 2 new APIs: RevokeRefreshTokensAsync()for revoking any previously issued refresh tokens to a user and VerifyIdTokenAsync() to check if a given ID token has been revoked since it was issued.

Firebase Extensions

storage-resize-images now supports WebP

The storage-resize-images extension was backed by the imagemagick npm module, which does not include WebP support. In order to provide WebP support, the Extensions Team changed the extension to use the sharp npm module instead. This change comes in version 0.1.6 of the extension. See the documentation to find out how to upgrade extensions.

Firebase Youtube Channel

A new video from the Build a to-do list app w/ SwiftUI & Firebase Semi-live Series was posted. On this one, Peter Friese shows how to implement Sign in with Apple on iOS using Firebase Authentication for users to sign in with Apple ID.

[Bonus] Firebase Virtual Meetups

This month, Firebase has also been hosting a series of Virtual Meetups aimed at bringing together Firebasers and developers in intimate online settings.
Last week they hosted “Building Secure Apps with Firebase” with a great presentation from Megha Bangalore and this week, on April 29th, they’ll be hosting “Achieving Continuous Deployment with Firebase Remote Config” with Steve Wilber. You can see the schedule for future meetups and/or register to attend on their website.

And that’s it for this week. Bellow you can find the other minor releases that happened over the past week.

As mentioned in the beginning of the article, this is the first one of the series. So please let me know in the comments if this was helpful to you and what would you like to see featured here.

Hat tip to Chet Haase for the amazing job he’s been doing with the Now In Android Blog, Video and Podcast series, which was the inspiration for the creation of this series.

Other Minor Releases

Android

• Analytics 17.4.0 - bug fixes and deprecation of the Install Referrer Broadcast Receiver;
• Cloud Firestore 21.4.3 - limited the number of concurrent document lookups it will perform when resolving inconsistencies in the local cache.
• Cloud Messaging 20.1.6 - Bug fixes
• In-App-Messaging and In-App-Messaging Display 19.0.6 - bug fixes.
• Firebase Instance IID 20.1.6 - improved FirebaseOptions validation. This may not sound like a huge change, but it might show you some errors if you do not provide an api key, an app id and a project id. In some cases, re-downloading the google-services.json file from the Firebase Console might help you fix the errors.
• MLKit Common 22.1.1, Predictions 19.0.7 and Remote Config 19.1.4 - internal changes to later migrate from Firebase Instance IID to Firebase Installations.

iOS

Bug fixes and internal changes on the modules: Analytics, Auth, Cloud Firestore, In App Messaging, FCM and Storage.

JavaScript (Web) 7.14.2

• Cloud Firestore now rejects write operations if they cannot be persisted in IndexedDB. Previously, these errors crashed the client. This should also fix more crashes related to IndexedDB.
• Cloud Messaging - changed to compare hostname instead of the entire URL to decide if there is a matching window client.

Unity 6.14.0

• Cloud Firestore - Firestore.LoggingEnabled is replaced with Firestore.LogLevel for consistency with other Firebase Unity APIs and its getter was removed.
• Crashlytics - (iOS) Removed references to UIWebView APIs to prevent App Store rejections.

Server Admin SDKs

• Node. Auth - Exposed email, email_verified, phone_number, and picture fields from the DecodedIdToken type.
• Go 3.12.1 - Deferred credential loading until required, which allows some APIs like auth.VerifyIDToken() to be called without credentials.
  - Cloud Firestore updated the remote endpoint used by topic management operations.

Firebase Extensions

• firestore-bigquer-export-v0.1.4 - bug fixes

Cloud Functions

• Cloud Functions v3.6.1 - updates TypeScript dependency to fix build issues.

Firebase CLI

• Firebase Tools v8.1.1 - Fixes error when deploying Cloud Functions for Firebase from a project subdirectory.

Desenvolvimento Android mais simples e conciso

“Quanto mais simples e conciso for o código, mais rápido você entenderá o que está acontecendo.” — Paulo Enoque

É por causa da simplicidade e concisão do Kotlin que muitos desenvolvedores têm optado por esta linguagem de programação para realizarem o seu trabalho.

Devo recordar também que em Maio de 2017 a Google anunciou que Kotlin passava a ser uma linguagem oficial para desenvolvimento de aplicações Android. De lá para cá, a adoção desta linguagem e, consequentemente, o número de desenvolvedores Kotlin também aumentaram.

Só um ano e meio depois do Kotlin ser adoptado como linguagem oficial para o Android é que o Firebase incluiu esta linguagem na sua documentação oficial :

Doug Stevenson 🔥 on Twitter

@Firebase code samples for Android are starting to get @kotlin samples to go with Java! Thanks to @daggerdwivedi and @_rpfernandes for the assists here. It's a tremendous effort overall, and it's great to have help from the community. https://t.co/PMlAViMf9F #AndroidDev

Depois de adicionar suporte para o Kotlin na Documentação Oficial, a equipa do Firebase decidiu adicionar também algumas Extension Functions no SDK Android do Firebase (pela mesma razão que eu criei o fireXtensions).

Leia este artigo completo em developingwith.firebaseapp.com .

Parte 2 — Linguagem Natural e Identificação de Linguagem

Este artigo faz parte da série Explorando o ML Kit for Firebase:

1. O novo serviço de Machine Learning do Firebase
2. Linguagem Natural e Identificação de Linguagem

No ano passado, a equipa do Firebase anunciou um novo SDK que foi adicionado à plataforma — o ML Kit. O ML Kit é um SDK que permite que desenvolvedores utilizem Machine Learning em aplicativos Android e iOS. Se você ainda não conhece o ML Kit, leia o primeiro artigo desta série.

Quando foi anunciado, o ML Kit só tinha funcionalidades relacionadas com o ramo Visão Computacional (Computer Vision). Mas hoje foi adicionada a primeira funcionalidade do ramo Processamento de Linguagem Natural (Natural Language Processing) — a chamada identificação de linguagem (Language Identification).

Assim, o ML Kit conta agora com 2 pacotes: o ML Vision (sobre o qual falei no artigo anterior) e o Natural Language (o tema deste artigo).

Natural Language

Enquanto que o ML Vision aplica conceitos de Machine Learning em imagens, o pacote Natural Language usa ML no processamento de texto.
Atualmente a única funcionalidade inclusa neste pacote é a Identificação de Linguagem, só está disponível para Android ou iOS e só é possível utilizá-la on-device, pois ainda não tem uma versão cloud.

Para ter o Natural Language na sua app, você só tem de:

1. Adicionar o Firebase ao projecto;
2. Adicionar a dependência do Natural Language no ficheiro build.gradle:

implementation 'com.google.firebase:firebase-ml-natural-language:18.1.1'

Identificação de linguagem

Como o nome sugere, esta funcionalidade analisa um texto e identifica em que linguagem/idioma esse texto está escrito.

Para utilizar esta funcionalidade, você tem de adicionar a sua dependência no build.gradle:

implementation 'com.google.firebase:firebase-ml-natural-language-language-id-model:18.0.2'

E na sua Activity/Fragment crie um objecto do tipo FirebaseLanguageIdentification :

val identification = FirebaseNaturalLanguage.getInstance().languageIdentification

Esta funcionalidade pode ser usada de 2 maneiras:

1. Identificar a linguagem mais provável
   É como clicar no botão “Estou com sorte” (I’m feeling lucky) do Google Search. Será mostrada a linguagem com maior probabilidade.
   Basta utilizar o método:

private fun identificarLinguagemMaisProvavel(texto: String) {

identification.identifyLanguage(texto)
        .addOnSuccessListener { linguagem ->
            if (linguagem == "und") {
                // Linguagem desconhecida
            } else {
                // Mostrar a linguagem na UI
            }
        }
        .addOnFailureListener { e ->
            // Ocorreu um erro
        }
}

Por padrão, o SDK irá mostrar a linguagem mais provável que tenha confidência maior do que 0,5 . Mas se você quiser especificar o número mínimo de confidência, você pode criar um objecto FirebaseLanguageIdentificationOptions e passar para o identificador:

val options = FirebaseLanguageIdentificationOptions.Builder()
    .setConfidenceThreshold(0.5f)
    .build()

val identification = FirebaseNaturalLanguage.getInstance()
    .getLanguageIdentification(options)

2. Identificar todas linguagens possíveis:
Para ver todas as possibilidades, é só utilizar o método:

private fun identificarLinguagensPossiveis(texto: String) {
    identification.identifyPossibleLanguages(texto)
        .addOnSuccessListener { linguagens ->
            var output = ""
            for (linguagem in linguagens) {
                output += linguagem.languageCode + " (${linguagem.confidence})\n"
            }
            // Mostrar o output na UI
        }
        .addOnFailureListener { e ->
            // Ocorreu um erro
        }
}

Por padrão, serão mostradas todas linguagens com confidência maior do que 0,01. Mas se você quiser especificar o número mínimo de confidência, crie um objeto FirebaseLanguageIdentificationOptions como mostrado no método 1 (linguagem mais provável).

Note que a String retornada pelo SDK é o código BCP-47 da linguagem. Você pode encontrar a lista de todas as linguagens suportadas aqui.

Veja o código completo da Activity aqui:

Identificar linguagens no Android com o Firebase é tão simples quanto isso. Esta funcionalidade pode não parecer útil, mas é sim em alguns casos de uso. Por exemplo: se você tiver criado uma aplicação que é uma espécie de um blog, você pode usar a identificação de linguagens para analisar os blog posts que cada utilizador lê. Se você souber que um certo utilizador lê muitos posts em chinês, talvez seja uma boa ideia recomendar-lhe mais posts em chinês.

Pude notar que diferentemente do pacote ML Vision, o SDK do Natural Language não ocupa tanto espaço assim. Quando testei o ML Vision pela primeira vez, o APK gerado tinha aproximadamente 15Mb. Enquanto usando o Natural Language, o APK tem aproximadamente 5Mb. Acho que é uma diferença compreensível, pois o SDK do ML Vision certamente usa modelos mais complexos e provavelmente leva consigo algumas imagens usadas para o treinamento destes modelos.

Vale lembrar que esta é só a primeira funcionalidade que o Firebase traz para o pacote Natural Language. É provável que ao longo do tempo sejam adicionadas mais funcionalidades para este pacote, afinal de contas vem aí o Cloud Next 19 e o Google I/O 2019 — dois eventos anuais onde a Google tradicionalmente anuncia novas funcionalidades do Firebase. Irei atualizar este artigo sempre que houverem novidades neste pacote, então continue me seguindo para não perdê-las.

Caso tenha alguma dúvida ou sugestão, deixe abaixo nos comentários. Se você estiver tentando usar o ML Kit e teve um problema, coloque ele no StackOverflow, explicando o que você fez e qual foi o erro que teve. De certeza que você obterá ajuda de mim ou de alguém da comunidade. 🙂

Explorando o ML Kit for Firebase was originally published in GDG Maputo on Medium, where people are continuing the conversation by highlighting and responding to this story.

Firebase Cloud Functions — Pesquisa de Texto na Base de dados

Algolia & ElasticSearch vs Tocha

Este artigo é parte da série Firebase Cloud Functions:

1. O que é Firebase Cloud Functions?
2. Firebase Cloud Functions — Como começar?
3. Firebase Cloud Functions + Cloud Messaging
4. Firebase Cloud Functions — Limpeza e Manutenção da Realtime Database
5. Firebase Cloud Functions — Chame uma função na sua app
6. Firebase Cloud Functions — Pesquisa de Texto na Base de Dados

Uma das funcionalidades mais requisitadas à equipe do Firebase é a possibilidade de fazer a clássica “Pesquisa de Texto” na Realtime Database ou no Cloud Firestore. Para quem vem do SQL, esta é a famosa operação LIKE, que é bastante utilizada em caixas/campos de procura de texto.

Na altura em que a Realtime Database era o único serviço de Base de Dados do Firebase, esta funcionalidade já era pedida por desenvolvedores e, como solução, o Firebase trouxe a Flashlight — uma biblioteca que conecta-se à plataforma ElasticSearch para permitir estas pesquisas.

Para quem não conhece, ElasticSearch é uma plataforma que faz a indexação de dados para futuras pesquisas. Ela funciona da seguinte forma: Você envia para a plataforma os dados que precisam ser indexados (neste caso, o nó da Realtime Database em que pretende pesquisar) e para fazer a pesquisa você envia uma requisição HTTP para a REST API deles e a API retorna os resultados da sua pesquisa.

Quando surgiu o Cloud Firestore, vimos várias funcionalidades de consulta(querying) de dados sendo adicionadas, que podemos dizer que são melhorias quando comparadas com as funcionalidades de consulta que existiam na Realtime Database. Mas infelizmente, ainda nada sobre a Pesquisa de Texto. Como solução, o Firebase criou um Tutorial de como conectar Firestore à Algolia para Pesquisa de Texto. Algolia é outra plataforma de indexação muito similar ao ElasticSearch, inclusive funcionam da mesma maneira.

Apesar destas plataformas parecerem ser a solução perfeita, existem alguns aspetos a ter em conta:

1. Você está partilhando os seus dados com plataformas de terceiros;
2. É recomendado fazer as requisições em um servidor, pois estas plataformas dão-lhe uma Chave (API KEY) que não deverá ser exposta em aplicações cliente.

Segundo o tutorial do Firebase, o 2º ponto que mencionei não será um problema, afinal de contas, existe o Firebase Cloud Functions que permite executar algumas funções no lado do servidor (server-side).

Apesar da combinação “Cloud Functions +Algolia/ElasticSearch” ser perfeita, ela tem um inconveniente: quando estiver a utilizar o plano grátis (Spark Plan) do Firebase, as Cloud Functions não podem enviar requisições para endereços externos (que não fazem parte da Google). Só quem estiver a utilizar um dos planos pagos (Flame ou Blaze Plan) é que tem a permissão para fazer isso.
Isto implica que caso você queira enviar requisições à Algolia/ElasticSearch através das Cloud Functions, você precisa adicionar o seu cartão de crédito e optar por um dos planos pagos.

Adicionar um cartão de crédito não deve ser problema para alguns, até porque mesmo depois de adicionar, eles não irão cobrar-lhe nada até que atinja um certo limite (conheça os limites na tabela de preços) e este limite é alto o suficiente para que uma aplicação de pequena escala não o atinja em pouco tempo.

Mas por outro lado, existem desenvolvedores que não pretendem utilizar estes planos, mesmo porque provavelmente não utilizarão nem metade das funcionalidades oferecidas ou porque estão a desenvolver apenas um protótipo. Foi a pensar nestes desenvolvedores que decidi criar uma forma de fazer a Pesquisa de Texto no plano grátis (Spark).

Tocha — Pesquisas de Texto no Plano Spark

Tocha é uma biblioteca Open Source, por mim desenvolvida, que permite fazer pesquisas de texto no Cloud Firestore e na Realtime Database mesmo que o seu projeto ainda esteja no plano grátis (Spark). É ideal para protótipos ou pequenas aplicações Android/iOS.
E tal como as outras soluções de pesquisa de texto para o Firebase, esta biblioteca funciona através de Cloud Functions.

Como começar

Vou assumir que você já sabe criar e fazer o deploy de Cloud Functions. Caso não, leia o segundo artigo desta série.

1. No directório functions do seu projeto Firebase, abra o ficheiro package.json e certifique-se que a sua cloud function está a utilizar o NodeJS na versão 8:

{
  // ... name, description, dependencies, etc
  "engines": {
    "node": "8"
  }
}

2. Instale o Tocha, abrindo a terminal e utilizando o comando:

npm install tocha

3. Por fim, abra o ficheiro index.js do directório functions e importe a(s) funcionalidade(s) do Tocha que você precisa:

const functions = require('firebase-functions');

// ... você pode importar mais bibliotecas aqui ...

const tocha = require('tocha');

// Para importar Pesquisa de texto no Cloud Firestore:
exports.searchFirestore = tocha.searchFirestore;

// Para importar Pesquisa de texto na Realtime Database:
exports.searchRTDB = tocha.searchRTDB;

// ... você pode declarar mais funções aqui ...

E pronto. Agora só basta fazer o deploy das novas funções:

firebase deploy --only functions

Vamos Experimentar

Suponhamos que temos uma collection no Cloud Firestore que armazena tarefas para uma app de organização de tarefas. Vamos chamar esta collection de “tarefas”:

Como vemos na imagem, a collection tem apenas 2 documentos, mas vamos supor que já tenhamos armazenado centenas de tarefas e já não nos lembramos à quem tínhamos de ligar para felicitar.
Vamos então utilizar o Tocha para pesquisar por tarefas que tenham a palavra “Ligar” no título. Para isso, temos de criar uma nova collection com o nome “tocha_searches”. Nesta collection vamos adicionar o seguinte documento:

{
  "collectionName": "tarefas", // collection que vamos pesquisar
  "fields": ["titulo"], // campo(s) a pesquisar
  "query": "Ligar*" // texto a ser encontrado
}

Ao adicionar este documento, a nossa Cloud Function será invocada e se estiver tudo correto, ela irá adicionar um campo response ao nosso documento contendo:

• isSuccessful (boolean) — este campo terá o valor true se a nossa pesquisa for bem sucedida ou false caso contrário.
• result — se a pesquisa for bem sucedida, este campo será um array contendo as tarefas que foram encontradas como resultado da pesquisa. Nota: Se ocorrer algum erro e isSuccessful for false, o campo result não existirá.
• errorMessage — só existe se tiver ocorrido algum erro e o valor do campo é uma String explicando a causa do erro.

Então a nossa resposta ficará algo como:

Num cenário real, só teríamos de ler o valor deste campo result e mostrá-lo na UI da nossa aplicação Android/iOS. E pronto, pesquisa implementada com sucesso.

Limitações

Tocha ainda é um projeto em desenvolvimento e possui algumas limitações:

1. Firestore/RTDB Security Rules não se aplicam na pesquisa. Isto significa que todas pesquisas realizadas assumem que o utilizador autenticado é administrador e tem acesso à toda base de dados.
2. Ainda não existe um SDK client-side para executar a pesquisa, mas já comecei a desenvolver um para android(tocha-android).

Vale lembrar que é um projeto Open Source, então você também é convidado à contribuir 🙂 O código-fonte e mais informações podem ser encontrados no GitHub:

rosariopfernandes/Tocha

Espero que esta biblioteca ajude-o no desenvolvimento de protótipos e/ou pequenas aplicações móveis com pesquisa de texto no Firebase. 🙂

Caso tenha alguma dúvida ou sugestão, deixe abaixo nos comentários. Se você estiver tentando usar a Tocha e teve algum problema, abra um issue no GitHub explicando o que você fez e qual foi o erro que teve.

Firebase Cloud Functions — Pesquisa de Texto na Base de dados was originally published in GDG Maputo on Medium, where people are continuing the conversation by highlighting and responding to this story.

Parte 4 — Testes Unitários

Na parte 3 desta série de artigos mostrei como utilizar o Simulador de Regras da Realtime Database. O simulador é uma ferramenta muito útil e que ajuda bastante na hora de testar as nossas regras online.

Mas hoje, durante o Firebase Summit 2018, foram lançadas 2 novas ferramentas que ajudam também na hora de testar regras: o Emulador da Realtime Database e o módulo firebase-testing da Firebase CLI. Neste artigo mostro como funcionam estas ferramentas e como elas facilitam-nos quando queremos verificar o comportamento das nossas regras de segurança.

Realtime Database Emulator

O emulador da Realtime Database é uma ferramenta que permite simular uma instância de uma database na nossa máquina local. Todas as operações que executamos na nossa Realtime Database podem ser simuladas localmente no emulador. A única diferença é que o emulador não está interligado aos outros serviços do Firebase.

Instalação

Para instalar o emulador, temos de executar os seguintes comandos:

firebase --open-sesame emulators
firebase setup:emulators:database

Iniciar

Agora que temos o emulador instalado, podemos iniciá-lo usando o comando: firebase serve --only firestore. Ao introduzir o comando, deverá aparecer uma mensagem dizendo “Listening on port 9000” no seu ecrã.

Geralmente a Realtime Database pode ser acedida através da URL https://<nome-da-database>.firebaseio.com/caminho/dos/dados.json. Ao iniciar o emulador, a mesma database pode ser acedida também pela URL http://localhost:9000/caminho/dos/dados.json?ns=<nome-da-database>.

Quando você inicia o emulador, a realtime database simulada é criada com as regras privadas (.write e .read em false).

Módulo node.js firebase-testing

Este módulo permite-nos escrever testes unitários para a nossa database. Neste artigo, vamos criar um diretório chamado teste, e neste diretório vamos instalar o nosso módulo firebase-testing. Para isso, basta utilizarmos o comando:

npm install --save @firebase/testing

async/await

Antes de começarmos a escrever os testes unitários, há 2 conceitos que podem ser novos para você: async e await.

Você já deve saber que as funções de leitura e escrita do Firebase funcionam de forma assíncrona. Mas como os nossos testes serão executados em sequência, não podemos fazê-los de forma assíncrona, pois a sequência se perderá.

E para nos ajudar com isso, o JavaScript possui o async e o await que permitem-nos esperar pelo resultado de uma operação antes de ir para a próxima. Por exemplo, para ler um utilizador de forma assíncrona no JavaScript, você faria:

function lerUtilizador(uid)
{
  rootRef.child("utilizadores").child(uid).once('value', function(snapshot){
      var utilizador = snapshot.val();
      //Mostrar o utilizador
  });
}

Para fazer a mesma leitura, de forma síncrona, você deve fazer:

async function lerUtilizador(uid)
{
  var snapshot = await rootRef.child("utilizadores").child(uid).once('value');
  var utilizador = snapshot.val();
  //Mostrar o utilizador
}

Há uma coisa a notar: o async serve para anotar funções e o await só pode ser utilizado em funções que foram declaradas com a anotação async.

Você pode aprender mais sobre async e await neste post do Jose Pedro Dava.

Escrever Testes Unitários

Para escrever os nossos testes, o firebase-testing possui as funções:

• initializeTestApp({ databaseName, auth }) — simula uma app que está a ser acedida por um utilizador autenticado, que é especificado no parâmetro auth.
• initializeAdminApp({ databaseName }) — simula uma app que está ser acedida com privilégios de administrador (é como usar o Admin SDK ou a REST API para aceder à database).
• loadRules({ databaseName , rulesPath }) — carrega as regras de segurança que iremos testar.
• apps() — retorna a lista de todos as apps que foram inicializadas para simulação.
• assertFails(pr: Promise) — verifica se uma escrita/leitura irá falhar.
• assertSucceeds(pr: Promise) — verifica se uma escrita/leitura irá ser executada com sucesso.

Agora que conhecemos as funções, podemos então escrever testes unitários para as regras (veja database.rules.json) da database que temos usado durante esta série de artigos (veja MyDatabase.json).

Por exemplo, uma regra que definimos foi: “Utilizadores só podem enviar mensagens para grupos que fazem parte”. A regra escrita foi:

E o código JavaScript para enviar a mensagem seria algo como:

rootRef.child(“mensagens/g1”).push().set(“Olá Mundo!”);

Então usamos este mesmo código simulando um utilizador autenticado. Podemos verificar se o utilizador de uid=”uid1" pode realmente escrever no grupo com a chave “g1” (que ele faz parte):

let firebase = require("@firebase/testing");

let app = firebase.initializeTestApp({ databaseName: "MinhaDB", auth: {uid:"uid1"} });

await firebase.assertSucceeds(app.database().ref("mensagens/g1").push().set("Olá Mundo"));

E podemos nos certificar que ele não tem acesso ao grupo “g2”:

await firebase.assertFails(app.database().ref("mensagens/g2").push().set("Olá Mundo"));

Juntando os dois, o nosso ficheiro index.js(no directório teste) ficaria assim:

Este é um dos exemplos mais simples. Completei o ficheiro index.js para testar todas as regras que foram definidas, e ficou assim:

Depois de escrever os testes, temos de executá-los. Para isso, voltamos à terminal e (no diretório parente do diretório teste) executamos o comando npm test teste. Você deverá ter um output semelhante à este:

E por hoje é tudo. Espero que você tenha compreendido e que comece também a escrever testes unitários para a sua database. ;)

Caso tenha alguma dúvida ou sugestão, deixe abaixo nos comentários. Se você estiver tentando escrever testes unitários e teve um problema, coloque ele no StackOverflow, mostrando o que você fez e qual foi o erro que teve. De certeza que você obterá ajuda de mim ou de alguém da comunidade. 🙂

Como funcionam as regras de segurança do Firebase na Realtime Database? was originally published in GDG Maputo on Medium, where people are continuing the conversation by highlighting and responding to this story.

Mudando a forma como você utiliza o Firebase no Android

ATUALIZAÇÃO 29/09/2019: O fireXtensions foi descontinuado a favor das bibliotecas KTX oficiais do Firebase. Obrigado a todos que contribuiram, apoiaram ou utilizaram o fireXtensions.

18 de Maio de 2017 foi o dia em que a Google anunciou, durante o Google I/O, que Kotlin passa a ser (oficialmente) uma linguagem para desenvolvimento de aplicações Android. Isso porque:

Kotlin is expressive, concise, and powerful.
(Kotlin é expressivo, conciso e poderoso)

Essa foi uma das melhores novidades do I/O, pois esta linguagem traz várias funcionalidades que facilitam a vida dos desenvolvedores e de certa forma melhora a produtividade deles. Se você não conhece as funcionalidades da linguagem, recomendo que leia esta série de artigos do Paulo Enoque:

1. Introdução a Kotlin
2. Sintaxe básica do Kotlin
3. Detalhes avançados sobre Kotlin
4. Kotlin Android Extensions

Kotlin Extensions

Uma funcionalidade que, em particular, chamou a minha atenção foi Kotlin Extensions. Esta funcionalidade permite que você adicione novos métodos à classes que não são suas, sem ter de herdar (o famoso extends do java) dessa classe. Por exemplo: eu posso criar um método que verifica se uma String contém ponto de exclamação(!), algo como:

fun contemPontoExclamacao(umaString: String): Boolean {
    return umaString.contains('!')
}

Mas para usar o método, eu tenho de chamar da seguinte forma: contemPontoExclamacao("Olá Mundo!"). Isso parece ok, mas imagine se eu tiver de chamar o método em várias classes — teria de declarar o método em todas elas ou declará-lo em uma só classe e definí-lo como estático. Ou até criar uma classe MinhaString que herda da classe String e implementa o método contemPontoExclamacao(). Depois teria de mudar o tipo de dado de todas as Strings do meu programa para que passasse a ser do tipoMinhaString.

Utilizando Kotlin Extensions, eu posso fazer com que este método faça parte da classe String:

fun String.contemPontoExclamacao(): Boolean{
    return contains('!')
}

E então posso chamá-lo em qualquer classe, sempre da mesma forma:

"Olá Mundo!".contemPontoExclamacao()
// ou:
val frase = "Olá Mundo"
frase.contemPontoExclamacao()

Como você pode ver, Kotlin simplifica o código que temos de escrever. Muitos desenvolvedores (a google inclusive) aproveitaram disso para desenvolver bibliotecas que tornam o desenvolvimento Android mais simples. Falo de bibliotecas como Android KTX, Anko, Nahu, entre outras.

FireXtensions

Foi inspirado nessas bibliotecas que decidi desenvolver o fireXtensions. fireXtensions é uma biblioteca que vem para simplificar a forma como nós (desenvolvedores) executamos operações no Firebase. Atualmente, a biblioteca suporta a Realtime Database e Cloud Firestore.

Por exemplo:
Para ler utilizadores da Realtime Database com Kotlin, você utilizaria o código:

ref.addValueEventListener(object: ValueEventListener {
    override fun onDataChange(dataSnapshot: DataSnapshot) {
        val utilizadores = ArrayList<Utilizador>()
        for (snapshot in dataSnapshot.children) {
            val utilizador = dataSnapshot.getValue(Utilizador::class.java)
            utilizadores.add(utilizador!!)
        }
        // Mostrar os utilizadores na UI
    }

    override fun onCancelled(error: DatabaseError) {
        // Mostrar o erro
    }
})

Com fireXtensions:

ref.observeChildren<Utilizador> { utilizadores, error ->
    utilizadores?.let {
        // Mostrar os utilizadores na UI
    }
    error.let {
        // Mostrar o erro
    }
}

Fica mais simples, não é?

Exemplo 2: Ler dados da cidade “Maputo que está na coleção “cidades” do Firestore:

val docRef = db.collection("cidades").document("Maputo")
docRef.get().addOnCompleteListener { task ->
    if (task.isSuccessful()) {
        val cidade = task.result.toObject(Cidade::class.java)
        // Mostrar a cidade
    }
}

Com fireXtensions:

docRef.getDocument<Cidade>() { cidade, _ ->
    cidade?.let {
        // Mostrar a cidade
    }
}

Como fazer essa magia?

Utilizar o fireXtensions na sua aplicação é muito simples, basta seguir as instruções encontradas no site:

1. Adicionar o maven do jitpack para o build.gradle do projecto:

allprojects {
        repositories {
            ...
            maven { url 'https://jitpack.io' }
        }
}

2. Adicionar a dependência ao build.gradle da app. Aqui você tem 2 opções:

• Adicionar as extensions para Realtime Database e Cloud Firestore:

dependencies {
        implementation 'com.github.rosariopfernandes:fireXtensions:0.3.4'
}

• Ou adicionar as extensions só para Realtime Database ou só para Cloud Firestore:

dependencies {

        // Use apenas uma:
        // Importar só a database
        implementation 'com.github.rosariopfernandes.fireXtensions:database:0.3.4'

        // ou importar só o firestore
        implementation 'com.github.rosariopfernandes.fireXtensions:firestore:0.3.4'
}

Conheça todas as extensions oferecidas pela biblioteca nos tutoriais:

• Realtime Database;
• Cloud Firestore.

Contribuir para a biblioteca

fireXtensions é open source (sob a MIT License) e você pode contribuir no GitHub. Abra um issue para sugerir uma alteração, pode ser uma nova funcionalidade ou correção de bugs. Se a sua alteração for aprovada, aí você poderá mandar um Pull Request para fazê-la ou esperar que alguém o faça.

Espero que esta biblioteca simplifique a forma como você escreve o seu código Android e que ajude-lhe a melhorar a sua produtividade. 🙂 Caso tenha alguma dúvida ou sugestão, deixe abaixo nos comentários. Se você estiver tentando usar o fireXtensions e teve um problema, abra um issue no GitHub explicando o que você fez e qual foi o erro que teve.

Apresentando o fireXtensions was originally published in GDG Maputo on Medium, where people are continuing the conversation by highlighting and responding to this story.