rho-tau-extensions 6.0.0 → 7.4.1

data/libs/fcm-push-18/ext/android/jni/src/fcmpushclient.cpp

@@ -0,0 +1,215 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+*
+* Copyright (c) 2008-2012 Rhomobile, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*
+* http://rhomobile.com
+*------------------------------------------------------------------------*/
+
+#include "rhodes/JNIRhodes.h"
+#include "common/RhoConf.h"
+#include "Push.h"
+#include "sync/RhoconnectClientManager.h"
+#include "sync/ILoginListener.h"
+#include "ruby/ext/rho/rhoruby.h"
+
+#include "logging/RhoLog.h"
+
+#include "fcmpushclient.h"
+
+//----------------------------------------------------------------------------------------------------------------------
+extern "C" void Init_FCMPush_extension()
+{
+    // create FCM push client
+    RAWTRACEC("Init_FCMPush_extension", "creating FCM client >>>>>>>>>>>>>>");
+
+    rho::fcm::FcmPushClient* pClient = new rho::fcm::FcmPushClient();
+
+    RAWTRACEC("Init_FCMPush_extension", "adding FCM client >>>>>>>>>>>>>>>>");
+
+    rho::push::CPushManager::getInstance()->addClient(pClient);
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+namespace rho { namespace fcm {
+
+IMPLEMENT_LOGCLASS(FcmPushClient, "FcmPushClient");
+
+//----------------------------------------------------------------------------------------------------------------------
+
+const char* const FcmPushClient::s_FCM_FACADE_CLASS = "com.rhomobile.rhodes.fcm.FCMFacade";
+
+//----------------------------------------------------------------------------------------------------------------------
+
+const String FcmPushClient::s_Type = "fcm";
+String FcmPushClient::token = "";
+
+FcmPushClient::FcmPushClient()
+{
+    LOG(TRACE) + "FcmPushInit()";
+    canExecuteNotifications = false;
+    JNIEnv *env = jnienv();
+
+    static jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
+    if (!cls) {
+        LOG(ERROR) + "Cannot find class: " + s_FCM_FACADE_CLASS;
+        return;
+    }
+
+    static jmethodID mid = env->GetStaticMethodID(cls, "initFireBase", "()V");
+    if (!mid) {
+        LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + ".initFireBase() method";
+        return;
+    }
+
+    env->CallStaticVoidMethod(cls, mid);
+
+    CMethodResult result;
+    setProperty("id", s_Type, result);
+    setProperty("type", IPush::PUSH_TYPE_NATIVE, result);
+    setProperty("senderId", RHOCONF().getString("Push.fcm.senderId"), result);
+    setPropertyFromMethod("google_app_id", result);
+    //setPropertyFromMethod("google_api_key", result);
+    setPropertyFromMethod("gcm_defaultSenderId", result);
+
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+void FcmPushClient::setPropertyFromMethod(const char* methodName, CMethodResult &result) {
+
+    JNIEnv *env = jnienv();
+    jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
+    if (!cls) {
+        LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS;
+        return;
+    }
+
+    jmethodID mid = env->GetStaticMethodID( cls, methodName, "()Ljava/lang/String;");
+    if (!mid){
+        LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + "." + methodName + " method";
+        return;
+    } 
+
+    jstring jstr = (jstring)env->CallStaticObjectMethod(cls, mid);
+    const char* buf = env->GetStringUTFChars(jstr,0);
+
+    setProperty(methodName, buf, result);
+    env->ReleaseStringUTFChars(jstr, buf);
+}
+
+void FcmPushClient::refreshToken(){
+    LOG(TRACE) + "refreshToken()";
+    JNIEnv *env = jnienv();
+
+    static jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
+    if (!cls) {
+        LOG(ERROR) + "Cannot find class: " + s_FCM_FACADE_CLASS;
+        return;
+    }
+
+    static jmethodID mid = env->GetStaticMethodID(cls, "refreshToken", "()V");
+    if (!mid) {
+        LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + ".refreshToken() method";
+        return;
+    }
+
+    env->CallStaticVoidMethod(cls, mid);
+
+}
+
+void FcmPushClient::getDeviceId(CMethodResult& result)
+{
+    String deviceId = m_hashProps["deviceId"];
+
+    if(deviceId.length() != 0)
+    {
+        LOG(TRACE) + "FCM deviceId: " + deviceId;
+        result.set(deviceId);
+    }
+    else
+    {
+        LOG(TRACE) + "Still waiting for FCM deviceId";
+        m_deviceIdResult = result;
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+void FcmPushClient::startNotifications(CMethodResult& result)
+{
+    LOG(TRACE) + "Start FCM push notifications";
+    m_oResult = result;
+    canExecuteNotifications = true;
+    executeCallBacks();
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+void FcmPushClient::stopNotifications(CMethodResult& result)
+{
+    LOG(TRACE) + "Stop FCM push notifications";
+    canExecuteNotifications = false;
+    m_oResult = CMethodResult();
+
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+void FcmPushClient::setDeviceId(const String& deviceId)
+{
+    CMethodResult result;
+    setProperty("deviceId", deviceId, result);
+
+    LOG(TRACE) + "creating client register";
+    rho::sync::RhoconnectClientManager::clientRegisterCreate(deviceId.c_str());
+
+    getDeviceId(m_deviceIdResult);
+    m_deviceIdResult = CMethodResult();
+
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+bool FcmPushClient::callBack(const String& json)
+{
+    LOG(TRACE) + "FCM push notification: " + json;
+
+    if (canExecuteNotifications){
+        m_oResult.setJSON(json);
+    }else{
+        if (callBacksQueue.size() < 1024){
+            callBacksQueue.push(json);
+        }
+    }
+
+    return true;
+}
+
+void FcmPushClient::executeCallBacks()
+{
+
+    while (!callBacksQueue.empty()){
+        callBack(callBacksQueue.front());
+        callBacksQueue.pop();
+    }
+
+}
+
+
+}}
+

data/libs/fcm-push-18/ext/android/jni/src/fcmpushclient.h

@@ -0,0 +1,74 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+*
+* Copyright (c) 2008-2012 Rhomobile, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*
+* http://rhomobile.com
+*------------------------------------------------------------------------*/
+
+#ifndef FCMPUSHCLIENT_H_
+#define FCMPUSHCLIENT_H_
+
+//#include "common/push/IRhoPushClient.h"
+#include "Push.h"
+
+#include "logging/RhoLog.h"
+#include "common/RhoStd.h"
+#include <queue>
+
+namespace rho { namespace fcm {
+
+using namespace rho::common;
+
+class FcmPushClient: public push::CPushClient
+{
+    class SyncLoginListener;
+private:
+    static const char* const s_FCM_FACADE_CLASS;
+    static const String s_Type;
+    static String token;
+    CMethodResult m_oResult;
+    CMethodResult m_deviceIdResult;
+    void setPropertyFromMethod(const char* methodName, CMethodResult &result);
+    void refreshToken();
+
+    std::queue<String> callBacksQueue;
+    void executeCallBacks();
+    bool canExecuteNotifications;
+public:
+    DEFINE_LOGCLASS;
+
+    FcmPushClient();
+    virtual ~FcmPushClient() {}
+
+    virtual const String& getId() const { return s_Type; }
+    virtual void setDeviceId(const String& deviceId);
+    virtual void getDeviceId(CMethodResult& result);
+    virtual void startNotifications(CMethodResult& result);
+    virtual void stopNotifications(CMethodResult& result);
+    virtual bool callBack(const String& json);
+
+};
+
+
+}}
+
+#endif /* FCMPUSHCLIENT_H_ */

data/libs/fcm-push-18/ext/android/res/res/values/fireBaseValues.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="gcm_defaultSenderId" translatable="false">946233903142</string>
+	<string name="google_app_id" translatable="false">1:946233903142:android:f30764748b001126</string>
+</resources>

data/libs/fcm-push-18/ext/android/src/com/rhomobile/rhodes/fcm/FCMFacade.java

@@ -0,0 +1,164 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+*
+* Copyright (c) 2008-2012 Rhomobile, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*
+* http://rhomobile.com
+*------------------------------------------------------------------------*/
+
+package com.rhomobile.rhodes.fcm;
+
+import com.rhomobile.rhodes.Push;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.PushContract;
+import com.rhomobile.rhodes.util.ContextFactory;
+import com.rhomobile.rhodes.fcm.FCMIntentService;
+import android.content.Intent;
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+import com.google.firebase.messaging.FirebaseMessaging;
+import com.google.firebase.iid.FirebaseInstanceId;
+import com.rhomobile.rhodes.R;
+import java.lang.Throwable;
+import com.rhomobile.rhodes.extmanager.AbstractRhoListener;
+import com.rhomobile.rhodes.RhodesActivity;
+import com.rhomobile.rhodes.RhodesService;
+import com.rhomobile.rhodes.extmanager.RhoExtManager;
+import com.rhomobile.rhodes.extmanager.RhoExtManagerImpl;
+import com.rhomobile.rhodes.extmanager.IRhoExtManager;
+import com.google.firebase.iid.InstanceIdResult;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+
+public final class FCMFacade {
+    private static final String TAG = FCMFacade.class.getSimpleName();
+    public static final FCMListener listener = FCMListener.getInstance();
+    
+    static final String FCM_PUSH_CLIENT = "fcm";
+    static String clientToken = "";
+
+    private static String gStr(int key){
+        String value = "";
+        try{
+            value = ContextFactory.getContext().getResources().getString(key);
+        }catch(Exception e){
+            Logger.W(TAG, "FCM: key " + key + " does not exist");
+        }
+        return value;
+    }
+
+    public static String google_app_id(){
+        return gStr(R.string.google_app_id);
+    }
+
+    public static String gcm_defaultSenderId() {
+        return gStr(R.string.gcm_defaultSenderId);
+    }
+
+/*
+    public static String google_api_key(){
+        return gStr(R.string.google_api_key);
+    }
+*/
+
+    public static void initFireBase() {
+
+        Logger.W(TAG, "FCM: Send FCM push register req");
+      
+        try{
+            FirebaseApp.getInstance();
+            Logger.T(TAG, "FCM: Firebase inited");
+        }catch(Exception exc){
+            FirebaseOptions options = null;
+            try {
+                options = new FirebaseOptions.Builder()
+                .setApplicationId(gStr(R.string.google_app_id))
+                //.setApiKey(gStr(R.string.google_api_key))
+                //.setDatabaseUrl(gStr(R.string.firebase_database_url))
+                //.setStorageBucket(gStr(R.string.google_storage_bucket))
+                .setGcmSenderId(gStr(R.string.gcm_defaultSenderId))
+                .build();
+            } catch( Throwable e ) {
+                Logger.E(TAG, "FCM: poblems on building options: " + e);
+                e.printStackTrace();
+            }
+            try{
+                FirebaseApp.initializeApp(ContextFactory.getContext(), options);
+                Logger.T(TAG, "FCM: initialization of application");
+            }catch(Exception e){
+                Logger.E(TAG, "FCM: poblems on initialization app: " + e);
+                e.printStackTrace();
+            }
+            try{
+                if (FirebaseApp.getInstance()==null){
+                    Logger.T(TAG, "FCM: firebase app is null"); 
+                }
+                Logger.T(TAG, "FCM: Firebase Inited");                
+            }catch(Exception e){
+                Logger.E(TAG, "FCM: poblems on getting instance: " + e);
+                e.printStackTrace();
+            }
+        }   
+  
+        refreshToken();  
+
+    }
+    public static void refreshToken(){
+        try{
+            Logger.T(TAG, "FCM: registation of application");
+            clientToken = "";
+
+            new Thread(new Runnable() {
+                public void run() {
+                    while (FirebaseInstanceId.getInstance(FirebaseApp.getInstance()) == null){
+                        try{
+                            Thread.sleep(1000);
+                        }catch(Exception e){
+
+                        }
+                        Logger.T(TAG, "FCM: FirebaseInstanceId is null");
+                    }
+                    FirebaseInstanceId.getInstance(FirebaseApp.getInstance()).getInstanceId().addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
+                    @Override
+                    public void onComplete(Task<InstanceIdResult> task) {
+                            if (task == null || !task.isSuccessful()) {
+                                Logger.T(TAG, "FCM: can't get token, try to refresh later: " + task.getException());
+                                return;
+                            }
+                            clientToken = task.getResult().getToken();
+                            PushContract.handleRegistration(ContextFactory.getContext(), clientToken, FCMFacade.FCM_PUSH_CLIENT);
+                            Logger.T(TAG, "FCM: registation successfully, token = " + clientToken);
+                        }
+                    });
+                }
+            }).start();
+
+
+            
+        }catch(Exception exc){
+            Logger.T(TAG, "FCM: can't handle registation: " + exc);
+        }
+        
+    }
+
+}

data/libs/fcm-push-18/ext/android/src/com/rhomobile/rhodes/fcm/FCMIntentService.java

@@ -0,0 +1,219 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+*
+* Copyright (c) 2008-2012 Rhomobile, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*
+* http://rhomobile.com
+*------------------------------------------------------------------------*/
+
+package com.rhomobile.rhodes.fcm;
+
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.BitmapFactory;
+import android.media.RingtoneManager;
+import android.net.Uri;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.support.v4.app.NotificationCompat;
+
+import android.app.PendingIntent;
+import android.net.Uri;
+import android.util.Log;
+import android.os.Build;
+
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.rhomobile.rhodes.util.ContextFactory;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.PushContract;
+import com.rhomobile.rhodes.R;
+import com.rhomobile.rhodes.RhodesActivity;
+import com.rhomobile.rhodes.R;
+
+
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+import android.util.Log;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.HashSet;
+import org.json.JSONException;
+import org.json.JSONObject;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.TimeUnit;
+import android.os.Handler;
+import com.rhomobile.rhodes.fcm.FCMFacade;
+import com.google.firebase.iid.FirebaseInstanceId;
+
+
+public class FCMIntentService extends FirebaseMessagingService {
+
+    private static final String TAG = FCMIntentService.class.getSimpleName();
+    public static final FCMListener listener = FCMListener.getInstance();
+    
+    private static final String CHANNEL_ID = "default";
+    private static Map<String, JSONObject> savedMessages = new HashMap<String, JSONObject>();
+    
+    @Override
+    public void onNewToken(String token) {
+       Logger.I(TAG, "FCM: on new token: " + token);
+       super.onNewToken(token);
+       FCMFacade.refreshToken();
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        if (Build.VERSION.SDK_INT >= 26) {
+            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, getPackageName(), NotificationManager.IMPORTANCE_DEFAULT);
+            NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(channel);
+        }
+    }
+
+
+    @Override
+    public void onMessageReceived(RemoteMessage remoteMessage) {
+        //savedIntents.remove(remoteMessage.getMessageId());
+
+        Logger.I(TAG, "FCM: onMessageReceived()");
+        Map<String, String> params = new HashMap<String, String>();
+
+        if (remoteMessage.getMessageId() != null) params.put("id", remoteMessage.getMessageId());
+        Logger.I(TAG, "FCM: id - " + remoteMessage.getMessageId());
+
+        if (remoteMessage.getFrom() != null) params.put("from", remoteMessage.getFrom());
+        Logger.I(TAG, "FCM: from - " + remoteMessage.getFrom());
+
+        if (remoteMessage.getTo() != null) params.put("to", remoteMessage.getTo());
+        Logger.I(TAG, "FCM: to - " + remoteMessage.getTo());
+
+        if (remoteMessage.getNotification() != null){
+            if (remoteMessage.getNotification().getBody() != null)  params.put("body", remoteMessage.getNotification().getBody());
+            Logger.I(TAG, "FCM: body - " + remoteMessage.getNotification().getBody());
+
+            if (remoteMessage.getNotification().getTitle() != null) params.put("title", remoteMessage.getNotification().getTitle());
+            Logger.I(TAG, "FCM: title - " + remoteMessage.getNotification().getTitle());
+
+            if (remoteMessage.getNotification().getTag() != null) params.put("tag", remoteMessage.getNotification().getTag());
+            Logger.I(TAG, "FCM: tag - " + remoteMessage.getNotification().getTag());
+        }
+
+        String title = null;
+        String text = null;
+
+        try{
+            JSONObject jsonObject = new JSONObject(params);
+
+            try {
+                jsonObject.put("data", new JSONObject(remoteMessage.getData()));
+                Logger.I(TAG, "FCM: data - " + remoteMessage.getData());
+                title = remoteMessage.getData().get("notification_title");
+                text = remoteMessage.getData().get("notification_text");
+            } catch (JSONException e) {
+                Logger.I(TAG, "FCM: jsonObject generation error");
+                e.printStackTrace();
+            }
+
+            Logger.W(TAG, "FCM: push message in JSON: " + jsonObject.toString());
+            try{
+                PushContract.handleMessage(ContextFactory.getContext(), jsonObject.toString(), FCMFacade.FCM_PUSH_CLIENT);
+            }catch(Exception e){
+                if (params.containsKey("id")){
+                    savedMessages.put(params.get("id"), jsonObject);
+                }
+            }
+        }catch(Exception e){
+            Logger.E(TAG, "FCM: can't create object for handleMessage");
+            e.printStackTrace();
+        }
+
+        if (title != null && text != null && !listener.applicationVisible()){
+            Intent resultIntent = new Intent(this, RhodesActivity.class);
+            PendingIntent resultPendingIntent = PendingIntent.getActivity(this, 0, resultIntent,
+                           PendingIntent.FLAG_UPDATE_CURRENT);
+        
+
+            NotificationCompat.Builder notificationBuilder = null;
+            if (Build.VERSION.SDK_INT >= 26) {
+                notificationBuilder = new NotificationCompat.Builder(this, "default");
+            }else{
+                notificationBuilder = new NotificationCompat.Builder(this);
+                           
+            }
+            notificationBuilder.setSmallIcon(R.mipmap.icon)
+                           .setContentTitle(title)
+                           .setContentText(text)
+                           .setAutoCancel(true)
+                           .setContentIntent(resultPendingIntent);
+
+            Notification notification = notificationBuilder.build();
+             
+            NotificationManager notificationManager =
+                   (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+
+            notificationManager.notify(1, notification);
+        }
+
+
+    }
+
+    public static boolean tryToHandleMessage(JSONObject jsonObject){
+        try{
+            Logger.W(TAG, "FCM: tryToHandleMessage() - trying to handle saved JSONObject");
+            PushContract.handleMessage(ContextFactory.getContext(), jsonObject.toString(), FCMFacade.FCM_PUSH_CLIENT);
+            return true;
+        }catch(Exception e){
+            Logger.W(TAG, "FCM: tryToHandleMessage() - can't handle JSONObject");
+        }
+        return false;
+    }
+
+
+    static public void resume()
+    {
+        if (savedMessages.size() > 0){
+
+            Timer timerObj = new Timer();
+            TimerTask timerTaskObj = new TimerTask() {
+                public void run() {
+                    Set<String> keySet = new HashSet<String>(savedMessages.keySet());
+                    for (String key : keySet){
+                        try{
+                            if (tryToHandleMessage(savedMessages.get(key))){
+                                savedMessages.remove(key);
+                            }
+                        }catch(Exception e){
+                            Logger.W(TAG, "FCM: can't handle saved message " + key);
+                        }
+                    }
+                }
+            };
+            timerObj.schedule(timerTaskObj, 2000);
+        }
+    }
+
+}