@onekeyfe/react-native-jpush 6.7.0-alpha.435 → 6.7.0-alpha.444

package/android/fcm/src/test/java/com/onekey/jpush/fcm/FcmManifestTest.java

@@ -0,0 +1,54 @@
+package com.onekey.jpush.fcm;
+
+import static org.junit.Assert.*;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ProviderInfo;
+import android.content.pm.ServiceInfo;
+import android.content.Intent;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class FcmManifestTest {
+    @Test
+    public void mergedManifestRoutesOnlyToGuardedServiceAndDisablesDelegation() throws Exception {
+        Context context = RuntimeEnvironment.getApplication();
+        PackageManager packages = context.getPackageManager();
+        PackageInfo info = packages.getPackageInfo(context.getPackageName(),
+            PackageManager.GET_META_DATA | PackageManager.GET_PROVIDERS | PackageManager.GET_SERVICES);
+        assertTrue(info.applicationInfo.metaData.containsKey("firebase_messaging_notification_delegation_enabled"));
+        assertFalse(info.applicationInfo.metaData.getBoolean("firebase_messaging_notification_delegation_enabled"));
+        assertTrue(info.applicationInfo.metaData.containsKey("firebase_messaging_auto_init_enabled"));
+        assertFalse(info.applicationInfo.metaData.getBoolean("firebase_messaging_auto_init_enabled"));
+        boolean initializerFound = false;
+        for (ProviderInfo provider : info.providers) {
+            if (FcmInitProvider.class.getName().equals(provider.name)) {
+                initializerFound = true;
+                assertFalse(provider.exported);
+            }
+        }
+        assertTrue("The startup delegate cleanup must be installed", initializerFound);
+        boolean guardedServiceFound = false;
+        for (ServiceInfo service : info.services) {
+            assertNotEquals("Unguarded Firebase fallback must not be installed",
+                "com.google.firebase.messaging.FirebaseMessagingService", service.name);
+            if (FcmMessagingService.class.getName().equals(service.name)) {
+                guardedServiceFound = true;
+                assertFalse(service.exported);
+                assertFalse(service.directBootAware);
+            }
+        }
+        assertTrue("The guarded receive service must be installed", guardedServiceFound);
+        android.content.pm.ResolveInfo handler = packages.resolveService(
+            new Intent("com.google.firebase.MESSAGING_EVENT").setPackage(context.getPackageName()), 0);
+        assertNotNull(handler);
+        assertEquals(FcmMessagingService.class.getName(), handler.serviceInfo.name);
+    }
+}

package/android/src/main/java/cn/jiguang/api/utils/JCollectionAuth.java

@@ -2,10 +2,15 @@ package cn.jiguang.api.utils;
 
 import android.content.Context;
 import cn.jiguang.core.JCoreStorage;
+import cn.jpush.android.api.JThirdPlatFormInterface;
 
 public class JCollectionAuth {
-    public static void setAuth(Context context, boolean auth) {
+    public static synchronized void setAuth(Context context, boolean auth) {
+        boolean wasAuthorized = JCoreStorage.isCollectionAuth(context);
         JCoreStorage.setCollectionAuth(context, auth);
+        if (auth && !wasAuthorized) {
+            JThirdPlatFormInterface.initializeFcm(context);
+        }
     }
 
     public static boolean isAuth(Context context) {

package/android/src/main/java/cn/jiguang/core/JCoreTcpEngine.java

@@ -1323,6 +1323,7 @@ public final class JCoreTcpEngine {
         String regId = JCoreStorage.getRegistrationId(context);
         ActionHelper.getInstance().dispatchRegisterEvent(context, regId);
         ActionHelper.getInstance().dispatchConnectedEvent(context, true);
+        cn.jpush.android.api.JThirdPlatFormInterface.initializeFcm(context);
     }
 
     public Bundle handleEvent(Context context, String sdkType, int cmd, String action, Bundle bundle, Object... extras) {

package/android/src/main/java/cn/jpush/android/api/JPushInterface.java

@@ -81,6 +81,7 @@ public class JPushInterface {
         JPushConstants.init(app);
         ActionHelper.getInstance().init(app);
         JCoreManager.init(app);
+        JThirdPlatFormInterface.initializeFcm(app);
     }
 
     public static void init(Context context, JPushConfig config) {
@@ -104,6 +105,7 @@ public class JPushInterface {
     public static void resumePush(Context context) {
         JCoreStorage.setPushStopped(context, false);
         JCoreManager.init(context);
+        JThirdPlatFormInterface.initializeFcm(context);
         ActionHelper.getInstance().setPushStatusWithCallBack(context, 4, 1);
     }
 

package/android/src/main/java/cn/jpush/android/api/JThirdPlatFormInterface.java

@@ -4,11 +4,21 @@ import android.app.Notification;
 import android.content.Context;
 import android.os.Bundle;
 import cn.jiguang.core.JCoreCrypto;
+import cn.jiguang.core.JCoreStorage;
+import cn.jiguang.core.JCoreTcpEngine;
+import cn.jiguang.plugins.push.common.JLogger;
 import cn.jpush.android.helper.JCoreHelper;
 import cn.jpush.android.local.ActionHelper;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.zip.GZIPInputStream;
 import org.json.JSONObject;
 
 public abstract class JThirdPlatFormInterface {
+    private static JThirdPlatFormInterface fcmPlugin;
+    private static boolean fcmRegistered;
+    private static final int MAX_MESSAGE_BYTES = 65536;
     public static final String ACTION_NOTIFICATION_SHOW = "action_notification_show";
     public static final String ACTION_NOTIFICATION_ARRIVED = "action_notification_arrived";
     public static final String ACTION_NOTIFICATION_UN_SHOW = "action_notification_unshow";
@@ -69,6 +79,44 @@ public abstract class JThirdPlatFormInterface {
         return false;
     }
 
+    public static void initializeFcm(final Context context) {
+        if (context == null || JCoreStorage.isPushStopped(context) || !JCoreStorage.isCollectionAuth(context)) {
+            return;
+        }
+        JCoreTcpEngine.getInstance().executeAsync(new Runnable() {
+            @Override
+            public void run() {
+                synchronized (JThirdPlatFormInterface.class) {
+                    if (JCoreStorage.isPushStopped(context) || !JCoreStorage.isCollectionAuth(context)) {
+                        return;
+                    }
+                    try {
+                        if (fcmPlugin == null) {
+                            // This optional source module is linked only by Google hosts.
+                            fcmPlugin = (JThirdPlatFormInterface) Class.forName(
+                                "com.onekey.jpush.fcm.FcmPushManager"
+                            ).getDeclaredConstructor().newInstance();
+                        }
+                        if (!fcmPlugin.isSupport(context)) {
+                            return;
+                        }
+                        if (!fcmRegistered) {
+                            fcmPlugin.init(context);
+                            fcmPlugin.register(context, new Bundle());
+                            fcmRegistered = true;
+                        }
+                        fcmPlugin.getToken(context);
+                        JLogger.i("FCM registration requested");
+                    } catch (ClassNotFoundException absentPlugin) {
+                        // Non-Google hosts intentionally do not include the optional plugin.
+                    } catch (Exception | LinkageError unavailablePlugin) {
+                        JLogger.w("FCM registration unavailable");
+                    }
+                }
+            }
+        });
+    }
+
     public static void onEvent(Thread thread, Throwable error) {
         ActionHelper.getInstance().onEvent(thread, error);
     }
@@ -84,6 +132,10 @@ public abstract class JThirdPlatFormInterface {
     }
 
     public static void sendActionByJCore(Context context, Bundle bundle, String action) {
+        if (ACTION_PLUGIN_PALTFORM_ON_MESSAGING.equals(action)) {
+            ActionHelper.getInstance().doAction(context, action, bundle);
+            return;
+        }
         JCoreHelper.runActionWithService(context, "JPUSH", action, bundle);
     }
 
@@ -132,16 +184,64 @@ public abstract class JThirdPlatFormInterface {
     public static NotificationMessage parseMessage(Context context, String rawJson) {
         NotificationMessage message = new NotificationMessage();
         message.context = context;
-        if (rawJson != null) {
+        message.platform = 8;
+        message.displayForeground = "0";
+        String decoded = decodeMessageJson(rawJson);
+        if (decoded != null) {
             try {
-                JSONObject json = new JSONObject(rawJson);
-                message.msgId = json.optString("msg_id", "");
-                message.notificationTitle = json.optString("n_title", "");
-                message.notificationContent = json.optString("n_content", "");
-                message.notificationExtras = json.optString("n_extras", "");
-            } catch (Throwable ignored) {
+                JSONObject json = new JSONObject(decoded);
+                message.msgId = json.optString("_jmsgid_", json.optString("_j_msgid", ""));
+                if (message.msgId.isEmpty()) {
+                    message.msgId = json.optString("msg_id", "");
+                }
+                String overrideId = json.optString("override_msg_id", "");
+                if (!overrideId.isEmpty()) {
+                    message.msgId = overrideId;
+                }
+                message.notificationId = getNofiticationID(message.msgId, 0);
+                message.notificationTitle = json.optString("n_title", json.optString("title", ""));
+                message.notificationContent = json.optString("n_content", json.optString("alert", json.optString("content", "")));
+                Object extras = json.opt("n_extras");
+                if (extras == null) {
+                    extras = json.opt("extras");
+                }
+                message.notificationExtras = extras != null ? extras.toString() : "";
+                message.notificationChannelId = json.optString("n_channel_id", "");
+                if (!JCoreStorage.isPushStopped(context) && JCoreStorage.isCollectionAuth(context)) {
+                    message.displayForeground = json.optString("n_foreground", "1");
+                }
+            } catch (Exception invalidMessage) {
+                JLogger.w("FCM payload rejected");
             }
         }
         return message;
     }
+
+    public static String decodeMessageJson(String rawJson) {
+        if (rawJson == null || rawJson.length() > MAX_MESSAGE_BYTES
+            || rawJson.getBytes(StandardCharsets.UTF_8).length > MAX_MESSAGE_BYTES) {
+            return null;
+        }
+        try {
+            JSONObject json = new JSONObject(rawJson);
+            if (!json.has("jg_c")) {
+                return rawJson;
+            }
+            byte[] compressed = JCoreCrypto.base64Decode(json.getString("jg_c"));
+            try (GZIPInputStream input = new GZIPInputStream(new ByteArrayInputStream(compressed));
+                 ByteArrayOutputStream output = new ByteArrayOutputStream()) {
+                byte[] buffer = new byte[2048];
+                int count;
+                while ((count = input.read(buffer)) != -1) {
+                    if (output.size() + count > MAX_MESSAGE_BYTES) {
+                        return null;
+                    }
+                    output.write(buffer, 0, count);
+                }
+                return new String(output.toByteArray(), StandardCharsets.UTF_8);
+            }
+        } catch (Exception invalidMessage) {
+            return null;
+        }
+    }
 }

package/android/src/main/java/cn/jpush/android/local/ActionHelper.java

@@ -1,6 +1,8 @@
 package cn.jpush.android.local;
 
 import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.KeyguardManager;
 import android.app.Notification;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
@@ -16,6 +18,7 @@ import cn.jiguang.core.JCoreWireCodec;
 import cn.jpush.android.api.CmdMessage;
 import cn.jpush.android.api.CustomMessage;
 import cn.jpush.android.api.JPushInterface;
+import cn.jpush.android.api.JThirdPlatFormInterface;
 import cn.jpush.android.api.JPushMessage;
 import cn.jpush.android.api.NotificationCustomButton;
 import cn.jpush.android.api.NotificationMessage;
@@ -111,6 +114,74 @@ public class ActionHelper {
     }
 
     public void doAction(Context context, String action, Object data) {
+        if (!(data instanceof Bundle) || JCoreStorage.isPushStopped(context) || !JCoreStorage.isCollectionAuth(context)) {
+            return;
+        }
+        Bundle bundle = (Bundle) data;
+        if ("third_action".equals(action)) {
+            action = bundle.getString("third_key_action", "");
+        }
+        if (JThirdPlatFormInterface.ACTION_REGISTER_TOKEN.equals(action)) {
+            String token = bundle.getString("token", "");
+            byte platform = bundle.getByte("platform", (byte) 8);
+            if (platform == 8 && !token.isEmpty()) {
+                setThirdTokenWithCallBack(context, token, platform, false);
+            }
+            return;
+        }
+        if (JThirdPlatFormInterface.ACTION_SEND_EXCEPTION.equals(action)) {
+            cn.jiguang.plugins.push.common.JLogger.w("FCM plugin reported an error");
+            return;
+        }
+        String raw = bundle.getString("data", bundle.getString("JMessageExtra", ""));
+        String decoded = JThirdPlatFormInterface.decodeMessageJson(raw);
+        if (decoded == null) {
+            return;
+        }
+        NotificationMessage message = JThirdPlatFormInterface.parseMessage(context, decoded);
+        if (message.msgId == null || message.msgId.isEmpty()) {
+            return;
+        }
+        message.notificationId = bundle.getInt("noti_id", message.notificationId);
+        if (JThirdPlatFormInterface.ACTION_PLUGIN_PALTFORM_ON_MESSAGING.equals(action)) {
+            try {
+                JSONObject json = new JSONObject(decoded);
+                if (json.has("message") && message.notificationContent.isEmpty()) {
+                    CustomMessage custom = new CustomMessage();
+                    custom.messageId = message.msgId;
+                    custom.message = json.optString("message", "");
+                    custom.title = message.notificationTitle;
+                    custom.extra = message.notificationExtras;
+                    custom.contentType = json.optString("content_type", "");
+                    custom.platform = 8;
+                    dispatchCustomMessageEvent(context, custom);
+                } else {
+                    if ("0".equals(message.displayForeground) && isApplicationForeground(context)) {
+                        return;
+                    }
+                    postSystemNotification(context, message);
+                    dispatchNotificationEvent(context, "notify_arrived", message);
+                }
+            } catch (Exception invalidMessage) {
+                cn.jiguang.plugins.push.common.JLogger.w("FCM payload rejected");
+            }
+        } else if (JThirdPlatFormInterface.ACTION_NOTIFICATION_ARRIVED.equals(action)) {
+            recordNotificationPosted(context, message.notificationId);
+            dispatchNotificationEvent(context, "notify_arrived", message);
+        } else if (JThirdPlatFormInterface.ACTION_NOTIFICATION_CLCKED.equals(action)) {
+            dispatchNotificationEvent(context, "notify_opened", message);
+            broadcastNotificationOpened(context, message);
+        }
+    }
+
+    private boolean isApplicationForeground(Context context) {
+        KeyguardManager keyguard = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
+        if (keyguard != null && keyguard.isKeyguardLocked()) {
+            return false;
+        }
+        ActivityManager.RunningAppProcessInfo process = new ActivityManager.RunningAppProcessInfo();
+        ActivityManager.getMyMemoryState(process);
+        return process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND;
     }
 
     public void doSingleAction(Context context, String action, Object data) {
@@ -148,10 +219,33 @@ public class ActionHelper {
                 return;
             }
             Serializable msg = intent.getSerializableExtra("multi_notification_msg");
+            boolean fcmClick = !(msg instanceof NotificationMessage) && intent.hasExtra("JMessageExtra");
+            if (fcmClick) {
+                if (JCoreStorage.isPushStopped(context) || !JCoreStorage.isCollectionAuth(context)) {
+                    return;
+                }
+                NotificationMessage message = JThirdPlatFormInterface.parseMessage(context, intent.getStringExtra("JMessageExtra"));
+                if (message.msgId == null || message.msgId.isEmpty()) {
+                    return;
+                }
+                msg = message;
+            }
             if (msg instanceof NotificationMessage) {
                 NotificationMessage notificationMessage = (NotificationMessage) msg;
+                if (notificationMessage.platform == 8
+                    && (JCoreStorage.isPushStopped(context) || !JCoreStorage.isCollectionAuth(context))) {
+                    return;
+                }
                 dispatchNotificationEvent(context, "notify_opened", notificationMessage);
                 broadcastNotificationOpened(context, notificationMessage);
+                if (fcmClick || notificationMessage.platform == 8) {
+                    android.content.pm.PackageManager manager = context.getPackageManager();
+                    Intent launcher = manager != null ? manager.getLaunchIntentForPackage(appPkg) : null;
+                    if (launcher != null) {
+                        launcher.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+                        context.startActivity(launcher);
+                    }
+                }
             }
         } catch (Throwable ignored) {
         }
@@ -897,6 +991,7 @@ public class ActionHelper {
                     if (statusCode == 0) {
                         JCoreStorage.saveThirdToken(context, platform, unbind ? "" : token);
                     }
+                    cn.jiguang.plugins.push.common.JLogger.i("Third token result platform=" + platform + " code=" + statusCode);
                     Intent intent = buildBaseReceiverIntent(context, "cmd_result", 0, statusCode);
                     intent.putExtra("cmd", 10000);
                     intent.putExtra("msg", unbind ? "unbind" : "bind");

package/android/src/main/java/cn/jpush/android/service/JPushMessageReceiver.java

@@ -10,6 +10,7 @@ import cn.jpush.android.api.JPushMessage;
 import cn.jpush.android.api.NotificationCustomButton;
 import cn.jpush.android.api.NotificationMessage;
 import cn.jpush.android.local.ActionHelper;
+import cn.jiguang.core.JCoreStorage;
 
 public abstract class JPushMessageReceiver extends BroadcastReceiver {
     @Override
@@ -74,7 +75,7 @@ public abstract class JPushMessageReceiver extends BroadcastReceiver {
     }
 
     public boolean isNeedShowNotification(Context context, NotificationMessage notificationMessage, String processName) {
-        return true;
+        return !JCoreStorage.isPushStopped(context) && JCoreStorage.isCollectionAuth(context);
     }
 
     public void onInAppMessageShow(Context context, NotificationMessage notificationMessage) {

package/android/src/test/java/com/margelo/nitro/reactnativejpush/JPushCloudHandshakeTest.java

@@ -0,0 +1,110 @@
+package com.margelo.nitro.reactnativejpush;
+
+import static org.junit.Assert.*;
+import cn.jiguang.core.JCoreCrypto;
+import cn.jiguang.core.JCoreWireCodec;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Set;
+import org.junit.Assume;
+import org.junit.Test;
+
+public class JPushCloudHandshakeTest {
+    @Test
+    public void liveCloudHandshake() throws Exception {
+        boolean enabled = "1".equals(System.getenv("JPUSH_LIVE_TESTS"));
+        if (!enabled) {
+            System.out.println("SKIPPED live Jiguang handshake: set JPUSH_LIVE_TESTS=1 to enable");
+        }
+        Assume.assumeTrue("External cloud handshake requires JPUSH_LIVE_TESTS=1", enabled);
+        String sisJson;
+        try (DatagramSocket udp = new DatagramSocket()) {
+            String request = JCoreWireCodec.buildSisRequestJson(
+                1, ReactNativeJpushProtocolTest.DEMO_TEST_APP_KEY, 0L, "",
+                Collections.<String>emptyList(), 1
+            );
+            byte[] packet = JCoreWireCodec.encodeUdpSisPacket(request, JCoreCrypto.nextPositiveSeed24());
+            udp.setSoTimeout(2500);
+            udp.send(new DatagramPacket(packet, packet.length, InetAddress.getByName("s.jpush.cn"), 19000));
+            DatagramPacket response = new DatagramPacket(new byte[4096], 4096);
+            udp.receive(response);
+            sisJson = JCoreWireCodec.decodeUdpSisPacket(Arrays.copyOf(response.getData(), response.getLength()));
+        }
+        assertTrue("SIS response must contain endpoints", sisJson.contains("\"ips\""));
+        Set<String> endpoints = JCoreWireCodec.extractJsonStringArray(sisJson, "ips");
+        assertFalse("SIS endpoints must not be empty", endpoints.isEmpty());
+        String endpoint = endpoints.iterator().next();
+        int colon = endpoint.lastIndexOf(':');
+        try (Socket tcp = new Socket()) {
+            tcp.connect(new InetSocketAddress(endpoint.substring(0, colon), Integer.parseInt(endpoint.substring(colon + 1))), 3000);
+            tcp.setSoTimeout(5000);
+            performHandshake(tcp.getInputStream(), tcp.getOutputStream());
+        }
+        System.out.println("Live Jiguang register/login handshake passed");
+    }
+
+    // Shared by the opt-in cloud test and deterministic failure-propagation regressions.
+    static void performHandshake(InputStream in, OutputStream out) throws Exception {
+        int seed = JCoreCrypto.nextRegisterSeed();
+        JCoreWireCodec.setLastRegisterSeed(seed);
+        byte[] regBody = JCoreWireCodec.buildRegisterPayload(
+            ReactNativeJpushProtocolTest.DEMO_TEST_APP_KEY,
+            "developer-default",
+            ReactNativeJpushProtocolTest.DEMO_TEST_PACKAGE_NAME,
+            "msgbench_auto_001"
+        );
+        byte[] regFrame = JCoreWireCodec.encodeFrame(
+            JCoreWireCodec.CMD_REGISTER,
+            JCoreWireCodec.VER_REGISTER,
+            101L,
+            seed,
+            0L,
+            regBody
+        );
+        out.write(regFrame);
+        out.flush();
+
+        JCoreWireCodec.DecodedFrame regRespFrame = JCoreWireCodec.readFrameFromStream(in, 0L);
+        assertNotNull("Missing register response", regRespFrame);
+        assertEquals("Register command", JCoreWireCodec.CMD_REGISTER, regRespFrame.command);
+        assertEquals("Register status", 0, regRespFrame.statusCode);
+        JCoreWireCodec.RegisterResponse regResp = JCoreWireCodec.parseRegisterResponse(regRespFrame);
+        assertNotNull(regResp);
+        assertEquals(0L, (long) regResp.statusCode);
+        assertTrue(regResp.uid > 0L);
+        assertTrue(regResp.registrationId != null && !regResp.registrationId.isEmpty());
+
+        byte[] loginBody = JCoreWireCodec.buildLoginPayload(
+            regResp.password,
+            ReactNativeJpushProtocolTest.DEMO_TEST_APP_KEY,
+            regResp.deviceId,
+            "CN"
+        );
+        byte[] loginFrame = JCoreWireCodec.encodeFrame(
+            JCoreWireCodec.CMD_LOGIN,
+            JCoreWireCodec.VER_LOGIN,
+            102L,
+            0,
+            regResp.uid,
+            loginBody
+        );
+        out.write(loginFrame);
+        out.flush();
+
+        JCoreWireCodec.DecodedFrame loginRespFrame = JCoreWireCodec.readFrameFromStream(in, regResp.uid);
+        assertNotNull("Missing login response", loginRespFrame);
+        assertEquals("Login command", JCoreWireCodec.CMD_LOGIN, loginRespFrame.command);
+        assertEquals("Login status", 0, loginRespFrame.statusCode);
+        JCoreWireCodec.LoginResponse loginResp = JCoreWireCodec.parseLoginResponse(loginRespFrame);
+        assertNotNull(loginResp);
+        assertEquals(0L, (long) loginResp.statusCode);
+        assertTrue(loginResp.sessionId != 0);
+    }
+}

package/android/src/test/java/com/margelo/nitro/reactnativejpush/JPushHandshakeFailureTest.java

@@ -0,0 +1,73 @@
+package com.margelo.nitro.reactnativejpush;
+
+import static org.junit.Assert.*;
+import cn.jiguang.core.JCoreWireCodec;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.function.Supplier;
+import org.junit.Test;
+
+public class JPushHandshakeFailureTest {
+    @Test
+    public void networkFailureIsNotConvertedToSuccess() {
+        InputStream broken = new InputStream() {
+            @Override public int read() throws IOException {
+                throw new IOException("Synthetic connection loss");
+            }
+        };
+        assertThrows(IOException.class, () -> JPushCloudHandshakeTest.performHandshake(broken, new ByteArrayOutputStream()));
+    }
+
+    @Test
+    public void missingResponseAssertionIsNotSwallowed() {
+        assertThrows(AssertionError.class, () -> JPushCloudHandshakeTest.performHandshake(
+            new ByteArrayInputStream(new byte[0]), new ByteArrayOutputStream()
+        ));
+    }
+
+    @Test
+    public void rejectedRegistrationFailsTheHandshake() {
+        AssertionError failure = assertThrows(AssertionError.class, () -> JPushCloudHandshakeTest.performHandshake(
+            lazyReply(() -> JCoreWireCodec.encodeResponseFrame(
+                JCoreWireCodec.CMD_REGISTER, JCoreWireCodec.VER_REGISTER, 101L,
+                (int) JCoreWireCodec.getLastRegisterSeed(), 42L, 1009, new byte[0]
+            )), new ByteArrayOutputStream()
+        ));
+        assertTrue(failure.getMessage().contains("Register status"));
+    }
+
+    @Test
+    public void rejectedLoginFailsTheHandshake() {
+        AssertionError failure = assertThrows(AssertionError.class, () -> JPushCloudHandshakeTest.performHandshake(
+            lazyReply(() -> {
+                byte[] registration = JCoreWireCodec.encodeResponseFrame(
+                    JCoreWireCodec.CMD_REGISTER, JCoreWireCodec.VER_REGISTER, 101L,
+                    (int) JCoreWireCodec.getLastRegisterSeed(), 42L, 0,
+                    JCoreWireCodec.buildRegisterResponsePayload(42L, "synthetic_password", "synthetic_registration", "synthetic_device")
+                );
+                byte[] login = JCoreWireCodec.encodeResponseFrame(
+                    JCoreWireCodec.CMD_LOGIN, JCoreWireCodec.VER_LOGIN, 102L, 0, 42L, 1005, new byte[0]
+                );
+                byte[] replies = new byte[registration.length + login.length];
+                System.arraycopy(registration, 0, replies, 0, registration.length);
+                System.arraycopy(login, 0, replies, registration.length, login.length);
+                return replies;
+            }), new ByteArrayOutputStream()
+        ));
+        assertTrue(failure.getMessage().contains("Login status"));
+    }
+
+    private static InputStream lazyReply(Supplier<byte[]> response) {
+        return new InputStream() {
+            private ByteArrayInputStream input;
+            private ByteArrayInputStream input() {
+                if (input == null) input = new ByteArrayInputStream(response.get());
+                return input;
+            }
+            @Override public int read() { return input().read(); }
+            @Override public int read(byte[] bytes, int offset, int length) { return input().read(bytes, offset, length); }
+        };
+    }
+}