vibes-react-native 1.0.0

package/android/src/main/java/com/vibes/push/rn/plugin/PushEvtEmitter.java

@@ -0,0 +1,65 @@
+package com.vibes.push.rn.plugin;
+
+import android.app.Application;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.vibes.vibes.PushPayloadParser;
+import com.vibes.vibes.Vibes;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Component for emitting events to the Javascript layer.
+ */
+public class PushEvtEmitter {
+	private ReactContext mReactContext;
+	private VibesAppHelper appHelper;
+
+	public PushEvtEmitter(ReactContext reactContext) {
+		mReactContext = reactContext;
+		appHelper = new VibesAppHelper((Application) reactContext.getApplicationContext());
+	}
+
+	void sendEvent(String eventName, Object params) {
+		if (mReactContext.hasActiveCatalystInstance()) {
+			mReactContext
+					.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+					.emit(eventName, params);
+		}
+	}
+
+	public void notifyPushReceived(PushPayloadParser bundle) {
+		WritableMap payload = convertMap(bundle.getMap());
+		WritableMap params = Arguments.createMap();
+		params.putMap("payload", payload);
+		sendEvent("pushReceived", params);
+	}
+
+	public void notifyPushOpened(PushPayloadParser bundle) {
+		appHelper.invokeApp();
+		WritableMap payload = convertMap(bundle.getMap());
+		WritableMap params = Arguments.createMap();
+		params.putMap("payload", payload);
+		sendEvent("pushOpened", params);
+	}
+
+	public static WritableMap convertMap(Map<String, String> data) {
+		String jsonString = null;
+		WritableMap map = new WritableNativeMap();
+		for (Map.Entry<String, String> entry : data.entrySet()) {
+			map.putString(entry.getKey(), entry.getValue());
+		}
+		return map;
+	}
+}

package/android/src/main/java/com/vibes/push/rn/plugin/VibesAppHelper.java

@@ -0,0 +1,100 @@
+package com.vibes.push.rn.plugin;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+
+import static com.vibes.push.rn.plugin.VibesModule.TAG;
+
+/**
+ * Utility class for obtaining items from the ApplicationContext
+ */
+public class VibesAppHelper{
+		private Context context;
+
+		public  VibesAppHelper(Application context){
+				this.context = context;
+		}
+
+		/**
+		 * Returns the push token already stored in shared preferences after Firebase runtime was initialized.
+		 * @return
+		 */
+		public String getPushToken(){
+				return getSharedPreferences().getString(VibesModule.TOKEN_KEY, null);
+		}
+
+		/**
+		 * Returns the Vibes device id already stored in shared preferences after Vibes SDK was initialized.
+		 * @return
+		 */
+		public String getDeviceId(){
+				return getSharedPreferences().getString(VibesModule.DEVICE_ID, null);
+		}
+
+		/**
+		 * Returns a Map containing items for <code>device_id</code> and <code>push_token</code> keys to enable quick display.
+		 *
+		 * @return
+		 */
+		public WritableMap getDeviceInfo(){
+				WritableMap map = Arguments.createMap();
+				map.putString("device_id", getDeviceId());
+				map.putString("push_token", getPushToken());
+				return map;
+		}
+
+		public void saveString(String key, String value){
+				SharedPreferences.Editor editor = getSharedPreferences().edit();
+				editor.putString(key, value);
+				editor.apply();
+		}
+
+		public void saveBoolean(String key, boolean value){
+				SharedPreferences.Editor editor = getSharedPreferences().edit();
+				editor.putBoolean(key, value);
+				editor.apply();
+		}
+
+		public boolean getBoolean(String key, boolean alternative){
+				return getSharedPreferences().getBoolean(key, alternative);
+		}
+
+		public String getString(String key, String alternative){
+				return getSharedPreferences().getString(key, alternative);
+		}
+
+		private SharedPreferences getSharedPreferences(){
+				return PreferenceManager.getDefaultSharedPreferences(this.context);
+		}
+
+	private Class getMainActivityClass() {
+			String packageName = context.getPackageName();
+			Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(packageName);
+			String className = launchIntent.getComponent().getClassName();
+			try {
+			return Class.forName(className);
+		} catch (ClassNotFoundException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	public void invokeApp() {
+		try {
+			Class<?> activityClass = getMainActivityClass();
+			Intent activityIntent = new Intent(context, activityClass);
+			activityIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+			context.startActivity(activityIntent);
+		} catch(Exception e) {
+			Log.e(TAG, "Class not found", e);
+			return;
+		}
+	}
+}

package/android/src/main/java/com/vibes/push/rn/plugin/VibesModule.java

@@ -0,0 +1,327 @@
+package com.vibes.push.rn.plugin;
+
+import android.app.Application;
+import androidx.annotation.NonNull;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import java.util.Map;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.firebase.iid.FirebaseInstanceId;
+import com.google.firebase.iid.InstanceIdResult;
+
+import com.vibes.vibes.Credential;
+import com.vibes.vibes.Vibes;
+import com.vibes.vibes.VibesConfig;
+import com.vibes.vibes.VibesListener;
+
+@ReactModule(name = VibesModule.NAME)
+public class VibesModule extends ReactContextBaseJavaModule {
+	public static final String NAME = "Vibes";
+	public static final String DEVICE_REGISTERED = "DEVICE_REGISTERED";
+	public static final String TOKEN_REGISTERED = "TOKEN_REGISTERED";
+	public static final String TAG = "VibesRN";
+	public static final String TOKEN_KEY = "VibesRN.PushToken";
+	public static final String DEVICE_ID = "VibesRN.Device_Id";
+	public static final String VIBES_APPID_KEY = "com.vibes.push.rn.plugin.appId";
+	public static final String VIBES_APIURL_KEY = "com.vibes.push.rn.plugin.apiUrl";
+	public static final String REGISTER_DEVICE_ERROR_KEY = "REGISTER_DEVICE_ERROR";
+	public static final String UNREGISTER_DEVICE_ERROR_KEY = "UNREGISTER_DEVICE_ERROR";
+	public static final String PLUGIN_ERROR_KEY = "PLUGIN_ERROR";
+	public static final String REGISTER_PUSH_ERROR_KEY = "REGISTER_PUSH_ERROR";
+
+
+	private VibesAppHelper appHelper;
+
+	public VibesModule(ReactApplicationContext reactContext) {
+		super(reactContext);
+		appHelper = new VibesAppHelper((Application) reactContext.getApplicationContext());
+	}
+
+	@Override
+	@NonNull
+	public String getName() {
+		return NAME;
+	}
+
+	@Override
+	public void initialize()  {
+		FirebaseInstanceId.getInstance().getInstanceId()
+				.addOnSuccessListener(
+						new OnSuccessListener<InstanceIdResult>() {
+							@Override
+							public void onSuccess(InstanceIdResult instanceIdResult) {
+								String instanceToken = instanceIdResult.getToken();
+								if (instanceToken != null) {
+									appHelper.saveString(VibesModule.TOKEN_KEY, instanceToken);
+									Log.d(TAG, "Push token obtained from FirebaseInstanceId --> " + instanceToken);
+								}
+							}
+						}
+				)
+				.addOnFailureListener(
+						new OnFailureListener() {
+							@Override
+							public void onFailure(Exception e) {
+								Log.d(TAG, "Failed to fetch token from FirebaseInstanceId: " + e.getLocalizedMessage());
+							}
+						}
+				);
+
+		if (BuildConfig.DEBUG) Log.d(TAG, "Initializing Vibes SDK");
+
+		String env = null;
+		String appId = null;
+		String apiUrl = null;
+		try {
+			ApplicationInfo ai = getReactApplicationContext().getPackageManager()
+					.getApplicationInfo(getReactApplicationContext().getPackageName(), PackageManager.GET_META_DATA);
+			Bundle bundle = ai.metaData;
+			appId = bundle.getString(VIBES_APPID_KEY);
+			apiUrl = bundle.getString(VIBES_APIURL_KEY);
+
+		} catch (PackageManager.NameNotFoundException ex) {
+
+		}
+		if (appId == null || appId.isEmpty()) {
+			throw new IllegalStateException("No appId provided in manifest under name [" + VIBES_APPID_KEY + "]");
+		}
+	   
+		VibesConfig config = null;
+		if (apiUrl == null || apiUrl.isEmpty()) {
+			config = new VibesConfig.Builder().setAppId(appId).build();
+			Log.d(TAG, "Initializing the plugin with appId=[" + appId + "]. Will use default apiUrl");
+		}else{
+			config = new VibesConfig.Builder().setApiUrl(apiUrl).setAppId(appId).build();
+			Log.d(TAG, "Initializing the plugin with appId=[" + appId + "] and apiUrl=[" + apiUrl + "]");
+		}
+
+		Vibes.initialize(getReactApplicationContext(), config);
+		this.registerDeviceAtStartup();
+
+	}
+	
+	@ReactMethod
+	public void registerDevice(final Promise promise) {
+		Log.d(TAG, "Plugin called to register device");
+		VibesListener<Credential> listener = getRegisterDeviceListener(promise);
+		Vibes.getInstance().registerDevice(listener);
+	}
+
+	@ReactMethod
+	public void getVibesDeviceInfo(final Promise promise) {
+		Log.d(TAG, "Plugin called to return device info");
+		WritableMap map = appHelper.getDeviceInfo();
+		promise.resolve(map);   
+	}
+
+	@ReactMethod
+	public void registerPush(final Promise promise) {
+		Log.d(TAG, "Plugin called to register push token with platform");
+		VibesListener<Void> listener = getRegisterPushListener(promise);
+		String pushToken = appHelper.getPushToken();
+		if(pushToken == null){
+			FirebaseInstanceId.getInstance().getInstanceId()
+					.addOnSuccessListener(
+						new OnSuccessListener<InstanceIdResult>() {
+							@Override
+							public void onSuccess(InstanceIdResult instanceIdResult) {
+								String instanceToken = instanceIdResult.getToken();
+								if (instanceToken == null) {
+									promise.reject(REGISTER_PUSH_ERROR_KEY,"No push token available for registration yet");
+								} else {
+									appHelper.saveString(VibesModule.TOKEN_KEY, instanceToken);
+									Log.d(TAG, "Push token obtianed from FirebaseInstanceId --> " + instanceToken);
+									VibesListener<Void> listener = getRegisterPushListener(promise);
+									registerPush(instanceToken, listener);
+								}
+							}
+						}
+					)
+					.addOnFailureListener(
+						new OnFailureListener() {
+							@Override
+							public void onFailure(Exception e) {
+								Log.d(TAG, "Failed to fetch token from FirebaseInstanceId: "+ e.getLocalizedMessage());
+								promise.reject(REGISTER_DEVICE_ERROR_KEY, "No push token available for registration yet");
+							}
+						}
+					);
+		}else{
+			boolean tokenRegistered = appHelper.getBoolean(VibesModule.TOKEN_REGISTERED, false);
+			if(tokenRegistered){
+				promise.resolve("Success");
+			}else{
+				registerPush(pushToken, listener);
+			}
+		}
+	}
+
+	@ReactMethod
+	public void unregisterDevice(final Promise promise) {
+		VibesListener<Void> listener = new VibesListener<Void>() {
+			public void onSuccess(Void credential) {
+				Log.d(TAG, "Unregister device successful");
+				appHelper.saveString(VibesModule.DEVICE_ID, null);
+				appHelper.saveBoolean(VibesModule.DEVICE_REGISTERED, false);
+				promise.resolve("Success");
+			}
+
+			public void onFailure(String errorText) {
+				Log.d(TAG, "Unregister device failed");
+				promise.reject(UNREGISTER_DEVICE_ERROR_KEY, errorText);
+			}
+		};
+		Vibes.getInstance().unregisterDevice(listener);
+	}
+
+	private void registerDeviceAtStartup() {
+		VibesListener<Credential> listener = getRegisterDeviceListener(null);
+		Vibes.getInstance().registerDevice(listener);
+	}
+
+
+	private VibesListener<Credential> getRegisterDeviceListener(final Promise promise) {
+		return new VibesListener<Credential>() {
+			public void onSuccess(Credential credential) {
+				appHelper.saveBoolean(VibesModule.DEVICE_REGISTERED, true);
+				String deviceId = credential.getDeviceID();
+				appHelper.saveString(VibesModule.DEVICE_ID, deviceId);
+				Log.d(TAG, "Device id obtained is --> " + deviceId);
+				String pushToken = appHelper.getPushToken();
+				if (pushToken == null) {
+					Log.d(TAG, "Token not yet available. Skipping registerPush");
+				} else {
+					Log.d(TAG, "Token found after registering device. Attempting to register push token");
+					registerPush(pushToken);
+				}
+				WritableMap map = Arguments.createMap();
+				map.putString("device_id", credential.getDeviceID());
+				if (promise != null) {
+					promise.resolve(map);
+				}
+			}
+
+			public void onFailure(String errorText) {
+				Log.e(TAG, "Failure registering device with Vibes Push SDK: " + errorText);
+				if (promise != null) {
+					promise.reject(REGISTER_DEVICE_ERROR_KEY, errorText);
+				}
+			}
+		};
+	}
+
+	private VibesListener<Void> getRegisterPushListener(final Promise promise) {
+		return new VibesListener<Void>() {
+			public void onSuccess(Void credential) {
+				appHelper.saveBoolean(VibesModule.TOKEN_REGISTERED, true);
+				Log.d(TAG, "Push token registration successful");
+				if(promise !=null){
+					promise.resolve("Success");
+				}
+			}
+
+			public void onFailure(String errorText) {
+				appHelper.saveBoolean(VibesModule.TOKEN_REGISTERED, false);
+				Log.d(TAG, "Failure registering token with Vibes Push SDK: " + errorText);
+				if(promise !=null){
+					promise.reject(REGISTER_DEVICE_ERROR_KEY, errorText);
+				}
+			}
+		};
+	}
+
+	/**
+	 * To be able to target each device, we need to send the push token generated by the Firebase environment to the
+	 * server-side via the SDK. However, ensure that {@link Vibes#registerDevice()} has been called before this is called.
+	 *
+	 * @param pushToken
+	 */
+	public static void registerPush(String pushToken) {
+		Log.d(TAG, "Registering push token with vibes");
+		VibesListener<Void> listener = new VibesListener<Void>() {
+			public void onSuccess(Void credential) {
+				Log.d(TAG, "Push token registration successful");
+			}
+
+			public void onFailure(String errorText) {
+				Log.d(TAG, "Failure registering token with Vibes Push SDK: " + errorText);
+			}
+		};      
+		registerPush(pushToken, listener);
+	}
+
+	public static void registerPush(String pushToken, VibesListener<Void> listener) {
+		Vibes.getInstance().registerPush(pushToken, listener);
+	}
+
+	/**
+	 * Unregisters a device from receiving further push notifications
+	 */
+	@ReactMethod
+	public void unregisterPush(final Promise promise) {
+		VibesListener<Void> listener = new VibesListener<Void>() {
+			public void onSuccess(Void credential) {
+				Log.d(TAG, "Unregister push successful");
+				appHelper.saveString(VibesModule.TOKEN_KEY, null);
+				appHelper.saveBoolean(VibesModule.TOKEN_REGISTERED, false);
+				promise.resolve("Success");
+			}
+			public void onFailure(String errorText) {
+				Log.d(TAG, "Unregister push failed");
+				promise.reject("REGISTER_PUSH_ERROR", errorText);
+			}
+		};
+		Vibes.getInstance().unregisterPush(listener);
+	}
+
+	/**
+    * @param externalPersonId The id to associate with the logged-in person.
+    */
+    @ReactMethod
+    public void associatePerson(final String externalPersonId, final Promise promise) {
+            Log.d(TAG, "Associating Person --> " + externalPersonId);
+            VibesListener<Void> listener = new VibesListener<Void>() {
+                public void onSuccess(Void value) {
+                    promise.resolve("Success");;
+                }
+
+                public void onFailure(String errorText) {
+                    promise.reject("ASSOCIATE_PERSON_ERROR", errorText);
+                }
+            };
+            this.associatePerson(externalPersonId, listener);
+    }
+
+    private void associatePerson(String externalPersonId, VibesListener<Void> listener) {
+        Vibes.getInstance().associatePerson(externalPersonId, listener);
+    }
+
+		/**
+     * React Native Plugin Method that updates client device information with Vibes.
+     *
+     * @param updateCredential a boolean indicating if it's a token update or device info update. Specify false if not certain
+     * @param latitude         client device latitude
+     * @param longitude        client device longitude
+     */
+		@ReactMethod
+		public void updateDevice(final boolean updateCredential, Double latitude, Double longitude, final Promise promise) {
+			Log.d(TAG, "Plugin called to update");
+			VibesListener<Credential> listener = getRegisterDeviceListener(promise);
+			Vibes.getInstance().updateDevice(updateCredential, latitude, longitude, listener);
+		}	
+}

package/android/src/main/java/com/vibes/push/rn/plugin/VibesPackage.java

@@ -0,0 +1,28 @@
+package com.vibes.push.rn.plugin;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class VibesPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new VibesModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/com/vibes/push/rn/plugin/notifications/Fms.java

@@ -0,0 +1,116 @@
+package com.vibes.push.rn.plugin.notifications;
+
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.util.Log;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.vibes.vibes.BuildConfig;
+import com.vibes.vibes.PushPayloadParser;
+import com.vibes.vibes.Vibes;
+
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.ReactContext;
+
+import java.util.Map;
+import com.vibes.push.rn.plugin.VibesModule;
+import com.vibes.push.rn.plugin.PushEvtEmitter;
+import static com.vibes.push.rn.plugin.VibesModule.TAG;
+import static com.vibes.push.rn.plugin.VibesModule.TOKEN_KEY;
+import static com.vibes.push.rn.plugin.VibesModule.DEVICE_REGISTERED;
+
+public class Fms extends FirebaseMessagingService {
+
+		@Override
+		public void onMessageReceived(RemoteMessage message){
+
+			Log.d(TAG, "Push message received. Processing");
+			PushPayloadParser pushModel = this.createPushPayloadParser(message.getData());
+			if (BuildConfig.DEBUG) {
+				PayloadWrapper wrapper = new PayloadWrapper(pushModel);
+				Log.d(TAG, wrapper.toString());
+			}
+			// pass the received payload to the handleNotification SDK method. It takes care
+			// of displaying the message
+			try {
+				Vibes.getInstance().handleNotification(getApplicationContext(), message.getData());
+				if (!pushModel.isSilentPush()) {
+					emitPayload(pushModel);
+				}
+			} catch(IllegalStateException e) {
+					Handler handler = new Handler(Looper.getMainLooper());
+					handler.post(new Runnable() {
+						public void run() {
+							Vibes.getInstance().handleNotification(getApplicationContext(), message.getData());
+							if (!pushModel.isSilentPush()) {
+								emitPayload(pushModel);
+							}
+						}
+					});
+			}
+		}
+		/**
+		 * This is invoked everytime the application generates a new Firebase push
+		 * token, which is then sent to the Vibes server to be able to target this
+		 * device with push messages.
+		 *
+		 * @param pushToken
+		 */
+		@Override
+		public void onNewToken(String pushToken) {
+				super.onNewToken(pushToken);
+				Log.d(TAG, "Firebase token obtained from Fms as " + pushToken);
+				SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
+				SharedPreferences.Editor editor = preferences.edit();
+				editor.putString(TOKEN_KEY, pushToken);
+				editor.apply();
+
+				boolean registered = preferences.getBoolean(DEVICE_REGISTERED, false);
+				if (registered) {
+						VibesModule.registerPush(pushToken);
+				}
+		}
+
+	public PushPayloadParser createPushPayloadParser(Map<String, String> map) {
+		return new PushPayloadParser(map);
+	}
+
+	private void emitPayload(PushPayloadParser pushModel) {
+		final FirebaseMessagingService serviceRef = this;
+		// We need to run this on the main thread, as the React code assumes that is true.
+		// Namely, DevServerHelper constructs a Handler() without a Looper, which triggers:
+		// "Can't create handler inside thread that has not called Looper.prepare()"
+		Handler handler = new Handler(Looper.getMainLooper());
+		handler.post(new Runnable() {
+			public void run() {
+				// Construct and load our normal React JS code bundle
+				final ReactInstanceManager mReactInstanceManager = ((ReactApplication) serviceRef.getApplication()).getReactNativeHost().getReactInstanceManager();
+				ReactContext context = mReactInstanceManager.getCurrentReactContext();
+				// If it's constructed, send a notification
+				if (context != null) {
+					PushEvtEmitter pushEmitter = new PushEvtEmitter(context);
+					pushEmitter.notifyPushReceived(pushModel);
+				} else {
+					// Otherwise wait for construction, then send the notification
+					mReactInstanceManager.addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
+						public void onReactContextInitialized(ReactContext context) {
+							PushEvtEmitter pushEmitter = new PushEvtEmitter(context);
+							pushEmitter.notifyPushReceived(pushModel);
+							mReactInstanceManager.removeReactInstanceEventListener(this);
+						}
+					});
+					if (!mReactInstanceManager.hasStartedCreatingInitialContext()) {
+						// Construct it in the background
+						mReactInstanceManager.createReactContextInBackground();
+					}
+				}
+			}
+		});
+	}
+}

package/android/src/main/java/com/vibes/push/rn/plugin/notifications/PayloadWrapper.java

@@ -0,0 +1,23 @@
+
+package com.vibes.push.rn.plugin.notifications;
+
+import com.vibes.vibes.PushPayloadParser;
+
+public class PayloadWrapper {
+
+    private final PushPayloadParser payload;
+
+
+    public PayloadWrapper(PushPayloadParser payload) {
+        this.payload = payload;
+    }
+
+    @Override
+    public String toString() {
+        return "PayloadWrapper{" +
+                "title=" + payload.getTitle() +", body=" + payload.getBody()+", channel=" + payload.getChannel()+", notification_channel=" + payload.getNotificationChannel()
+                +", silent_push=" + payload.isSilentPush()+", sound=" + payload.getSound()+", rich_media_url=" + payload.getRichPushMediaURL()+", vibes_collapse_id=" + payload.getVibesCollapseId()
+                +", priority=" + payload.getPriority()+", custom_client_data=" + payload.getCustomClientData()+ '}';
+    }
+    
+}