How to use Firebase EventListener as a background service in android?

Question

I am trying to make a background service that runs even if the application is closed. this services is supposed to listen to Firebase changes, and start the application according to a trigger. I don't know whether I am missing something in the code or not even close to the right answer, but here is my code :

public class FireBaseService extends Service {

private HashMap<String, String> fireBaseBattery;

@Override
public void onCreate() {
    super.onCreate();

    fireBaseBattery = new HashMap<>();
    final Firebase firebaseRef_Battery = new Firebase("the url i want to take data from");

    firebaseRef_Battery.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            if (dataSnapshot.getValue() != null) {
                fireBaseBattery = (HashMap<String, String>) dataSnapshot.getValue();
                String battery = (String) fireBaseBattery.get("battery");
                int battery_int = Integer.parseInt(battery);

                System.out.println("SERVICE FIREBASE : " + battery);
                if (battery_int <= 10) {
                    Intent intent = new Intent(getApplicationContext(), MainActivity.class);
                    startActivity(intent);
                }
            }
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {

        }
    });
}

@Nullable
@Override
public IBinder onBind(Intent intent) {
    return null;
}

}

And this is the manifest :

    <uses-permission android:name="android.permission.READ_SMS" />
    <application
        android:name=".ParseApplication"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

<service android:enabled="true"
        android:name=".FireBaseService">
    </service>
        <activity
            android:name=".Launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme.NoActionBar">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
 </application>

</manifest>

Edit : I added a line in MainActivity.class to start the service

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    startService(new Intent(this, FireBaseService.class));
}

Answer 1

I edited the Application as following :

1. The Service class extends Activity and not Service
2. I added the service manifest inside the application tag directly as the following :

android:name=".FireBaseService"

3. There is no need to start the service from main activity.

Edited Manifest:

 <uses-permission android:name="android.permission.READ_SMS" />
<application
    android:name=".FireBaseService"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">

    <activity
        android:name=".Launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme.NoActionBar">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

Answer 2

What you want, it just startForeground you can do it. For safety reasons, the user should be aware that something is running in the background.

Answer 3

I think I have cracked it.

I have solved it using a child event listener and a sticky service. Here is how it goes:

I first add a child event listener in my data store class:

class DataStore {

        private static DataStore sDataStore;
        private List<EmergencyZoneEventListener> mEmergencyZoneEventListeners = null;

        static DataStore get() {
            if (sDataStore == null) {
                sDataStore = new DataStore();
            }

            return sDataStore;
        }

        void addEmergencyZoneEventListener(EmergencyZoneEventListener emergencyZoneEventListener) {
            if (emergencyZoneEventListener != null && !sDataStore.mEmergencyZoneEventListeners.contains(emergencyZoneEventListener)) {
                sDataStore.mEmergencyZoneEventListeners.add(emergencyZoneEventListener);
            }
        }

        void removeEmergencyZoneEventListener(EmergencyZoneEventListener emergencyZoneEventListener) {
            mEmergencyZoneEventListeners.remove(emergencyZoneEventListener);
        }

        DataStore() {
            FirebaseDatabase.getInstance().getReference("/emergencyZones/").
                    addChildEventListener(new ChildEventListener() {
                        @Override
                        public void onChildAdded(DataSnapshot dataSnapshot, String s) {
                            emergencyZoneAddedOrChangedRemotely(dataSnapshot);
                        }

                        @Override
                        public void onChildChanged(DataSnapshot dataSnapshot, String s) {
                            emergencyZoneAddedOrChangedRemotely(dataSnapshot);
                        }

                        @Override
                        public void onChildRemoved(DataSnapshot dataSnapshot) {
                            emergencyZoneRemovedRemotely(dataSnapshot);
                        }

                        @Override
                        public void onChildMoved(DataSnapshot dataSnapshot, String s) { }

                        @Override
                        public void onCancelled(DatabaseError databaseError) {
                            Log.w(TAG, "onCancelled: " + databaseError.getMessage() + ": "
                                    + databaseError.getDetails());
                        }
                    });
        }
    }

And here is what happens within emergencyZoneAddedOrChangedRemotely:

private void emergencyZoneAddedOrChangedRemotely(DataSnapshot dataSnapshot) {
        EmergencyZone ez = dataSnapshot.getValue(EmergencyZone.class);
        if (ez == null || ez.getKey() == null) {
            Log.w(TAG, "emergencyZoneAddedRemotely: EmergencyZone or getKey is null");
            return;
        }

        for (EmergencyZoneEventListener listener : mEmergencyZoneEventListeners) {
            listener.onEmergencyZoneAdded(ez);
        }
    }

Here, each time a change occurs in the Firebase, and the Firebase fires my ChildEventListener I in turn fire my locally attached listeners using listener.onEmergencyZondeAdded.

And finally the sticky service:

public class NotificationService extends Service {

    private static final String TAG = "NotificationService";

    private DataStore mDataStore;
    private DataStore.EmergencyZoneEventListener mEmergencyZoneEventListener = new DataStore.EmergencyZoneEventListener() {
        @Override
        public void onEmergencyZoneAdded(EmergencyZone emergencyZone) {
            Log.i(TAG, "onEmergencyZoneAdded: " + emergencyZone.getKey());
        }

        @Override
        public void onEmergencyZoneChanged(EmergencyZone emergencyZone) {
            Log.i(TAG, "onEmergencyZoneChanged: " + emergencyZone.getKey());
        }

        @Override
        public void onEmergencyZoneRemoved(EmergencyZone emergencyZone) { }
    };

    public static Intent getIntent(Context packageContext) {
        return new Intent(packageContext, NotificationService.class);
    }

    @Override
    public void onCreate() {
        Log.i(TAG, "onCreate: NotificationService is being created...");
        mDataStore = DataStore.get(this);
        mDataStore.addEmergencyZoneEventListener(mEmergencyZoneEventListener);
        QueryPreferences.setIsNotificationsOn(this, true);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG, "onStartCommand: Received start id " + startId + ": " + intent);
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy: NotificationService is being destroyed...");
        mDataStore.removeEmergencyZoneEventListener(mEmergencyZoneEventListener);
        QueryPreferences.setIsNotificationsOn(this, false);
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

I tested this solution when the application was exited and when phone was asleep and it worked neatly. When I closed the application from the task manager the service didn't get destroyed but got recreated and continued to receive remote changes.

Hope it helps.

Note: My callbacks can take up to 5 minutes to get fired following the actual changes in the firebase database.