Android Core

Synchronize Android Things with Firebase: Control RGB LED remotely in real time

This article describes how to synchronize Android Things with Firebase so that we can control an RGB LED remotely in real time. In more details, this project shows how to control a remote RGB LED real time over the air changing some value in the Firebase database. As you may already know Android Things is a branch of Android OS therefore Android Things supports Firebase out of the box. This tutorial describes all the step necessary to integrate Android Things with Firebase and how to connect the RGB LED to the Android Things board. Synchronizing Android Things with Firebase this IoT project changes in real time the LED color according to the value we set using Firebase.

In this tutorial, we assume you are already familiar with Android Things OS and you have already installed it. If this is the first time you use Android Things you can read how to install the Android Things OS on your board. This Android Things IoT project can be further extended so that we can synchronize Android Things with Firebase using different types of information.  There are several scenarios where the synchronization between Android Things and Firebase plays an important role so it is important to know how to do it.

Before diving into this Android Things Firebase synchronization project it is useful to clarify which components we will use:

  • Raspberry Pi 3 (or an Android Things compatible board)
  • a common anode RGB LED

Moreover, you need a Firebase account so that you can test this Android Things IoT project.

How to synchronize Android Things with Firebase Project overview

Now we know the components we will use in this project, it is useful to have an overview of this synchronization project so that you can have a clear overview. The picture below describes how the project works:

Once we have connected Android Things to Firebase whenever we change a value in the Firebase database, the new value triggers an event so that the synchronization between Android Things and Firebase database takes place transferring the new value to the Android Things board that in turn set the RGB LED color.

How to setup Firebase with Android Things

In this section, we will describe how to configure a Firebase project so that we can integrate it with Android Things. The first step is creating a free account. Once you have your free account you can create a new Firebase project as shown below:

The next step is configuring your app:

During this configuration process, you have to follow the Firebase instructions. Finally, before interacting with Firebase it is necessary to modify the security aspects:

Finally, we can configure our database that will hold the LED colors:

At app level, the build.gradle looks like:

dependencies {
  provided ''
  compile ''
  compile ''
  apply plugin: ''

How to use Android Things with Firebase

Once you have followed the instruction during the Firebase project setup you are ready to start coding the Android Things app. All the Firebase dependencies and configuration are now ready and we can dive into the Android Things project. As described previously, the Android Things app has to listen to the Firebase value changes and react controlling the RGB LED.

The RGB LED has 3 pins one for each color and we connect them to the Raspberry GPIO pins. According to the value in the Firebase database, the Android Things app turns on or off each GPIO pins controlling, in this way, the LED color. This app does not have a UI because the Android Things is controlled remotely.

In order to create this Android IoT app, it is necessary to create a new Android Things project cloning the template project. If you are new and this is the first time you approach the Android Things you can follow this tutorial describing how to get started with Android Things.

In the previous step, we have created a table in the Firebase database containing three different fields representing the LED colors. In order to hold the Firebase new values, we have to create a simple POJO class that represents the table:

public class RGBColor {

  private int red;
  private int green;
  private int blue;

  public RGBColor() {}

  public int getRed() {
    return red;

  public void setRed(int red) { = red;

  public int getGreen() {
    return green;

  public void setGreen(int green) { = green;

 public int getBlue() {
   return blue;

 public void setBlue(int blue) { = blue;

We will use this simple class to control the GPIO pins.

Now, we can focus our attention on the main activity that will handle all the synchronization between Android Things and Firebase. To this purpose, you can use the template Activity already configured in the project. In onCreate(), we have to initialize the connection with Firebase and get the reference to the PeripheralManagerService:

protected void onCreate(Bundle savedInstanceState) {
  Log.d(TAG, "onCreate");
  databaseRef = FirebaseDatabase.getInstance().getReference();
  pms = new PeripheralManagerService();

where databaseRef is an instance of DatabaseReference. Moreover, the app adds a listener to the databaseRef to receive notification when values will change. Moreover, in this method we initialize the pins that the app uses to control the LED:

private void initPin() {
   try {
     redPin = pms.openGpio("BCM26");
     greenPin = pms.openGpio("BCM6");
     bluePin = pms.openGpio("BCM5");
  catch (IOException ioe) {
     Log.e(TAG, "Unable to open pins");

It is important to notice, that in the code above, the Android Things IoT app references the pin names directly. This is not a best practice if you want that your app
is portable on different boards. Anyway, for this tutorial, we can use the pin direct access.

Synchronizing Android Things with Firebase

Once the “hardware” part is ready and the pins are initialized, it is necessary to receive notification when Firebase values change. To this purpose, it is necessary to define a listener:

private ValueEventListener veListener = new ValueEventListener() {
  public void onDataChange(DataSnapshot dataSnapshot) {
     RGBColor color = dataSnapshot.getValue(RGBColor.class);

     // update pins
    updatePin(redPin, color.getRed());
    updatePin(greenPin, color.getGreen());
    updatePin(bluePin, color.getBlue());

  public void onCancelled(DatabaseError databaseError) {}

The code above is really simple, the onDataChange method is invoked when the one or more values in the database are changed. The class RGBColor, described previously, holds the new values. The last step is updating the pin setting the right color:

private void updatePin(Gpio pin, int value) {
  try {
    pin.setValue( value > 0 ? false : true);
  } catch (IOException e) {

In this example, we suppose that if the value is more than zero then the PIN is on otherwise if off. Notice that we are using a common cathode LED, for this reason, we turn off the pin.

Now you can play using the Firebase console changing the RGB values and notice that the LED change color.


At the end of this article, you gained the knowledge about how to synchronize Android Things with Firebase so that we can control in real time the Android Things board remotely.

Published on Java Code Geeks with permission by Francesco Azzola, partner at our JCG program. See the original article here: Synchronize Android Things with Firebase: Control RGB LED remotely in real time

Opinions expressed by Java Code Geeks contributors are their own.

Francesco Azzola

He's a senior software engineer with more than 15 yrs old experience in JEE architecture. He's SCEA certified (Sun Certified Enterprise Architect), SCWCD, SCJP. He is an android enthusiast and he has worked for long time in the mobile development field.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button