feature(multi instance):support multiple pusher instances

Author: heywhy

.editorconfig

@@ -11,5 +11,5 @@ end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
 
-[*.java]
+[*{.java,.swift}]
 indent_size = 4

android/src/main/java/com/github/heywhy/flutter_pusher/FlutterPusherPlugin.java

@@ -1,51 +1,29 @@
 package com.github.heywhy.flutter_pusher;
 
-import android.os.Handler;
 import android.util.Log;
-import android.os.Looper;
-
-import com.github.heywhy.flutter_pusher.listeners.*;
-
+import com.github.heywhy.flutter_pusher.platform_messages.InstanceMessage;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
-import com.pusher.client.Pusher;
-import com.pusher.client.PusherOptions;
-import com.pusher.client.channel.Channel;
-import com.pusher.client.connection.ConnectionEventListener;
-import com.pusher.client.connection.ConnectionState;
-import com.pusher.client.connection.ConnectionStateChange;
-import com.pusher.client.util.ConnectionFactory;
-import com.pusher.client.util.HttpAuthorizer;
-import com.pusher.client.util.UrlEncodedConnectionFactory;
-
-import org.json.JSONObject;
-
-import java.lang.reflect.Type;
-import java.util.HashMap;
-import java.util.Map;
-
 import io.flutter.plugin.common.EventChannel;
 import io.flutter.plugin.common.MethodCall;
 import io.flutter.plugin.common.MethodChannel;
 import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
 import io.flutter.plugin.common.MethodChannel.Result;
 import io.flutter.plugin.common.PluginRegistry.Registrar;
 
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * FlutterPusherPlugin
  */
 public class FlutterPusherPlugin implements MethodCallHandler {
 
     public static String TAG = "FlutterPusherPlugin";
     public static EventChannel.EventSink eventSink;
-    public static boolean isLoggingEnabled = false;
-
-    private Pusher pusher;
-    private Map<String, Channel> channels = new HashMap<>();
 
-    private static EventChannelListener eventListener;
-    private static PrivateChannelListener eventListenerPrivate;
-    private static PresenceChannelListener eventListenerPresence;
+    private Map<String, PusherInstance> pusherInstanceMap = new HashMap<>();
 
     /**
      * Plugin registration.
@@ -54,10 +32,6 @@ public static void registerWith(Registrar registrar) {
         final MethodChannel channel = new MethodChannel(registrar.messenger(), "com.github.heywhy/pusher");
         final EventChannel eventStream = new EventChannel(registrar.messenger(), "com.github.heywhy/pusherStream");
 
-        eventListener = new EventChannelListener();
-        eventListenerPrivate = new PrivateChannelListener();
-        eventListenerPresence = new PresenceChannelListener();
-
         channel.setMethodCallHandler(new FlutterPusherPlugin());
         eventStream.setStreamHandler(new EventChannel.StreamHandler() {
             @Override
@@ -74,296 +48,22 @@ public void onCancel(Object args) {
 
     @Override
     public void onMethodCall(MethodCall call, Result result) {
-        switch (call.method) {
-            case "init":
-                init(call, result);
-                break;
-            case "connect":
-                connect(call, result);
-                break;
-            case "disconnect":
-                disconnect(call, result);
-                break;
-            case "subscribe":
-                subscribe(call, result);
-                break;
-            case "unsubscribe":
-                unsubscribe(call, result);
-                break;
-            case "bind":
-                bind(call, result);
-                break;
-            case "unbind":
-                unbind(call, result);
-                break;
-            case "trigger":
-                // trigger(call, result);
-                break;
-            default:
-                result.notImplemented();
-                break;
+        Type type = new TypeToken<InstanceMessage>(){}.getType();
+        InstanceMessage instanceMessage = new Gson().fromJson(call.arguments.toString(), type);
+        String instanceId = instanceMessage.getInstanceId();
+        PusherInstance instance = getPusherInstance(instanceId);
+        if (instance == null) {
+            String message = String.format("Instance with id %s not found", instanceId);
+            throw new IllegalArgumentException(message);
         }
-    }
-
-
-    private void init(MethodCall call, Result result) {
-        if (pusher != null) {
-            for (Map.Entry<String, Channel> entry : channels.entrySet()) {
-                String name = entry.getKey();
-                pusher.unsubscribe(name);
-                channels.remove(name);
-            }
-        }
-
-        try {
-            final JSONObject json = new JSONObject(call.arguments.toString());
-            final JSONObject options = json.getJSONObject("options");
-
-            if (json.has("isLoggingEnabled")) {
-                isLoggingEnabled = json.getBoolean("isLoggingEnabled");
-            }
 
-            // setup options
-            final PusherOptions pusherOptions = new PusherOptions();
-
-            if (options.has("auth")) {
-                final JSONObject auth = options.getJSONObject("auth");
-                final String endpoint = auth.getString("endpoint");
-                final Type mapType = new TypeToken<Map<String, String>>() {}.getType();
-                final Map<String, String> headers = new Gson().fromJson(auth.get("headers").toString(), mapType);
-
-                pusherOptions.setAuthorizer(getAuthorizer(endpoint, headers));
-            }
-
-            if (options.has("activityTimeout")) {
-                pusherOptions.setActivityTimeout(options.getInt("activityTimeout"));
-            }
-            if (options.has("cluster")) {
-                pusherOptions.setCluster(options.getString("cluster"));
-            }
-            if (options.has("host")) {
-                pusherOptions.setHost(options.getString("host"));
-            }
-
-            // defaults to encrypted connection on port 443
-            final int port = options.has("port") ? options.getInt("port") : 443;
-            final boolean encrypted = !options.has("encrypted") || options.getBoolean("encrypted");
-
-            if (encrypted) {
-                pusherOptions.setWssPort(port);
-            } else {
-                pusherOptions.setWsPort(port);
-            }
-            pusherOptions.setEncrypted(encrypted);
-
-
-            // create client
-            pusher = new Pusher(json.getString("appKey"), pusherOptions);
-
-            if (isLoggingEnabled) {
-                Log.d(TAG, "init");
-            }
-            result.success(null);
-        } catch (Exception e) {
-            if (isLoggingEnabled) {
-                Log.d(TAG, "init error: " + e.getMessage());
-                e.printStackTrace();
-            }
-        }
+        instance.onMethodCall(call, result);
     }
 
-    private void connect(MethodCall call, Result result) {
-        pusher.connect(new ConnectionEventListener() {
-            @Override
-            public void onConnectionStateChange(final ConnectionStateChange change) {
-                new Handler(Looper.getMainLooper()).post(new Runnable() {
-                    @Override
-                    public void run() {
-                        try {
-                            final JSONObject eventStreamMessageJson = new JSONObject();
-                            final JSONObject connectionStateChangeJson = new JSONObject();
-                            connectionStateChangeJson.put("currentState", change.getCurrentState().toString());
-                            connectionStateChangeJson.put("previousState", change.getPreviousState().toString());
-                            eventStreamMessageJson.put("connectionStateChange", connectionStateChangeJson);
-                            eventSink.success(eventStreamMessageJson.toString());
-                        } catch (Exception e) {
-                            if (isLoggingEnabled) {
-                                Log.d(TAG, "onConnectionStateChange error: " + e.getMessage());
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                });
-            }
-
-            @Override
-            public void onError(final String message, final String code, final Exception ex) {
-                new Handler(Looper.getMainLooper()).post(new Runnable() {
-                    @Override
-                    public void run() {
-                        try {
-                            final String exMessage = ex != null ? ex.getMessage() : null;
-                            final JSONObject eventStreamMessageJson = new JSONObject();
-                            final JSONObject connectionErrorJson = new JSONObject();
-
-                            connectionErrorJson.put("message", message);
-                            connectionErrorJson.put("code", code);
-                            connectionErrorJson.put("exception", exMessage);
-                            eventStreamMessageJson.put("connectionError", connectionErrorJson);
-
-                            eventSink.success(eventStreamMessageJson.toString());
-
-                        } catch (Exception e) {
-                            if (isLoggingEnabled) {
-                                Log.d(TAG, "onError exception: " + e.getMessage());
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                });
-            }
-
-        }, ConnectionState.ALL);
-
-        if (isLoggingEnabled) {
-            Log.d(TAG, "connect");
-        }
-        result.success(null);
-    }
-
-
-    private void disconnect(MethodCall call, Result result) {
-        pusher.disconnect();
-        if (isLoggingEnabled) {
-            Log.d(TAG, "disconnect");
-        }
-        result.success(null);
-    }
-
-    private void subscribe(MethodCall call, Result result) {
-        final String channelName = call.arguments.toString();
-        final String channelType = channelName.split("-")[0];
-        Channel channel = channels.get(channelName);
-
-        if (channel != null && channel.isSubscribed()) {
-            if (isLoggingEnabled) {
-                Log.d(TAG, "Already subscribed, ignoring ...");
-            }
-            result.success(null);
-            return;
-        }
-
-        switch (channelType) {
-            case "private":
-                channel = pusher.subscribePrivate(channelName, eventListenerPrivate);
-                if (isLoggingEnabled) {
-                    Log.d(TAG, "subscribe (private)");
-                }
-                break;
-            case "presence":
-                channel = pusher.subscribePresence(channelName, eventListenerPresence);
-                if (isLoggingEnabled) {
-                    Log.d(TAG, "subscribe (presence)");
-                }
-                break;
-            default:
-                channel = pusher.subscribe(channelName, eventListener);
-
-                if (isLoggingEnabled) {
-                    Log.d(TAG, "subscribe");
-                }
-                break;
+    private PusherInstance getPusherInstance(String instanceId) {
+        if (instanceId != null && !pusherInstanceMap.containsKey(instanceId)) {
+            pusherInstanceMap.put(instanceId, new PusherInstance(instanceId));
         }
-
-        channels.put(channelName, channel);
-        result.success(null);
-    }
-
-    private void unsubscribe(MethodCall call, Result result) {
-        final String channelName = call.arguments.toString();
-        pusher.unsubscribe(call.arguments.toString());
-        channels.remove(channelName);
-
-        if (isLoggingEnabled) {
-            Log.d(TAG, String.format("unsubscribe (%s)", channelName));
-        }
-        result.success(null);
-    }
-
-    private void bind(MethodCall call, Result result) {
-        try {
-            final JSONObject json = new JSONObject(call.arguments.toString());
-            final String channelName = json.getString("channelName");
-            final String channelType = channelName.split("-")[0];
-            final String eventName = json.getString("eventName");
-
-            Channel channel = channels.get(channelName);
-
-            switch (channelType) {
-                case "private":
-                    channel.bind(eventName, eventListenerPrivate);
-                    break;
-                case "presence":
-                    channel.bind(eventName, eventListenerPresence);
-                    break;
-                default:
-                    channel.bind(eventName, eventListener);
-                    break;
-            }
-
-            if (isLoggingEnabled) {
-                Log.d(TAG, String.format("bind (%s)", eventName));
-            }
-            result.success(null);
-        } catch (Exception e) {
-            if (isLoggingEnabled) {
-                Log.d(TAG, String.format("bind exception: %s", e.getMessage()));
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private void unbind(MethodCall call, Result result) {
-        try {
-            final JSONObject json = new JSONObject(call.arguments.toString());
-            final String channelName = json.getString("channelName");
-            final String channelType = channelName.split("-")[0];
-            final String eventName = json.getString("eventName");
-
-            Channel channel = channels.get(channelName);
-            switch (channelType) {
-                case "private":
-                    channel.unbind(eventName, eventListenerPrivate);
-                    break;
-                case "presence":
-                    channel.unbind(eventName, eventListenerPresence);
-                    break;
-                default:
-                    channel.unbind(eventName, eventListener);
-                    break;
-            }
-
-            if (isLoggingEnabled) {
-                Log.d(TAG, String.format("unbind (%s)", eventName));
-            }
-            result.success(null);
-        } catch (Exception e) {
-            if (isLoggingEnabled) {
-                Log.d(TAG, String.format("unbind exception: %s", e.getMessage()));
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private HttpAuthorizer getAuthorizer(String endpoint, Map<String, String> headers) {
-        final ConnectionFactory connection = headers.containsValue("application/json")
-            ? new JsonEncodedConnectionFactory()
-            : new UrlEncodedConnectionFactory();
-
-        final HttpAuthorizer authorizer = new HttpAuthorizer(endpoint, connection);
-        authorizer.setHeaders(headers);
-
-        return authorizer;
-
+        return pusherInstanceMap.get(instanceId);
     }
 }

android/src/main/java/com/github/heywhy/flutter_pusher/PusherInstance.java

@@ -0,0 +1,376 @@
+package com.github.heywhy.flutter_pusher;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import com.github.heywhy.flutter_pusher.listeners.EventChannelListener;
+import com.github.heywhy.flutter_pusher.listeners.PresenceChannelListener;
+import com.github.heywhy.flutter_pusher.listeners.PrivateChannelListener;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.pusher.client.Pusher;
+import com.pusher.client.PusherOptions;
+import com.pusher.client.channel.Channel;
+import com.pusher.client.connection.ConnectionEventListener;
+import com.pusher.client.connection.ConnectionState;
+import com.pusher.client.connection.ConnectionStateChange;
+import com.pusher.client.util.ConnectionFactory;
+import com.pusher.client.util.HttpAuthorizer;
+import com.pusher.client.util.UrlEncodedConnectionFactory;
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+import org.json.JSONObject;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.github.heywhy.flutter_pusher.FlutterPusherPlugin.TAG;
+import static com.github.heywhy.flutter_pusher.FlutterPusherPlugin.eventSink;
+
+public class PusherInstance implements MethodChannel.MethodCallHandler {
+
+    private Pusher pusher;
+    private String instanceId;
+    private boolean isLoggingEnabled = false;
+    private Map<String, Channel> channels = new HashMap<>();
+
+    private EventChannelListener eventListener;
+    private PrivateChannelListener eventListenerPrivate;
+    private PresenceChannelListener eventListenerPresence;
+
+    PusherInstance(String instanceId) {
+        this.instanceId = instanceId;
+    }
+
+    @Override
+    public void onMethodCall(MethodCall call, MethodChannel.Result result) {
+        switch (call.method) {
+            case "init":
+                init(call, result);
+                break;
+            case "connect":
+                connect(call, result);
+                break;
+            case "disconnect":
+                disconnect(call, result);
+                break;
+            case "subscribe":
+                subscribe(call, result);
+                break;
+            case "unsubscribe":
+                unsubscribe(call, result);
+                break;
+            case "bind":
+                bind(call, result);
+                break;
+            case "unbind":
+                unbind(call, result);
+                break;
+            case "trigger":
+                // trigger(call, result);
+                break;
+            case "getSocketId":
+                getSocketId(call, result);
+                break;
+            default:
+                result.notImplemented();
+                break;
+        }
+    }
+
+    private void initListeners() {
+        eventListener = new EventChannelListener(instanceId, isLoggingEnabled);
+        eventListenerPrivate = new PrivateChannelListener(instanceId, isLoggingEnabled);
+        eventListenerPresence = new PresenceChannelListener(instanceId, isLoggingEnabled);
+    }
+
+    private void init(MethodCall call, MethodChannel.Result result) {
+        if (pusher != null) {
+            for (Map.Entry<String, Channel> entry : channels.entrySet()) {
+                String name = entry.getKey();
+                pusher.unsubscribe(name);
+                channels.remove(name);
+            }
+        }
+
+        try {
+            final JSONObject json = new JSONObject(call.arguments.toString());
+            final JSONObject options = json.getJSONObject("options");
+
+            if (json.has("isLoggingEnabled")) {
+                isLoggingEnabled = json.getBoolean("isLoggingEnabled");
+            }
+
+            // setup options
+            final PusherOptions pusherOptions = new PusherOptions();
+
+            if (options.has("auth")) {
+                final JSONObject auth = options.getJSONObject("auth");
+                final String endpoint = auth.getString("endpoint");
+                final Type mapType = new TypeToken<Map<String, String>>() {}.getType();
+                final Map<String, String> headers = new Gson().fromJson(auth.get("headers").toString(), mapType);
+
+                pusherOptions.setAuthorizer(getAuthorizer(endpoint, headers));
+            }
+
+            if (options.has("activityTimeout")) {
+                pusherOptions.setActivityTimeout(options.getInt("activityTimeout"));
+            }
+            if (options.has("cluster")) {
+                pusherOptions.setCluster(options.getString("cluster"));
+            }
+            if (options.has("host")) {
+                pusherOptions.setHost(options.getString("host"));
+            }
+
+            // defaults to encrypted connection on port 443
+            final int port = options.has("port") ? options.getInt("port") : 443;
+            final boolean encrypted = !options.has("encrypted") || options.getBoolean("encrypted");
+
+            if (encrypted) {
+                pusherOptions.setWssPort(port);
+            } else {
+                pusherOptions.setWsPort(port);
+            }
+            pusherOptions.setEncrypted(encrypted);
+
+
+            // create client
+            pusher = new Pusher(json.getString("appKey"), pusherOptions);
+            initListeners();
+
+            if (isLoggingEnabled) {
+                Log.d(TAG, "init");
+            }
+            result.success(null);
+        } catch (Exception e) {
+            if (isLoggingEnabled) {
+                Log.d(TAG, "init error: " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void connect(MethodCall call, MethodChannel.Result result) {
+        pusher.connect(new ConnectionEventListener() {
+            @Override
+            public void onConnectionStateChange(final ConnectionStateChange change) {
+                new Handler(Looper.getMainLooper()).post(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            final JSONObject eventStreamMessageJson = new JSONObject();
+                            final JSONObject connectionStateChangeJson = new JSONObject();
+
+                            connectionStateChangeJson.put("currentState", change.getCurrentState().toString());
+                            connectionStateChangeJson.put("previousState", change.getPreviousState().toString());
+                            eventStreamMessageJson.put("connectionStateChange", connectionStateChangeJson);
+                            eventStreamMessageJson.put("instanceId", instanceId);
+                            eventSink.success(eventStreamMessageJson.toString());
+                        } catch (Exception e) {
+                            if (isLoggingEnabled) {
+                                Log.d(TAG, "onConnectionStateChange error: " + e.getMessage());
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onError(final String message, final String code, final Exception ex) {
+                new Handler(Looper.getMainLooper()).post(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            final String exMessage = ex != null ? ex.getMessage() : null;
+                            final JSONObject eventStreamMessageJson = new JSONObject();
+                            final JSONObject connectionErrorJson = new JSONObject();
+
+                            connectionErrorJson.put("instanceId", instanceId);
+                            connectionErrorJson.put("message", message);
+                            connectionErrorJson.put("code", code);
+                            connectionErrorJson.put("exception", exMessage);
+                            eventStreamMessageJson.put("connectionError", connectionErrorJson);
+                            eventStreamMessageJson.put("instanceId", instanceId);
+
+                            eventSink.success(eventStreamMessageJson.toString());
+
+                        } catch (Exception e) {
+                            if (isLoggingEnabled) {
+                                Log.d(TAG, "onError exception: " + e.getMessage());
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                });
+            }
+
+        }, ConnectionState.ALL);
+
+        if (isLoggingEnabled) {
+            Log.d(TAG, "connect");
+        }
+        result.success(null);
+    }
+
+
+    private void getSocketId(MethodCall call, MethodChannel.Result result) {
+        result.success(pusher.getConnection().getSocketId());
+    }
+
+    private void disconnect(MethodCall call, MethodChannel.Result result) {
+        pusher.disconnect();
+        if (isLoggingEnabled) {
+            Log.d(TAG, "disconnect");
+        }
+        result.success(null);
+    }
+
+    private void subscribe(MethodCall call, MethodChannel.Result result) {
+
+        try {
+            final JSONObject json = new JSONObject(call.arguments.toString());
+            final String channelName = json.getString("channelName");
+            final String channelType = channelName.split("-")[0];
+            Channel channel = channels.get(channelName);
+
+            if (channel != null && channel.isSubscribed()) {
+                if (isLoggingEnabled) {
+                    Log.d(TAG, "Already subscribed, ignoring ...");
+                }
+                result.success(null);
+                return;
+            }
+
+            switch (channelType) {
+                case "private":
+                    channel = pusher.subscribePrivate(channelName, eventListenerPrivate);
+                    if (isLoggingEnabled) {
+                        Log.d(TAG, "subscribe (private)");
+                    }
+                    break;
+                case "presence":
+                    channel = pusher.subscribePresence(channelName, eventListenerPresence);
+                    if (isLoggingEnabled) {
+                        Log.d(TAG, "subscribe (presence)");
+                    }
+                    break;
+                default:
+                    channel = pusher.subscribe(channelName, eventListener);
+
+                    if (isLoggingEnabled) {
+                        Log.d(TAG, "subscribe");
+                    }
+                    break;
+            }
+
+            channels.put(channelName, channel);
+            result.success(null);
+        } catch (Exception e) {
+            if (isLoggingEnabled) {
+                Log.d(TAG, "subscribe error: " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private void unsubscribe(MethodCall call, MethodChannel.Result result) {
+        try {
+            final JSONObject json = new JSONObject(call.arguments.toString());
+            final String channelName = json.getString("channelName");
+            pusher.unsubscribe(channelName);
+            channels.remove(channelName);
+
+            if (isLoggingEnabled) {
+                Log.d(TAG, String.format("unsubscribe (%s)", channelName));
+            }
+            result.success(null);
+        } catch (Exception e) {
+            if (isLoggingEnabled) {
+                Log.d(TAG, "unsubscribe error: " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private void bind(MethodCall call, MethodChannel.Result result) {
+        try {
+            final JSONObject json = new JSONObject(call.arguments.toString());
+            final String channelName = json.getString("channelName");
+            final String channelType = channelName.split("-")[0];
+            final String eventName = json.getString("eventName");
+
+            Channel channel = channels.get(channelName);
+
+            switch (channelType) {
+                case "private":
+                    channel.bind(eventName, eventListenerPrivate);
+                    break;
+                case "presence":
+                    channel.bind(eventName, eventListenerPresence);
+                    break;
+                default:
+                    channel.bind(eventName, eventListener);
+                    break;
+            }
+
+            if (isLoggingEnabled) {
+                Log.d(TAG, String.format("bind (%s)", eventName));
+            }
+            result.success(null);
+        } catch (Exception e) {
+            if (isLoggingEnabled) {
+                Log.d(TAG, String.format("bind exception: %s", e.getMessage()));
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void unbind(MethodCall call, MethodChannel.Result result) {
+        try {
+            final JSONObject json = new JSONObject(call.arguments.toString());
+            final String channelName = json.getString("channelName");
+            final String channelType = channelName.split("-")[0];
+            final String eventName = json.getString("eventName");
+
+            Channel channel = channels.get(channelName);
+            switch (channelType) {
+                case "private":
+                    channel.unbind(eventName, eventListenerPrivate);
+                    break;
+                case "presence":
+                    channel.unbind(eventName, eventListenerPresence);
+                    break;
+                default:
+                    channel.unbind(eventName, eventListener);
+                    break;
+            }
+
+            if (isLoggingEnabled) {
+                Log.d(TAG, String.format("unbind (%s)", eventName));
+            }
+            result.success(null);
+        } catch (Exception e) {
+            if (isLoggingEnabled) {
+                Log.d(TAG, String.format("unbind exception: %s", e.getMessage()));
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private HttpAuthorizer getAuthorizer(String endpoint, Map<String, String> headers) {
+        final ConnectionFactory connection = headers.containsValue("application/json")
+            ? new JsonEncodedConnectionFactory()
+            : new UrlEncodedConnectionFactory();
+
+        final HttpAuthorizer authorizer = new HttpAuthorizer(endpoint, connection);
+        authorizer.setHeaders(headers);
+
+        return authorizer;
+
+    }
+}

android/src/main/java/com/github/heywhy/flutter_pusher/listeners/EventChannelListener.java

@@ -4,8 +4,6 @@
 import android.util.Log;
 import android.os.Looper;
 
-import com.github.heywhy.flutter_pusher.FlutterPusherPlugin;
-
 import com.pusher.client.channel.ChannelEventListener;
 import com.pusher.client.channel.PusherEvent;
 
@@ -14,11 +12,22 @@
 
 import org.json.JSONObject;
 
+import static com.github.heywhy.flutter_pusher.FlutterPusherPlugin.TAG;
+import static com.github.heywhy.flutter_pusher.FlutterPusherPlugin.eventSink;
+
 public class EventChannelListener implements ChannelEventListener {
     static final String SUBSCRIPTION_SUCCESS_EVENT = "pusher:subscription_succeeded";
     static final String MEMBER_ADDED_EVENT = "pusher:member_added";
     static final String MEMBER_REMOVED_EVENT = "pusher:member_removed";
 
+    private String instanceId;
+    private boolean isLoggingEnabled;
+
+    public EventChannelListener(String instanceId, boolean isLoggingEnabled) {
+        this.instanceId = instanceId;
+        this.isLoggingEnabled = isLoggingEnabled;
+    }
+
     static PusherEvent toPusherEvent(String channel, String event, String userId, String data) {
         final Map<String, Object> eventData = new HashMap<>();
 
@@ -47,12 +56,14 @@ public void run() {
                     eventJson.put("channel", channel);
                     eventJson.put("event", event);
                     eventJson.put("data", data);
+                    eventStreamMessageJson.put("isEvent", true);
                     eventStreamMessageJson.put("event", eventJson);
+                    eventStreamMessageJson.put("instanceId", instanceId);
 
-                    FlutterPusherPlugin.eventSink.success(eventStreamMessageJson.toString());
+                    eventSink.success(eventStreamMessageJson.toString());
 
-                    if (FlutterPusherPlugin.isLoggingEnabled) {
-                        Log.d(FlutterPusherPlugin.TAG, String.format("onEvent: \nCHANNEL: %s \nEVENT: %s \nDATA: %s", channel, event, data));
+                    if (isLoggingEnabled) {
+                        Log.d(TAG, String.format("onEvent: \nCHANNEL: %s \nEVENT: %s \nDATA: %s", channel, event, data));
                     }
                 } catch (Exception e) {
                     onError(e);
@@ -73,16 +84,17 @@ public void run() {
                     connectionErrorJson.put("code", "Channel error");
                     connectionErrorJson.put("exception", e);
                     eventStreamMessageJson.put("connectionError", connectionErrorJson);
+                    eventStreamMessageJson.put("instanceId", instanceId);
 
-                    FlutterPusherPlugin.eventSink.success(eventStreamMessageJson.toString());
+                    eventSink.success(eventStreamMessageJson.toString());
 
-                    if (FlutterPusherPlugin.isLoggingEnabled) {
-                        Log.d(FlutterPusherPlugin.TAG, "onError : " + e.getMessage());
+                    if (isLoggingEnabled) {
+                        Log.d(TAG, "onError : " + e.getMessage());
                         e.printStackTrace();
                     }
                 } catch (Exception ex) {
-                    if (FlutterPusherPlugin.isLoggingEnabled) {
-                        Log.d(FlutterPusherPlugin.TAG, "onError exception: " + e.getMessage());
+                    if (isLoggingEnabled) {
+                        Log.d(TAG, "onError exception: " + e.getMessage());
                         ex.printStackTrace();
                     }
                 }

android/src/main/java/com/github/heywhy/flutter_pusher/listeners/PresenceChannelListener.java

@@ -7,6 +7,10 @@
 
 public class PresenceChannelListener extends EventChannelListener implements PresenceChannelEventListener {
 
+    public PresenceChannelListener(String instanceId, boolean isLoggingEnabled) {
+        super(instanceId, isLoggingEnabled);
+    }
+
     @Override
     public void onSubscriptionSucceeded(String channelName) {
         this.onEvent(toPusherEvent(channelName, SUBSCRIPTION_SUCCESS_EVENT, null, null));

android/src/main/java/com/github/heywhy/flutter_pusher/listeners/PrivateChannelListener.java

@@ -4,6 +4,10 @@
 
 public class PrivateChannelListener extends EventChannelListener implements PrivateChannelEventListener {
 
+    public PrivateChannelListener(String instanceId, boolean isLoggingEnabled) {
+        super(instanceId, isLoggingEnabled);
+    }
+
     @Override
     public void onSubscriptionSucceeded(String channelName) {
         this.onEvent(toPusherEvent(channelName, SUBSCRIPTION_SUCCESS_EVENT, null, null));

android/src/main/java/com/github/heywhy/flutter_pusher/platform_messages/BindInstanceMessage.java

@@ -0,0 +1,22 @@
+package com.github.heywhy.flutter_pusher.platform_messages;
+
+public class BindInstanceMessage extends InstanceMessage {
+    private String eventName;
+    private String channelName;
+
+    public String getEventName() {
+        return eventName;
+    }
+
+    public void setEventName(String eventName) {
+        this.eventName = eventName;
+    }
+
+    public String getChannelName() {
+        return channelName;
+    }
+
+    public void setChannelName(String channelName) {
+        this.channelName = channelName;
+    }
+}

android/src/main/java/com/github/heywhy/flutter_pusher/platform_messages/InitInstanceMessage.java

@@ -0,0 +1,113 @@
+package com.github.heywhy.flutter_pusher.platform_messages;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class InitInstanceMessage extends InstanceMessage {
+
+    private String appKey;
+    private InitOptions options;
+    private boolean isLoggingEnabled = false;
+
+    public String getAppKey() {
+        return appKey;
+    }
+
+    public void setAppKey(String appKey) {
+        this.appKey = appKey;
+    }
+
+    public boolean getIsLoggingEnabled() {
+        return isLoggingEnabled;
+    }
+
+    public void setLoggingEnabled(boolean loggingEnabled) {
+        isLoggingEnabled = loggingEnabled;
+    }
+
+    public InitOptions getOptions() {
+        return options;
+    }
+
+    public void setOptions(InitOptions options) {
+        this.options = options;
+    }
+
+    public static class InitOptions {
+        private int port;
+        private String host;
+        private String cluster;
+        private AuthOption auth;
+        private boolean encrypted = true;
+        private int activityTimeout;
+
+        public int getPort() {
+            return port;
+        }
+
+        public void setPort(int port) {
+            this.port = port;
+        }
+
+        public String getHost() {
+            return host;
+        }
+
+        public void setHost(String host) {
+            this.host = host;
+        }
+
+        public String getCluster() {
+            return cluster;
+        }
+
+        public void setCluster(String cluster) {
+            this.cluster = cluster;
+        }
+
+        public AuthOption getAuth() {
+            return auth;
+        }
+
+        public void setAuth(AuthOption auth) {
+            this.auth = auth;
+        }
+
+        public boolean getEncrypted() {
+            return encrypted;
+        }
+
+        public void setEncrypted(boolean encrypted) {
+            this.encrypted = encrypted;
+        }
+
+        public int getActivityTimeout() {
+            return activityTimeout;
+        }
+
+        public void setActivityTimeout(int activityTimeout) {
+            this.activityTimeout = activityTimeout;
+        }
+    }
+
+    public static class AuthOption {
+        private String endpoint;
+        private Map<String, String> headers = Collections.emptyMap();
+
+        public String getEndpoint() {
+            return endpoint;
+        }
+
+        public void setEndpoint(String endpoint) {
+            this.endpoint = endpoint;
+        }
+
+        public Map<String, String> getHeaders() {
+            return headers;
+        }
+
+        public void setHeaders(Map<String, String> headers) {
+            this.headers = headers;
+        }
+    }
+}

android/src/main/java/com/github/heywhy/flutter_pusher/platform_messages/InstanceMessage.java

@@ -0,0 +1,13 @@
+package com.github.heywhy.flutter_pusher.platform_messages;
+
+public class InstanceMessage {
+    private String instanceId;
+
+    public String getInstanceId() {
+        return instanceId;
+    }
+
+    public void setInstanceId(String instanceId) {
+        this.instanceId = instanceId;
+    }
+}

android/src/main/java/com/github/heywhy/flutter_pusher/platform_messages/SubscriptionInstanceMessage.java

@@ -0,0 +1,14 @@
+package com.github.heywhy.flutter_pusher.platform_messages;
+
+public class SubscriptionInstanceMessage extends InstanceMessage {
+
+    private String channelName;
+
+    public String getChannelName() {
+        return channelName;
+    }
+
+    public void setChannelName(String channelName) {
+        this.channelName = channelName;
+    }
+}

example/.flutter-plugins-dependencies

@@ -0,0 +1 @@
+{"_info":"// This is a generated file; do not edit or check into version control.","dependencyGraph":[{"name":"flutter_pusher_client","dependencies":[]}]}

example/lib/main.dart

@@ -33,7 +33,7 @@ class _MyAppState extends State<MyApp> {
 
       pusher
           .subscribe('channel')
-          .bind('event', (event) => log('event' + event.toJson().toString()));
+          .bind('event', (event) => log('event =>' + event.toString()));
     } on PlatformException {
       platformVersion = 'Failed to get platform version.';
     }

example/pubspec.lock

@@ -1,13 +1,27 @@
 # Generated by pub
 # See https://dart.dev/tools/pub/glossary#lockfile
 packages:
+  archive:
+    dependency: transitive
+    description:
+      name: archive
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.0.11"
+  args:
+    dependency: transitive
+    description:
+      name: args
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "1.5.2"
   async:
     dependency: transitive
     description:
       name: async
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.3.0"
+    version: "2.4.0"
   boolean_selector:
     dependency: transitive
     description:
@@ -29,6 +43,20 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.14.11"
+  convert:
+    dependency: transitive
+    description:
+      name: convert
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.1.1"
+  crypto:
+    dependency: transitive
+    description:
+      name: crypto
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.1.3"
   cupertino_icons:
     dependency: "direct main"
     description:
@@ -47,12 +75,19 @@ packages:
       path: ".."
       relative: true
     source: path
-    version: "0.1.1"
+    version: "0.1.2"
   flutter_test:
     dependency: "direct dev"
     description: flutter
     source: sdk
     version: "0.0.0"
+  image:
+    dependency: transitive
+    description:
+      name: image
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.1.4"
   json_annotation:
     dependency: transitive
     description:
@@ -66,14 +101,14 @@ packages:
       name: matcher
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.12.5"
+    version: "0.12.6"
   meta:
     dependency: transitive
     description:
       name: meta
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.1.7"
+    version: "1.1.8"
   path:
     dependency: transitive
     description:
@@ -88,6 +123,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.8.0+1"
+  petitparser:
+    dependency: transitive
+    description:
+      name: petitparser
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.4.0"
   quiver:
     dependency: transitive
     description:
@@ -141,7 +183,7 @@ packages:
       name: test_api
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.2.5"
+    version: "0.2.11"
   typed_data:
     dependency: transitive
     description:
@@ -156,5 +198,12 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "2.0.8"
+  xml:
+    dependency: transitive
+    description:
+      name: xml
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.5.0"
 sdks:
-  dart: ">=2.3.0 <3.0.0"
+  dart: ">=2.4.0 <3.0.0"

ios/Classes/SwiftFlutterPusherPlugin.swift

@@ -1,14 +1,364 @@
 import Flutter
 import UIKit
+import PusherSwift
 
-public class SwiftFlutterPusherPlugin: NSObject, FlutterPlugin {
-  public static func register(with registrar: FlutterPluginRegistrar) {
-    let channel = FlutterMethodChannel(name: "com.github.heywhy/pusher", binaryMessenger: registrar.messenger())
-    let instance = SwiftFlutterPusherPlugin()
-    registrar.addMethodCallDelegate(instance, channel: channel)
-  }
+public class SwiftFlutterPusherPlugin: NSObject, FlutterPlugin, PusherDelegate {
 
-  public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
-    result("iOS " + UIDevice.current.systemVersion)
-  }
+
+    public static var pusher: Pusher?
+    public static var isLoggingEnabled: Bool = false;
+    public static var bindedEvents = [String:String]()
+    public static var channels = [String:PusherChannel]()
+    public static var eventSink: FlutterEventSink?
+
+    public static func register(with registrar: FlutterPluginRegistrar) {
+        let channel = FlutterMethodChannel(name: "com.github.heywhy/pusher", binaryMessenger: registrar.messenger())
+        let instance = SwiftFlutterPusherPlugin()
+        let eventChannel = FlutterEventChannel(name: "com.github.heywhy/pusherStream", binaryMessenger: registrar.messenger())
+
+        registrar.addMethodCallDelegate(instance, channel: channel)
+        eventChannel.setStreamHandler(StreamHandler())
+    }
+
+    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        switch call.method {
+            case "init":
+                setup(call, result: result)
+            case "connect":
+                connect(call, result: result)
+            case "disconnect":
+                disconnect(call, result: result)
+            case "subscribe":
+                subscribe(call, result: result)
+            case "unsubscribe":
+                unsubscribe(call, result: result)
+            case "bind":
+                bind(call, result: result)
+            case "unbind":
+                unbind(call, result: result)
+            case "trigger":
+                // trigger(call, result: result)
+            default:
+                result(FlutterMethodNotImplemented)
+        }
+    }
+
+
+    public func setup(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        if let pusherObj = SwiftPusherPlugin.pusher {
+            pusherObj.unbindAll();
+            pusherObj.unsubscribeAll()
+        }
+
+        for (_, pusherChannel) in SwiftPusherPlugin.channels {
+            pusherChannel.unbindAll()
+        }
+
+        SwiftPusherPlugin.channels.removeAll();
+        SwiftPusherPlugin.bindedEvents.removeAll()
+
+        do {
+            let json = call.arguments as! String
+            let jsonDecoder = JSONDecoder()
+            let initArgs = try jsonDecoder.decode(InitArgs.self, from: json.data(using: .utf8)!)
+
+            SwiftPusherPlugin.isLoggingEnabled = initArgs.isLoggingEnabled
+
+            let options = PusherClientOptions(
+                authMethod: initArgs.options.auth != nil ? AuthMethod.authRequestBuilder(authRequestBuilder: AuthRequestBuilder(endpoint: initArgs.options.auth!.endpoint, headers: initArgs.options.auth!.headers)): .noMethod,
+                host: initArgs.options.host != nil ? .host(initArgs.options.host!) : (initArgs.options.cluster != nil ? .cluster(initArgs.options.cluster!) : .host("ws.pusherapp.com")),
+                port: initArgs.options.port ?? (initArgs.options.encrypted ?? true ? 443 : 80),
+                encrypted: initArgs.options.encrypted ?? true,
+                activityTimeout: Double(initArgs.options.activityTimeout ?? 30000) / 1000
+            )
+
+            SwiftPusherPlugin.pusher = Pusher(
+                key: initArgs.appKey,
+                options: options
+            )
+            SwiftPusherPlugin.pusher!.connection.delegate = self
+
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher init")
+            }
+        } catch {
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher init error:" + error.localizedDescription)
+            }
+        }
+        result(nil);
+    }
+
+    public func connect(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        if let pusherObj = SwiftPusherPlugin.pusher {
+            pusherObj.connect();
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher connect")
+            }
+        }
+        result(nil);
+    }
+
+    public func disconnect(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        if let pusherObj = SwiftPusherPlugin.pusher {
+            pusherObj.disconnect();
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher disconnect")
+            }
+        }
+        result(nil);
+    }
+
+    public func subscribe(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        if let pusherObj = SwiftPusherPlugin.pusher {
+            let channelName = call.arguments as! String
+            let channelType = channelName.components(separatedBy: "-")[0]
+            var channel: PusherChannel
+
+            switch channelType{
+            case "private":
+                channel = pusherObj.subscribe(channelName)
+                if (SwiftPusherPlugin.isLoggingEnabled) {
+                    print("Pusher subscribe (private)")
+                }
+            case "presence":
+                channel = pusherObj.subscribeToPresenceChannel(channelName: channelName)
+                if (SwiftPusherPlugin.isLoggingEnabled) {
+                    print("Pusher subscribe (presence)")
+                }
+            default:
+                channel = pusherObj.subscribe(channelName)
+                if (SwiftPusherPlugin.isLoggingEnabled) {
+                    print("Pusher subscribe")
+                }
+            }
+
+            SwiftPusherPlugin.channels[channelName] = channel;
+        }
+        result(nil);
+    }
+
+    public func subscribeToPresence(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        if let pusherObj = SwiftPusherPlugin.pusher {
+            let channelName = call.arguments as! String
+            let channel = pusherObj.subscribeToPresenceChannel(channelName: channelName)
+            SwiftPusherPlugin.channels[channelName] = channel;
+
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher subscribe to presence channel")
+            }
+        }
+        result(nil);
+    }
+
+    public func unsubscribe(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        if let pusherObj = SwiftPusherPlugin.pusher {
+            let channelName = call.arguments as! String
+            pusherObj.unsubscribe(channelName)
+            SwiftPusherPlugin.channels.removeValue(forKey: "channelName")
+
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher unsubscribe")
+            }
+        }
+        result(nil);
+    }
+
+    public func bind(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        do {
+            let json = call.arguments as! String
+            let jsonDecoder = JSONDecoder()
+            let bindArgs = try jsonDecoder.decode(BindArgs.self, from: json.data(using: .utf8)!)
+
+            let channel = SwiftPusherPlugin.channels[bindArgs.channelName]
+            if let channelObj = channel {
+                unbindIfBound(channelName: bindArgs.channelName, eventName: bindArgs.eventName)
+                SwiftPusherPlugin.bindedEvents[bindArgs.channelName + bindArgs.eventName] = channelObj.bind(eventName: bindArgs.eventName, callback: { data in
+                    do {
+                        if let dataObj = data as? [String : AnyObject] {
+                            let pushJsonData = try! JSONSerialization.data(withJSONObject: dataObj)
+                            let pushJsonString = NSString(data: pushJsonData, encoding: String.Encoding.utf8.rawValue)
+                            let event = Event(channel: bindArgs.channelName, event: bindArgs.eventName, data: pushJsonString! as String)
+                            let message = PusherEventStreamMessage(event: event, connectionStateChange:  nil)
+                            let jsonEncoder = JSONEncoder()
+                            let jsonData = try jsonEncoder.encode(message)
+                            let jsonString = String(data: jsonData, encoding: .utf8)
+                            if let eventSinkObj = SwiftPusherPlugin.eventSink {
+                                eventSinkObj(jsonString)
+
+                                if (SwiftPusherPlugin.isLoggingEnabled) {
+                                    print("Pusher event: CHANNEL:\(bindArgs.channelName) EVENT:\(bindArgs.eventName) DATA:\(jsonString ?? "no data")")
+                                }
+                            }
+                        }
+                    } catch {
+                        if (SwiftPusherPlugin.isLoggingEnabled) {
+                            print("Pusher bind error:" + error.localizedDescription)
+                        }
+                    }
+                })
+                if (SwiftPusherPlugin.isLoggingEnabled) {
+                    print("Pusher bind (\(bindArgs.eventName))")
+                }
+            }
+        } catch {
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher bind error:" + error.localizedDescription)
+            }
+        }
+        result(nil);
+    }
+
+    public func unbind(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        do {
+            let json = call.arguments as! String
+            let jsonDecoder = JSONDecoder()
+            let bindArgs = try jsonDecoder.decode(BindArgs.self, from: json.data(using: .utf8)!)
+            unbindIfBound(channelName: bindArgs.channelName, eventName: bindArgs.eventName)
+        } catch {
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher unbind error:" + error.localizedDescription)
+            }
+        }
+        result(nil);
+    }
+
+    private func unbindIfBound(channelName: String, eventName: String) {
+        let channel = SwiftPusherPlugin.channels[channelName]
+        if let channelObj = channel {
+            let callbackId = SwiftPusherPlugin.bindedEvents[channelName + eventName]
+            if let callbackIdObj = callbackId {
+                channelObj.unbind(eventName: eventName, callbackId: callbackIdObj)
+                SwiftPusherPlugin.bindedEvents.removeValue(forKey: channelName + eventName)
+
+                if (SwiftPusherPlugin.isLoggingEnabled) {
+                    print("Pusher unbind")
+                }
+            }
+        }
+    }
+
+    public func changedConnectionState(from old: ConnectionState, to new: ConnectionState) {
+        do {
+            let stateChange = ConnectionStateChange(currentState: new.stringValue(), previousState: old.stringValue())
+            let message = PusherEventStreamMessage(event: nil, connectionStateChange: stateChange)
+            let jsonEncoder = JSONEncoder()
+            let jsonData = try jsonEncoder.encode(message)
+            let jsonString = String(data: jsonData, encoding: .utf8)
+            if let eventSinkObj = SwiftPusherPlugin.eventSink {
+                eventSinkObj(jsonString)
+            }
+        } catch {
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher changedConnectionState error:" + error.localizedDescription)
+            }
+        }
+    }
+
+    public func trigger(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        do {
+            let json = call.arguments as! String
+            let jsonDecoder = JSONDecoder()
+            let bindArgs = try jsonDecoder.decode(BindArgs.self, from: json.data(using: .utf8)!)
+
+            let channel = SwiftPusherPlugin.channels[bindArgs.channelName]
+            if let channelObj = channel {
+                let eventName = bindArgs.eventName
+
+                channelObj.trigger(eventName: eventName, data: [])
+            }
+        } catch {
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Pusher trigger error:" + error.localizedDescription)
+            }
+        }
+    }
+}
+
+
+class AuthRequestBuilder: AuthRequestBuilderProtocol {
+    var endpoint: String
+    var headers: [String: String]
+
+    init(endpoint: String, headers: [String: String]) {
+        self.endpoint = endpoint
+        self.headers = headers
+    }
+
+    func requestFor(socketID: String, channelName: String) -> URLRequest? {
+        do{
+            var request = URLRequest(url: URL(string: endpoint)!)
+            request.httpMethod = "POST"
+
+            if(headers.values.contains("application/json")){
+                let jsonEncoder = JSONEncoder()
+                request.httpBody = try jsonEncoder.encode(["socket_id": socketID, "channel_name": channelName])
+            }else{
+                request.httpBody = "socket_id=\(socketID)&channel_name=\(channelName)".data(using: String.Encoding.utf8)
+            }
+
+            for (key, value) in headers {
+                request.addValue(value, forHTTPHeaderField: key)
+            }
+            return request
+        } catch {
+            if (SwiftPusherPlugin.isLoggingEnabled) {
+                print("Authentication error:" + error.localizedDescription)
+            }
+            return nil
+        }
+
+    }
+}
+
+class StreamHandler: NSObject, FlutterStreamHandler {
+    public func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? {
+        SwiftPusherPlugin.eventSink = events
+        return nil;
+    }
+
+    public func onCancel(withArguments arguments: Any?) -> FlutterError? {
+        return nil;
+    }
+}
+
+struct InitArgs: Codable {
+    var appKey: String
+    var options: Options
+    var isLoggingEnabled: Bool
+}
+
+struct Options: Codable {
+    var cluster: String?
+    var host: String?
+    var port: Int?
+    var encrypted: Bool?
+    var auth: Auth?
+    var activityTimeout: Int?
+}
+
+struct Auth: Codable{
+    var endpoint: String
+    var headers: [String: String]
+}
+
+struct PusherEventStreamMessage: Codable {
+    var event: Event?
+    var connectionStateChange: ConnectionStateChange?
+}
+
+struct ConnectionStateChange: Codable {
+    var currentState: String
+    var previousState: String
+}
+
+struct Event: Codable {
+    var channel: String
+    var event: String
+    var data: String
+}
+
+struct BindArgs: Codable {
+    var channelName: String
+    var eventName: String
 }

ios/Classes/UserAgent.h

@@ -0,0 +1,4 @@
+// Generated file, do not edit
+#define LIBRARY_VERSION @"0.0.4"
+#define LIBRARY_NAME @"flutter_pusher_client"
+#define PUSHER_LIBRARY_VERSION @"7.0.0"

ios/flutter_pusher.podspec

@@ -1,6 +1,11 @@
 #
 # To learn more about a Podspec see http://guides.cocoapods.org/syntax/podspec.html
 #
+require 'yaml'
+pubspec = YAML.load_file(File.join('..', 'pubspec.yaml'))
+libraryVersion = pubspec['version'].gsub('+', '-')
+pusherLibraryVersion = '~> 7.2'
+
 Pod::Spec.new do |s|
   s.name             = 'flutter_pusher_client'
   s.version          = '0.1.0'
@@ -15,7 +20,15 @@ A new flutter plugin project.
   s.source_files = 'Classes/**/*'
   s.public_header_files = 'Classes/**/*.h'
   s.dependency 'Flutter'
+  s.dependency 'PusherSwift', pusherLibraryVersion
+
+  s.ios.deployment_target = '9.0'
 
-  s.ios.deployment_target = '8.0'
+s.prepare_command = <<-CMD
+    echo // Generated file, do not edit > Classes/UserAgent.h
+    echo "#define LIBRARY_VERSION @\\"#{libraryVersion}\\"" >> Classes/UserAgent.h
+    echo "#define LIBRARY_NAME @\\"flutter_pusher_client\\"" >> Classes/UserAgent.h
+    echo "#define PUSHER_LIBRARY_VERSION @\\"#{pusherLibraryVersion}\\"" >> Classes/UserAgent.h
+  CMD
 end
 

lib/flutter_pusher.dart

@@ -26,11 +26,12 @@ class Channel {
   }
 
   void _subscribe() async {
-    await _channel.invokeMethod('subscribe', this.name);
+    await _channel.invokeMethod('subscribe',
+        {'channelName': this.name, 'instanceId': pusher._instanceId});
   }
 
   /// Bind to listen for events sent on the given channel
-  Future bind(String eventName, void Function(Event) onEvent) async {
+  Future bind(String eventName, Function onEvent) async {
     await this.pusher._bind(name, eventName, onEvent: onEvent);
   }
 
@@ -54,14 +55,15 @@ class Channel {
 class FlutterPusher {
   static const MethodChannel _channel =
       const MethodChannel('com.github.heywhy/pusher');
-  static const EventChannel _eventChannel =
+  final EventChannel _eventChannel =
       const EventChannel('com.github.heywhy/pusherStream');
+  static num _instances = 0;
 
-  Map<String, void Function(Event)> eventCallbacks =
-      Map<String, void Function(Event)>();
-
-  static void Function(ConnectionError) _onError;
-  static void Function(ConnectionStateChange) _onConnectionStateChange;
+  num _instanceId;
+  String _socketId;
+  Map<String, Function> _eventCallbacks = Map<String, Function>();
+  void Function(ConnectionError) _onError;
+  void Function(ConnectionStateChange) _onConnectionStateChange;
 
   FlutterPusher(
     String appKey,
@@ -72,12 +74,13 @@ class FlutterPusher {
     void Function(ConnectionStateChange) onConnectionStateChange,
   })  : assert(appKey != null),
         assert(options != null) {
-
+    _instanceId = _instances++;
     _onError = onError;
     _onConnectionStateChange = onConnectionStateChange;
     _init(appKey, options, enableLogging: enableLogging);
     if (!lazyConnect) {
-      connect(onError: onError, onConnectionStateChange: onConnectionStateChange);
+      connect(
+          onError: onError, onConnectionStateChange: onConnectionStateChange);
     }
   }
 
@@ -87,16 +90,18 @@ class FlutterPusher {
     void Function(ConnectionError) onError,
   }) async {
     _onConnectionStateChange = onConnectionStateChange != null
-      ? onConnectionStateChange : _onConnectionStateChange;
+        ? onConnectionStateChange
+        : _onConnectionStateChange;
     _onError = onError != null ? onError : _onError;
 
-    await _channel.invokeMethod('connect');
+    await _channel.invokeMethod(
+        'connect', jsonEncode({'instanceId': _instanceId}));
   }
 
-
   /// Disconnect the client from pusher
   Future disconnect() async {
-    await _channel.invokeMethod('disconnect');
+    await _channel.invokeMethod(
+        'disconnect', jsonEncode({'instanceId': _instanceId}));
   }
 
   /// Subscribe to a channel
@@ -107,13 +112,19 @@ class FlutterPusher {
 
   /// Unsubscribe from a channel
   Future unsubscribe(String channelName) async {
-    await _channel.invokeMethod('unsubscribe', channelName);
+    await _channel.invokeMethod(
+        'unsubscribe', {'channelName': channelName, 'instanceId': _instanceId});
+  }
+
+  String getSocketId() {
+    return _socketId;
   }
 
   void _init(String appKey, PusherOptions options, {bool enableLogging}) async {
     _eventChannel.receiveBroadcastStream().listen(_handleEvent);
 
     final initArgs = jsonEncode(InitArgs(
+      _instanceId,
       appKey,
       options,
       isLoggingEnabled: enableLogging,
@@ -122,16 +133,21 @@ class FlutterPusher {
     await _channel.invokeMethod('init', initArgs);
   }
 
-  void _handleEvent([dynamic arguments]) {
+  void _handleEvent([dynamic arguments]) async {
     var message = PusherEventStreamMessage.fromJson(jsonDecode(arguments));
 
+    if (message.instanceId != _instanceId.toString()) {
+      return;
+    }
+
     if (message.isEvent) {
       var callback =
-          eventCallbacks[message.event.channel + message.event.event];
+          _eventCallbacks[message.event.channel + message.event.event];
       if (callback != null) {
-        callback(message.event);
+        callback(jsonDecode(message.event.data));
       }
     } else if (message.isConnectionStateChange) {
+      _socketId = await _channel.invokeMethod('getSocketId', {'instanceId': _instanceId});
       if (_onConnectionStateChange != null) {
         _onConnectionStateChange(message.connectionStateChange);
       }
@@ -145,29 +161,32 @@ class FlutterPusher {
   Future _bind(
     String channelName,
     String eventName, {
-    void Function(Event) onEvent,
+    Function onEvent,
   }) async {
     final bindArgs = jsonEncode(BindArgs(
+      instanceId: _instanceId,
       channelName: channelName,
       eventName: eventName,
     ).toJson());
 
-    eventCallbacks[channelName + eventName] = onEvent;
+    _eventCallbacks[channelName + eventName] = onEvent;
     await _channel.invokeMethod('bind', bindArgs);
   }
 
   Future _unbind(String channelName, String eventName) async {
     final bindArgs = jsonEncode(BindArgs(
+      instanceId: _instanceId,
       channelName: channelName,
       eventName: eventName,
     ).toJson());
 
-    eventCallbacks.remove(channelName + eventName);
+    _eventCallbacks.remove(channelName + eventName);
     await _channel.invokeMethod('unbind', bindArgs);
   }
 
   Future _trigger(String channelName, String eventName) async {
     final bindArgs = jsonEncode(BindArgs(
+      instanceId: _instanceId,
       channelName: channelName,
       eventName: eventName,
     ).toJson());
@@ -177,45 +196,47 @@ class FlutterPusher {
 }
 
 class PusherClient extends FlutterPusher {
-    PusherClient(
+  PusherClient(
     String appKey,
     PusherOptions options, {
     bool lazyConnect = false,
     bool enableLogging = false,
     void Function(ConnectionError) onError,
     void Function(ConnectionStateChange) onConnectionStateChange,
   }) : super(
-        appKey,
-        options,
-        onError: onError,
-        lazyConnect: lazyConnect,
-        enableLogging: enableLogging,
-        onConnectionStateChange: onConnectionStateChange,
-      );
+          appKey,
+          options,
+          onError: onError,
+          lazyConnect: lazyConnect,
+          enableLogging: enableLogging,
+          onConnectionStateChange: onConnectionStateChange,
+        );
 }
 
-
 @JsonSerializable()
 class BindArgs {
+  final int instanceId;
   final String channelName;
   final String eventName;
 
-  BindArgs({this.channelName, this.eventName});
+  BindArgs({this.channelName, this.eventName, this.instanceId})
+      : assert(instanceId != null);
 
   factory BindArgs.fromJson(Map<String, dynamic> json) =>
       _$BindArgsFromJson(json);
 
   Map<String, dynamic> toJson() => _$BindArgsToJson(this);
 }
 
-
 @JsonSerializable()
 class InitArgs {
+  final int instanceId;
   final String appKey;
   final PusherOptions options;
   final bool isLoggingEnabled;
 
-  InitArgs(this.appKey, this.options, {this.isLoggingEnabled = false});
+  InitArgs(this.instanceId, this.appKey, this.options,
+      {this.isLoggingEnabled = false});
 
   factory InitArgs.fromJson(Map<String, dynamic> json) =>
       _$InitArgsFromJson(json);
@@ -266,6 +287,7 @@ class PusherAuth {
 @JsonSerializable()
 class PusherEventStreamMessage {
   final Event event;
+  final String instanceId;
   final ConnectionStateChange connectionStateChange;
   final ConnectionError connectionError;
 
@@ -276,7 +298,10 @@ class PusherEventStreamMessage {
   bool get isConnectionError => connectionError != null;
 
   PusherEventStreamMessage(
-      {this.event, this.connectionStateChange, this.connectionError});
+      {this.event,
+      this.instanceId,
+      this.connectionStateChange,
+      this.connectionError});
 
   factory PusherEventStreamMessage.fromJson(Map<String, dynamic> json) =>
       _$PusherEventStreamMessageFromJson(json);

lib/flutter_pusher.g.dart

@@ -15,6 +15,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "0.2.1"
+  archive:
+    dependency: transitive
+    description:
+      name: archive
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.0.11"
   args:
     dependency: transitive
     description:
@@ -28,7 +35,7 @@ packages:
       name: async
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.3.0"
+    version: "2.4.0"
   boolean_selector:
     dependency: transitive
     description:
@@ -221,6 +228,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "3.1.3"
+  image:
+    dependency: transitive
+    description:
+      name: image
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.1.4"
   io:
     dependency: transitive
     description:
@@ -269,14 +283,14 @@ packages:
       name: matcher
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.12.5"
+    version: "0.12.6"
   meta:
     dependency: transitive
     description:
       name: meta
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.1.7"
+    version: "1.1.8"
   mime:
     dependency: transitive
     description:
@@ -326,6 +340,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.8.0+1"
+  petitparser:
+    dependency: transitive
+    description:
+      name: petitparser
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.4.0"
   pool:
     dependency: transitive
     description:
@@ -428,7 +449,7 @@ packages:
       name: test_api
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.2.5"
+    version: "0.2.11"
   timing:
     dependency: transitive
     description:
@@ -464,6 +485,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.1.0"
+  xml:
+    dependency: transitive
+    description:
+      name: xml
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.5.0"
   yaml:
     dependency: transitive
     description:
@@ -472,4 +500,4 @@ packages:
     source: hosted
     version: "2.2.0"
 sdks:
-  dart: ">=2.3.0 <3.0.0"
+  dart: ">=2.4.0 <3.0.0"

pubspec.lock

@@ -1,7 +1,7 @@
 name: flutter_pusher_client
 description: A Flutter plugin to listen to events sent through pusher. Wraps the native Java and Swift libraries
-version: 0.1.1
-author: Atanda Rasheed <atandarash@gmail.com>
+version: 0.1.2
+# author: Atanda Rasheed <atandarash@gmail.com>
 homepage: https://github.com/heywhy/flutter-pusher-client
 
 environment: