Dev decrypt plus retry

src/main/java/com/pusher/client/channel/PrivateEncryptedChannelEventListener.java

@@ -6,5 +6,5 @@
  */
 public interface PrivateEncryptedChannelEventListener extends PrivateChannelEventListener {
 
-    //  TODO: add onDecryptionFailure
+    void onDecryptionFailure(String event, String reason);
 }

src/main/java/com/pusher/client/channel/impl/ChannelImpl.java

@@ -89,33 +89,29 @@ public boolean isSubscribed() {
 
     /* InternalChannel implementation */
 
+    @Override
+    public PusherEvent prepareEvent(String event, String message) {
+        return GSON.fromJson(message, PusherEvent.class);
+    }
+
     @Override
     public void onMessage(final String event, final String message) {
 
         if (event.equals(SUBSCRIPTION_SUCCESS_EVENT)) {
             updateState(ChannelState.SUBSCRIBED);
-        }
-        else {
-            final Set<SubscriptionEventListener> listeners;
-            synchronized (lock) {
-                final Set<SubscriptionEventListener> sharedListeners = eventNameToListenerMap.get(event);
-                if (sharedListeners != null) {
-                    listeners = new HashSet<SubscriptionEventListener>(sharedListeners);
-                }
-                else {
-                    listeners = null;
-                }
-            }
-
+        } else {
+            final Set<SubscriptionEventListener> listeners = getInterestedListeners(event);
             if (listeners != null) {
-                for (final SubscriptionEventListener listener : listeners) {
-                    final PusherEvent e = GSON.fromJson(message, PusherEvent.class);
-                    factory.queueOnEventThread(new Runnable() {
-                        @Override
-                        public void run() {
-                            listener.onEvent(e);
-                        }
-                    });
+                final PusherEvent pusherEvent = prepareEvent(event, message);
+                if (pusherEvent != null) {
+                    for (final SubscriptionEventListener listener : listeners) {
+                        factory.queueOnEventThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                listener.onEvent(pusherEvent);
+                            }
+                        });
+                    }
                 }
             }
         }
@@ -213,4 +209,18 @@ private void validateArguments(final String eventName, final SubscriptionEventLi
                     "Cannot bind or unbind to events on a channel that has been unsubscribed. Call Pusher.subscribe() to resubscribe to this channel");
         }
     }
+
+    protected Set<SubscriptionEventListener> getInterestedListeners(String event) {
+        synchronized (lock) {
+
+            final Set<SubscriptionEventListener> sharedListeners =
+                    eventNameToListenerMap.get(event);
+
+            if (sharedListeners == null) {
+                return null;
+            }
+
+            return new HashSet<>(sharedListeners);
+        }
+    }
 }

src/main/java/com/pusher/client/channel/impl/InternalChannel.java

@@ -3,13 +3,16 @@
 import com.pusher.client.channel.Channel;
 import com.pusher.client.channel.ChannelEventListener;
 import com.pusher.client.channel.ChannelState;
+import com.pusher.client.channel.PusherEvent;
 
 public interface InternalChannel extends Channel, Comparable<InternalChannel> {
 
     String toSubscribeMessage();
 
     String toUnsubscribeMessage();
 
+    PusherEvent prepareEvent(String event, String message);
+
     void onMessage(String event, String message);
 
     void updateState(ChannelState state);

src/main/java/com/pusher/client/channel/impl/PrivateEncryptedChannelImpl.java

@@ -5,18 +5,21 @@
 import com.pusher.client.channel.ChannelState;
 import com.pusher.client.channel.PrivateEncryptedChannel;
 import com.pusher.client.channel.PrivateEncryptedChannelEventListener;
+import com.pusher.client.channel.PusherEvent;
 import com.pusher.client.channel.SubscriptionEventListener;
 import com.pusher.client.connection.ConnectionEventListener;
 import com.pusher.client.connection.ConnectionState;
 import com.pusher.client.connection.ConnectionStateChange;
 import com.pusher.client.connection.impl.InternalConnection;
+import com.pusher.client.crypto.nacl.AuthenticityException;
 import com.pusher.client.crypto.nacl.SecretBoxOpener;
 import com.pusher.client.crypto.nacl.SecretBoxOpenerFactory;
 import com.pusher.client.util.Factory;
 import com.pusher.client.util.internal.Base64;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 
 public class PrivateEncryptedChannelImpl extends ChannelImpl implements PrivateEncryptedChannel {
 
@@ -124,6 +127,69 @@ public void updateState(ChannelState state) {
         }
     }
 
+    @Override
+    public PusherEvent prepareEvent(String event, String message) {
+
+        try {
+            return decryptMessage(message);
+        } catch (AuthenticityException e1) {
+
+            // retry once only.
+            disposeSecretBoxOpener();
+            authenticate();
+
+            try {
+                return decryptMessage(message);
+            } catch (AuthenticityException e2) {
+                // deliberately not destroying the secretBoxOpener so the next message
+                // has an opportunity to fetch a new key and decrypt
+                notifyListenersOfDecryptFailure(event, "Failed to decrypt message.");
+            }
+        }
+
+        return null;
+    }
+
+    private void notifyListenersOfDecryptFailure(final String event, final String reason) {
+        Set<SubscriptionEventListener> listeners = getInterestedListeners(event);
+        if (listeners != null) {
+            for (SubscriptionEventListener listener : listeners) {
+                ((PrivateEncryptedChannelEventListener)listener).onDecryptionFailure(
+                        event, reason);
+            }
+        }
+    }
+
+    private class EncryptedReceivedData {
+        String nonce;
+        String ciphertext;
+
+        public byte[] getNonce() {
+            return Base64.decode(nonce);
+        }
+
+        public byte[] getCiphertext() {
+            return Base64.decode(ciphertext);
+        }
+    }
+
+    private PusherEvent decryptMessage(String message) {
+
+        Map<String, Object> receivedMessage =
+                GSON.<Map<String, Object>>fromJson(message, Map.class);
+
+        final EncryptedReceivedData encryptedReceivedData =
+                GSON.fromJson((String)receivedMessage.get("data"), EncryptedReceivedData.class);
+
+        String decryptedData = new String(secretBoxOpener.open(
+                encryptedReceivedData.getCiphertext(),
+                encryptedReceivedData.getNonce()));
+
+        receivedMessage.replace("data", decryptedData);
+
+        return new PusherEvent(receivedMessage);
+    }
+
     private void disposeSecretBoxOpener() {
         if (secretBoxOpener != null) {
             secretBoxOpener.clearKey();

src/main/java/com/pusher/client/example/PrivateEncryptedChannelExampleApp.java

@@ -86,4 +86,10 @@ public void onError(String message, String code, Exception e) {
                 code,
                 e));
     }
+
+    @Override
+    public void onDecryptionFailure(String event, String reason) {
+        System.out.println(String.format(
+                "An error was received decrypting message for event:[%s] - reason: [%s]", event, reason));
+    }
 }