Merge pull request #21 from JoaoCaixinha/master

realtime-framework · web-flow · commit bf75b82c5da3 · 2017-02-14T12:05:08.000Z
Added guaranteed delivery mode methods
diff --git a/RCTRealtimeMessagingAndroid.js b/RCTRealtimeMessagingAndroid.js
@@ -31,7 +31,6 @@ class RCTRealtimeMessagingAndroid extends React.Component {
 		ortcClient.connect(config, this.id);
 	}
 	
-
 	RTDisconnect(){
 		ortcClient.disconnect(this.id);
 	}
@@ -44,6 +43,14 @@ class RCTRealtimeMessagingAndroid extends React.Component {
 		ortcClient.subscribeWithFilter(channel, subscribeOnReconnect, filter, this.id);
 	}
 
+	RTSubscribeWithBuffer(channel, subscriberId){
+		ortcClient.subscribeWithBuffer(channel, subscriberId, this.id);
+	}
+
+	RTSubscribeWithOptions(options){
+		ortcClient.subscribeWithOptions(options, this.id);
+	}
+
 	RTSubscribeWithNotifications(channel, subscribeOnReconnect: boolean){
 		ortcClient.subscribeWithNotifications(channel, subscribeOnReconnect, this.id);
 	}
@@ -52,7 +59,11 @@ class RCTRealtimeMessagingAndroid extends React.Component {
 		ortcClient.unsubscribe(channel, this.id);
 	}
 
-	RTSendMessage(message, channel){
+	RTSendMessage(channel, message, ttl){
+		ortcClient.publish(channel, message, ttl, this.id);
+	}
+
+	RTPublishMessage(message, channel){
 		ortcClient.sendMessage(message, channel, this.id);
 	}
 
diff --git a/README.md b/README.md
@@ -52,7 +52,7 @@ More information can be found on the
 
 
 
-* Drag `RCTRealtimeMessagingAndroid.js` to the root of your project.
+* Drag `PROJECT_DIR/node_modules/react-native-realtimemessaging-android/RCTRealtimeMessagingAndroid.js` to the root of your project.
 
 * **If you want to use push notifications**, set `MainActivity` extending `RealtimePushNotificationActivity`.
 
@@ -124,6 +124,23 @@ RTRemoveEventListener removes an event registration. After this method when the
 
 *	onMessageWithFilter - Occurs when a message is received using `RTSubscribeWithFilter`. The event notification data is `{"message": message,"channel": channel, "filtered":true}`, where the filtered property indicates wheter the server was able to successfully filter the message. 
 
+*	onMessageWithBuffer - Fired when a message was received in the specified channel subscribed with the `RTSubscribeWithBuffer`.
+	- channel - The channel where the message was received
+	- seqId - The message sequence id
+	- message - The message received
+
+*	onMessageWithOptions - Fired when a message was received in the specified channel subscribed with the `RTSubscribeWithOptions`
+	- msgOptions - Dictionary where the message data was received
+	
+	-
+		msgOptions = {
+		    channel, // Channel where the message was received
+		    seqId, // The message sequence id property
+		    filtered, // Indicates if server has filtered the message
+		    message // Content of the received message
+		}
+
+
 * onPresence - Gets the subscriptions in the specified channel and if active the first 100 unique connection metadata:
 	- On success -> `{"result": result}`
 	- On error -> `{"error": error}`
@@ -247,6 +264,46 @@ Indicates whether the client should subscribe to the channel when reconnected (i
 
 ----------
 
+#####RTSubscribeWithOptions(options)
+
+Subscribes to a channel to receive messages sent to it with given options.
+
+**Parameters**
+
+* options - The subscription options dictionary, EX:
+options = {
+	channel,
+	subscribeOnReconnected, // optional, default = true,
+	withNotifications (Bool), // optional, default = false, use push notifications as in subscribeWithNotifications
+	filter, // optional, default = "", the subscription filter as in subscribeWithFilter
+	subscriberId // optional, default = "", the subscriberId as in subscribeWithBuffer
+	}
+
+***Example:***
+
+	var options = {
+			"channel":"YOUR_CHANNEL_NAME", 
+			"subscriberId":"CLIENT_SUBSCRIBER_ID", 
+			"filter":"MESSAGE_FILTER"
+			}
+	RCTRealtimeMessaging.RTSubscribeWithOptions(options);
+
+----------
+
+#####RTSubscribeWithBuffer(channel, subscriberId)
+
+Subscribes to a channel to receive messages published to it.
+
+**Parameters**
+
+* channel - The channel name.
+* subscriberId - The subscriberId associated to the channel.
+
+***Example:***
+
+	RCTRealtimeMessaging.RTSubscribeWithBuffer("MyChannel", "CLIENT_SUBSCRIBER_ID");
+
+----------
 
 ##### RTSubscribeWithNotifications(channel, subscribeOnReconnect: boolean)
 
@@ -295,6 +352,25 @@ Sends a message to a pub/sub channel.
 
 ----------
 
+#####RTPublishMessage(channel, message, ttl, onPublishResultCallback)
+
+Publish a message to a channel.
+
+**Parameters**
+
+ * channel - The channel name.
+ * message - The message to publish.
+ * ttl - The message expiration time in seconds (0 for maximum allowed ttl).
+ * onPublishResultCallback - callback returns error if message publish was not successful or published message unique id (seqId) if sucessfully published
+ 
+***Example:***
+
+	RCTRealtimeMessaging.RTPublishMessage("MyChannel", "Hello World", ttl, function(error, seqId){
+	
+	});
+
+----------
+
 ##### RTEnablePresence(aPrivateKey, channel, aMetadata:boolean)
 
 Enables presence for the specified channel with first 100 unique connection metadata.
@@ -308,8 +384,6 @@ Enables presence for the specified channel with first 100 unique connection meta
 * metadata - Sets to return metadata info
 
 
-
-
 ***Example:***
 
 	RCTRealtimeMessaging.RTEventListener("onEnablePresence", function(event){
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-realtimemessaging-android",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "The Realtime Framework Cloud Messaging Pub/Sub client for React-Native Android",
   "main": "RCTRealtimeMessagingAndroid.js",
   "scripts": {
diff --git a/reactnativemessagingandroid/src/main/java/co/realtime/reactnativemessagingandroid/GcmReceiver.java b/reactnativemessagingandroid/src/main/java/co/realtime/reactnativemessagingandroid/GcmReceiver.java
@@ -1,7 +1,5 @@
 package co.realtime.reactnativemessagingandroid;
 
-import android.app.Activity;
-import android.app.Application;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
@@ -11,7 +9,6 @@
 import android.support.v4.app.NotificationCompat;
 import android.util.Log;
 
-
 import java.util.Random;
 
 import ibt.ortc.extensibility.GcmOrtcBroadcastReceiver;
@@ -31,15 +28,15 @@ public void onReceive(Context context, Intent intent) {
             // if we are in the foreground, just surface the payload, else post it to the statusbar
             if (RealtimeMessagingAndroid.isOnForeground()) {
                 extras.putBoolean("foreground", true);
-
+                RealtimeMessagingAndroid.sendExtras(extras);
             } else {
                 extras.putBoolean("foreground", false);
                 // Send a notification if there is a message
                 if (extras.getString("M") != null && extras.getString("M").length() != 0) {
                     createNotification(context, extras);
                 }
             }
-            RealtimeMessagingAndroid.sendExtras(extras);
+
         }
     }
 
diff --git a/reactnativemessagingandroid/src/main/java/co/realtime/reactnativemessagingandroid/RealtimeMessagingAndroid.java b/reactnativemessagingandroid/src/main/java/co/realtime/reactnativemessagingandroid/RealtimeMessagingAndroid.java
@@ -13,16 +13,21 @@
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
@@ -35,7 +40,10 @@
 import ibt.ortc.extensibility.OnDisconnected;
 import ibt.ortc.extensibility.OnException;
 import ibt.ortc.extensibility.OnMessage;
+import ibt.ortc.extensibility.OnMessageWithBuffer;
 import ibt.ortc.extensibility.OnMessageWithFilter;
+import ibt.ortc.extensibility.OnMessageWithOptions;
+import ibt.ortc.extensibility.OnPublishResult;
 import ibt.ortc.extensibility.OnReconnected;
 import ibt.ortc.extensibility.OnReconnecting;
 import ibt.ortc.extensibility.OnSubscribed;
@@ -217,6 +225,133 @@ public void disconnect(Integer id){
         }
     }
 
+    private Map<String, Object> recursivelyDeconstructReadableMap(ReadableMap readableMap) {
+        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        Map<String, Object> deconstructedMap = new HashMap<>();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            ReadableType type = readableMap.getType(key);
+            switch (type) {
+                case Null:
+                    deconstructedMap.put(key, null);
+                    break;
+                case Boolean:
+                    deconstructedMap.put(key, readableMap.getBoolean(key));
+                    break;
+                case Number:
+                    deconstructedMap.put(key, readableMap.getDouble(key));
+                    break;
+                case String:
+                    deconstructedMap.put(key, readableMap.getString(key));
+                    break;
+                case Map:
+                    deconstructedMap.put(key, recursivelyDeconstructReadableMap(readableMap.getMap(key)));
+                    break;
+                case Array:
+                    deconstructedMap.put(key, recursivelyDeconstructReadableArray(readableMap.getArray(key)));
+                    break;
+                default:
+                    throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
+            }
+
+        }
+        return deconstructedMap;
+    }
+
+    private List<Object> recursivelyDeconstructReadableArray(ReadableArray readableArray) {
+        List<Object> deconstructedList = new ArrayList<>(readableArray.size());
+        for (int i = 0; i < readableArray.size(); i++) {
+            ReadableType indexType = readableArray.getType(i);
+            switch(indexType) {
+                case Null:
+                    deconstructedList.add(i, null);
+                    break;
+                case Boolean:
+                    deconstructedList.add(i, readableArray.getBoolean(i));
+                    break;
+                case Number:
+                    deconstructedList.add(i, readableArray.getDouble(i));
+                    break;
+                case String:
+                    deconstructedList.add(i, readableArray.getString(i));
+                    break;
+                case Map:
+                    deconstructedList.add(i, recursivelyDeconstructReadableMap(readableArray.getMap(i)));
+                    break;
+                case Array:
+                    deconstructedList.add(i, recursivelyDeconstructReadableArray(readableArray.getArray(i)));
+                    break;
+                default:
+                    throw new IllegalArgumentException("Could not convert object at index " + i + ".");
+            }
+        }
+        return deconstructedList;
+    }
+
+
+    @ReactMethod
+    public void subscribeWithOptions(ReadableMap options, Integer id){
+        Map newOptions = recursivelyDeconstructReadableMap(options);
+        OrtcClient client = null;
+        if (queue.containsKey(id)) {
+            client = queue.get(id);
+            client.subscribeWithOptions(newOptions, new OnMessageWithOptions() {
+                @Override
+                public void run(OrtcClient sender, Map msgOptions) {
+                    String thisId = "" + RealtimeMessagingAndroid.getKeyByValue(queue, sender);
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("channel", (String)msgOptions.get("channel"));
+                    params.putString("message", (String)msgOptions.get("message"));
+                    if (msgOptions.containsKey("filtered"))
+                        params.putBoolean("filtered", (Boolean) msgOptions.get("filtered"));
+                    if (msgOptions.containsKey("seqId"))
+                        params.putString("seqId", (String) msgOptions.get("seqId"));
+
+                    sendEvent(getReactApplicationContext(), thisId + "-onMessageWithOptions", params);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void subscribeWithBuffer(String channel, String subscriberId, Integer id){
+        OrtcClient client = null;
+        if (queue.containsKey(id)) {
+            client = queue.get(id);
+            client.subscribeWithBuffer(channel, subscriberId, new OnMessageWithBuffer() {
+                @Override
+                public void run(OrtcClient sender, String channel, String seqId, String message) {
+                    String thisId = "" + RealtimeMessagingAndroid.getKeyByValue(queue, sender);
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("channel", channel);
+                    params.putString("message", message);
+                    params.putString("seqId", seqId);
+                    sendEvent(getReactApplicationContext(), thisId + "-onMessageWithBuffer", params);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void publish(String channel, String message, Integer ttl, Integer id, final Callback callBack){
+        if (queue.containsKey(id)) {
+            final OrtcClient client = queue.get(id);
+            client.publish(channel, message, ttl, new OnPublishResult() {
+                @Override
+                public void run(String error, String seqId) {
+                    String pError = "";
+                    String pSeqId = "";
+                    if (error != null)
+                        pError = error;
+                    if (seqId != null)
+                       pSeqId = seqId;
+                    callBack.invoke(pError, pSeqId);
+                }
+            });
+        }
+    }
+
+
     @ReactMethod
     public void subscribeWithFilter(String channel, Boolean subscribeOnReconnect, String filter, Integer id){
         OrtcClient client = null;
@@ -461,6 +596,10 @@ private static JSONObject convertBundleToJson(Bundle extras)
             }
             else{
                 String message = extras.getString("M");
+                if (message.charAt(0) == '#'){
+                    String seqId = message.substring(message.indexOf("#") + 1,message.indexOf(":"));
+                    json.put("seqId", seqId);
+                }
                 String newMsg = message.substring(message.indexOf("_", message.indexOf("_") + 1) + 1);
                 json.put("message", newMsg);
             }
@@ -502,8 +641,16 @@ public void sendJavascript(JSONObject json) {
                 gCachedExtras = null;
             } catch (JSONException ex) {
                 WritableMap params = new WritableNativeMap();
-                params.putString("message", json.getString("message"));
-                params.putString("channel", json.getString("channel"));
+
+                Iterator<String> iter = json.keys();
+                while (iter.hasNext()) {
+                    String key = iter.next();
+                    try {
+                        params.putString(key, json.getString(key));
+                    } catch (JSONException e) {
+                        // Something went wrong!
+                    }
+                }
 
                 if (queue != null){
                     for (int id : this.queue.keySet()){
diff --git a/reactnativemessagingandroid/src/main/java/co/realtime/reactnativemessagingandroid/RealtimePushNotificationActivity.java b/reactnativemessagingandroid/src/main/java/co/realtime/reactnativemessagingandroid/RealtimePushNotificationActivity.java

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,6 @@ class RCTRealtimeMessagingAndroid extends React.Component {`
`31`	`31`	`ortcClient.connect(config, this.id);`
`32`	`32`	`}`
`33`	`33`
`34`		`-`
`35`	`34`	`RTDisconnect(){`
`36`	`35`	`ortcClient.disconnect(this.id);`
`37`	`36`	`}`
`@@ -44,6 +43,14 @@ class RCTRealtimeMessagingAndroid extends React.Component {`
`44`	`43`	`ortcClient.subscribeWithFilter(channel, subscribeOnReconnect, filter, this.id);`
`45`	`44`	`}`
`46`	`45`
	`46`	`+ RTSubscribeWithBuffer(channel, subscriberId){`
	`47`	`+ ortcClient.subscribeWithBuffer(channel, subscriberId, this.id);`
	`48`	`+ }`
	`49`	`+`
	`50`	`+ RTSubscribeWithOptions(options){`
	`51`	`+ ortcClient.subscribeWithOptions(options, this.id);`
	`52`	`+ }`
	`53`	`+`
`47`	`54`	`RTSubscribeWithNotifications(channel, subscribeOnReconnect: boolean){`
`48`	`55`	`ortcClient.subscribeWithNotifications(channel, subscribeOnReconnect, this.id);`
`49`	`56`	`}`
`@@ -52,7 +59,11 @@ class RCTRealtimeMessagingAndroid extends React.Component {`
`52`	`59`	`ortcClient.unsubscribe(channel, this.id);`
`53`	`60`	`}`
`54`	`61`
`55`		`- RTSendMessage(message, channel){`
	`62`	`+ RTSendMessage(channel, message, ttl){`
	`63`	`+ ortcClient.publish(channel, message, ttl, this.id);`
	`64`	`+ }`
	`65`	`+`
	`66`	`+ RTPublishMessage(message, channel){`
`56`	`67`	`ortcClient.sendMessage(message, channel, this.id);`
`57`	`68`	`}`
`58`	`69`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "react-native-realtimemessaging-android",`
`3`		`- "version": "1.1.3",`
	`3`	`+ "version": "1.1.4",`
`4`	`4`	`"description": "The Realtime Framework Cloud Messaging Pub/Sub client for React-Native Android",`
`5`	`5`	`"main": "RCTRealtimeMessagingAndroid.js",`
`6`	`6`	`"scripts": {`