@onekeyfe/react-native-jpush 6.7.0-23 → 6.7.0-24

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

@@ -28,6 +28,7 @@ import cn.jpush.android.api.JPushInterface;
 import cn.jpush.android.api.JThirdPlatFormInterface;
 import cn.jpush.android.api.NotificationMessage;
 import cn.jpush.android.local.ActionHelper;
+import cn.jpush.android.data.JPushLocalNotification;
 import cn.jpush.android.service.JNotifyActivity;
 import cn.jpush.android.service.JPushMessageReceiver;
 import com.google.android.gms.common.GoogleApiAvailabilityLight;
@@ -44,6 +45,9 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -104,6 +108,56 @@ public class FcmAdapterTest {
         notifications.cancelAll();
     }
 
+    @Test
+    public void localSchedulingPostsAndDispatchesOnlyTheUncancelledNotification() throws Exception {
+        ActionHelper helper = ActionHelper.getInstance();
+        helper.clearActiveNotificationIds();
+        CountDownLatch fired = new CountDownLatch(1), cancelled = new CountDownLatch(1);
+        AtomicReference<NotificationMessage> delivered = new AtomicReference<>();
+        JPushMessageReceiver receiver = new JPushMessageReceiver() {
+            @Override public void onNotifyMessageArrived(Context c, NotificationMessage message) {
+                if (message.notificationId == 77001) cancelled.countDown();
+                if (message.notificationId == 77002) { delivered.set(message); fired.countDown(); }
+            }
+        };
+        helper.registerReceiver(receiver);
+        try {
+            JPushLocalNotification removed = new JPushLocalNotification();
+            removed.setNotificationId(77001L);
+            removed.setTitle("Cancelled local");
+            removed.setContent("Must not be delivered");
+            removed.setBroadcastTime(300L);
+            JPushInterface.addLocalNotification(context, removed);
+            JPushInterface.removeLocalNotification(context, 77001L);
+
+            JPushLocalNotification scheduled = new JPushLocalNotification();
+            scheduled.setNotificationId(77002L);
+            scheduled.setTitle("Scheduled local");
+            scheduled.setContent("Synthetic local scheduling verification");
+            scheduled.setBroadcastTime(70L);
+            JPushInterface.addLocalNotification(context, scheduled);
+            assertTrue("Scheduled local notification must arrive", fired.await(1000L, TimeUnit.MILLISECONDS));
+            assertEquals(1, delivered.get().notificationType);
+            assertEquals("77002", delivered.get().msgId);
+            Notification posted = Shadows.shadowOf(notifications).getNotification(77002);
+            assertNotNull(posted);
+            assertEquals("Scheduled local", posted.extras.getString(Notification.EXTRA_TITLE));
+            assertNotNull(posted.contentIntent);
+            NotificationMessage clicked = (NotificationMessage) Shadows.shadowOf(posted.contentIntent).getSavedIntent()
+                .getSerializableExtra("multi_notification_msg");
+            assertEquals(77002, clicked.notificationId);
+            assertEquals(1, clicked.notificationType);
+            assertTrue(helper.getActiveNotificationIds().contains(77002));
+            assertFalse("Cancelled local notification must stay cancelled", cancelled.await(360L, TimeUnit.MILLISECONDS));
+            assertNull(Shadows.shadowOf(notifications).getNotification(77001));
+            assertFalse(helper.getActiveNotificationIds().contains(77001));
+            assertEquals(1, arrived.size());
+        } finally {
+            helper.unregisterReceiver(receiver);
+            helper.clearActiveNotificationIds();
+        }
+    }
+
     @Test
     public void coreDiscoversSourceAdapterOnceAndRebindsTheCurrentToken() {
         FirebaseMessaging provider = mock(FirebaseMessaging.class);
@@ -417,6 +471,164 @@ public class FcmAdapterTest {
         }
     }
 
+    private void installHostLauncher() {
+        ActivityInfo host = new ActivityInfo();
+        host.packageName = context.getPackageName();
+        host.name = context.getPackageName() + ".MainActivity";
+        host.applicationInfo = new ApplicationInfo(context.getApplicationInfo());
+        ResolveInfo resolvedHost = new ResolveInfo();
+        resolvedHost.activityInfo = host;
+        Intent launcher = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER).setPackage(context.getPackageName());
+        Shadows.shadowOf(context.getPackageManager()).addResolveInfoForIntent(launcher, resolvedHost);
+    }
+
+    @Test
+    public void tcpReceiveAndSerializedTapsRespectStopAndAuthorization() {
+        installHostLauncher();
+        ActionHelper helper = ActionHelper.getInstance();
+        for (boolean stopped : new boolean[]{true, false}) {
+            JCoreStorage.setPushStopped(context, false);
+            JCoreStorage.setCollectionAuth(context, true);
+            helper.handleDownlinkPushMessage(context, (byte) 0, 7101, "{\"n_title\":\"TCP\",\"n_content\":\"body\"}");
+            helper.handleDownlinkPushMessage(context, (byte) 2, 7102, "{\"message\":\"custom\"}");
+            assertEquals(1, arrived.size());
+            assertEquals(1, custom.size());
+            Intent tap = Shadows.shadowOf(Shadows.shadowOf(notifications).getAllNotifications().get(0).contentIntent).getSavedIntent();
+            notifications.cancelAll();
+            JCoreStorage.setPushStopped(context, stopped);
+            JCoreStorage.setCollectionAuth(context, stopped);
+            helper.handleDownlinkPushMessage(context, (byte) 0, 7103, "{\"n_title\":\"blocked\",\"n_content\":\"body\"}");
+            helper.handleDownlinkPushMessage(context, (byte) 2, 7104, "{\"message\":\"blocked\"}");
+            Robolectric.buildActivity(JNotifyActivity.class, tap).create();
+            assertTrue(Shadows.shadowOf(notifications).getAllNotifications().isEmpty());
+            assertEquals(1, arrived.size());
+            assertEquals(1, custom.size());
+            assertTrue(opened.isEmpty());
+            assertNull(Shadows.shadowOf(RuntimeEnvironment.getApplication()).getNextStartedActivity());
+            arrived.clear();
+            custom.clear();
+        }
+    }
+
+    @Test
+    public void bothTransportTapsLaunchTheHostOnceAndRejectForeignOrInvalidIntents() {
+        installHostLauncher();
+        ActionHelper helper = ActionHelper.getInstance();
+        for (int platform : new int[]{0, 8}) {
+            NotificationMessage message = new NotificationMessage();
+            message.msgId = "tap_" + platform;
+            message.platform = platform;
+            Intent tap = new Intent(context, JNotifyActivity.class)
+                .setAction(JPushInterface.ACTION_NOTIFICATION_OPENED)
+                .putExtra("multi_notification_msg", message);
+            JNotifyActivity activity = Robolectric.buildActivity(JNotifyActivity.class, tap).create().get();
+            assertTrue(activity.isFinishing());
+            assertEquals(platform == 0 ? 1 : 2, opened.size());
+            Intent launched = Shadows.shadowOf(RuntimeEnvironment.getApplication()).getNextStartedActivity();
+            assertNotNull(launched);
+            assertEquals(context.getPackageName() + ".MainActivity", launched.getComponent().getClassName());
+            assertNull(Shadows.shadowOf(RuntimeEnvironment.getApplication()).getNextStartedActivity());
+            helper.handleNotificationIntent(context, new Intent(tap).setAction("unrelated"));
+            helper.handleNotificationIntent(context, new Intent(tap).setPackage("foreign.package"));
+            helper.handleNotificationIntent(context, new Intent(tap).setComponent(new android.content.ComponentName("foreign.package", "Foreign")));
+            message.msgId = "";
+            helper.handleNotificationIntent(context, tap);
+            assertEquals(platform == 0 ? 1 : 2, opened.size());
+            assertNull(Shadows.shadowOf(RuntimeEnvironment.getApplication()).getNextStartedActivity());
+        }
+    }
+
+    @Test
+    public void notificationConstructionCannotCrossAnAuthorizationGeneration() {
+        NotificationManager manager = mock(NotificationManager.class);
+        android.content.ContextWrapper wrapped = new android.content.ContextWrapper(context) {
+            @Override public Object getSystemService(String name) {
+                return Context.NOTIFICATION_SERVICE.equals(name) ? manager : super.getSystemService(name);
+            }
+        };
+        ReflectionHelpers.setStaticField(JCoreStorage.class, "sAppContext", wrapped);
+        doAnswer(call -> {
+            JCoreStorage.setCollectionAuth(wrapped, false);
+            JCoreStorage.setCollectionAuth(wrapped, true);
+            return null;
+        }).when(manager).createNotificationChannel(any(android.app.NotificationChannel.class));
+        ActionHelper helper = ActionHelper.getInstance();
+        helper.handleDownlinkPushMessage(wrapped, (byte) 0, 7105, "{\"n_title\":\"TCP\",\"n_content\":\"body\"}");
+        Bundle payload = new Bundle();
+        payload.putString("data", "{\"msg_id\":\"fcm_generation\",\"n_title\":\"FCM\",\"n_content\":\"body\"}");
+        helper.doAction(wrapped, JThirdPlatFormInterface.ACTION_PLUGIN_PALTFORM_ON_MESSAGING, payload);
+        verify(manager, times(2)).createNotificationChannel(any(android.app.NotificationChannel.class));
+        verify(manager, never()).notify(anyInt(), any(Notification.class));
+        assertTrue(arrived.isEmpty());
+    }
+
+    @Test
+    public void revokedConstructionCannotMutateAnExistingClickIntentOrNotificationTracking() {
+        ActionHelper helper = ActionHelper.getInstance();
+        helper.clearActiveNotificationIds();
+        JCoreStorage.setLatestNotificationNumber(context, 2);
+        for (int id : new int[]{7105, 7106}) {
+            NotificationMessage previous = new NotificationMessage();
+            previous.msgId = "existing_" + id;
+            previous.notificationId = id;
+            previous.notificationTitle = "Existing notification";
+            helper.postSystemNotification(context, previous);
+        }
+        assertEquals(java.util.Arrays.asList(7105, 7106), helper.getActiveNotificationIds());
+        Notification previous = Shadows.shadowOf(notifications).getNotification(7105);
+        android.app.PendingIntent previousClick = previous.contentIntent;
+        NotificationManager manager = spy(notifications);
+        android.content.ContextWrapper wrapped = new android.content.ContextWrapper(context) {
+            @Override public Object getSystemService(String name) {
+                return Context.NOTIFICATION_SERVICE.equals(name) ? manager : super.getSystemService(name);
+            }
+        };
+        ReflectionHelpers.setStaticField(JCoreStorage.class, "sAppContext", wrapped);
+        doAnswer(call -> {
+            JCoreStorage.setCollectionAuth(wrapped, false);
+            return null;
+        }).when(manager).createNotificationChannel(any(android.app.NotificationChannel.class));
+        for (int id : new int[]{7105, 7107}) {
+            JCoreStorage.setCollectionAuth(wrapped, true);
+            NotificationMessage rejected = new NotificationMessage();
+            rejected.msgId = "rejected_" + id;
+            rejected.notificationId = id;
+            rejected.notificationTitle = "Rejected replacement";
+            helper.postSystemNotification(wrapped, rejected);
+            assertEquals(java.util.Arrays.asList(7105, 7106), helper.getActiveNotificationIds());
+            assertEquals(2, Shadows.shadowOf(notifications).getAllNotifications().size());
+            NotificationMessage saved = (NotificationMessage) Shadows.shadowOf(previousClick).getSavedIntent()
+                .getSerializableExtra("multi_notification_msg");
+            assertEquals("existing_7105", saved.msgId);
+            assertEquals("Existing notification", Shadows.shadowOf(notifications).getNotification(7105)
+                .extras.getString(Notification.EXTRA_TITLE));
+        }
+        verify(manager, never()).notify(anyInt(), any(Notification.class));
+        verify(manager, never()).cancel(anyInt());
+    }
+
+    @Test
+    public void openedCallbackRevocationAndRegrantCannotContinueTheOldTapLaunch() {
+        installHostLauncher();
+        ActionHelper helper = ActionHelper.getInstance();
+        JPushMessageReceiver revoke = new JPushMessageReceiver() {
+            @Override public void onNotifyMessageOpened(Context c, NotificationMessage message) {
+                JCoreStorage.setCollectionAuth(c, false);
+                JCoreStorage.setCollectionAuth(c, true);
+            }
+        };
+        helper.registerReceiver(revoke);
+        NotificationMessage message = new NotificationMessage();
+        message.msgId = "tap_generation";
+        Intent tap = new Intent(context, JNotifyActivity.class)
+            .setAction(JPushInterface.ACTION_NOTIFICATION_OPENED)
+            .putExtra("multi_notification_msg", message);
+        Robolectric.buildActivity(JNotifyActivity.class, tap).create();
+        assertEquals(1, opened.size());
+        assertNull(Shadows.shadowOf(RuntimeEnvironment.getApplication()).getNextStartedActivity());
+        helper.unregisterReceiver(revoke);
+    }
+
     @Test
     public void compressedMetadataRetainsItsOwnTitleAndExtras() {
         Bundle payload = metadata(compress("{\"msg_id\":\"zipped\",\"override_msg_id\":\"\",\"n_title\":\"metadata_title\",\"n_content\":\"metadata_body\",\"n_extras\":{\"route\":\"private_route\"}}"));

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,6 +1,46 @@
 #include <jni.h>
+#include <fbjni/fbjni.h>
 #include "reactnativejpushOnLoad.hpp"
+#include "JHybridReactNativeJpushSpec.hpp"
+
+namespace margelo::nitro::reactnativejpush {
+class OwnedReactNativeJpush final : public JHybridReactNativeJpushSpec {
+ public:
+  explicit OwnedReactNativeJpush(const jni::local_ref<JavaPart>& javaPart)
+      : HybridObject(HybridReactNativeJpushSpec::TAG), JHybridObject(javaPart), JHybridReactNativeJpushSpec(javaPart) {}
+  ~OwnedReactNativeJpush() override {
+    try {
+      jni::ThreadScope::WithClassLoader([&] {
+        const auto& javaPart = getJavaPart();
+        const auto release = javaPart->getClass()->getMethod<void()>("releaseOwnedListeners");
+        release(javaPart);
+      });
+    } catch (...) {
+      // Runtime teardown cannot propagate Java cleanup failures.
+    }
+  }
+};
+class OwnedCxxPart final : public jni::HybridClass<OwnedCxxPart, JHybridReactNativeJpushSpec::CxxPart> {
+ public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativejpush/ReactNativeJpush$OwnedCxxPart;";
+  using HybridBase::HybridBase;
+  static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> self) {
+    return makeCxxInstance(self);
+  }
+  static void registerNatives() {
+    registerHybrid({makeNativeMethod("initHybrid", OwnedCxxPart::initHybrid)});
+  }
+ protected:
+  std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override {
+    auto typed = jni::dynamic_ref_cast<JHybridReactNativeJpushSpec::JavaPart>(javaPart);
+    return std::make_shared<OwnedReactNativeJpush>(typed);
+  }
+};
+}
 
 extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  return margelo::nitro::reactnativejpush::initialize(vm);
+  return facebook::jni::initialize(vm, [] {
+    margelo::nitro::reactnativejpush::registerAllNatives();
+    margelo::nitro::reactnativejpush::OwnedCxxPart::registerNatives();
+  });
 }

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

@@ -478,22 +478,19 @@ public final class JCoreCrypto {
     }
 
     public static byte[] gzipDecompress(byte[] compressed) {
-        if (compressed == null || compressed.length == 0) {
-            return new byte[0];
-        }
-        try {
-            ByteArrayInputStream in = new ByteArrayInputStream(compressed);
-            GZIPInputStream gzip = new GZIPInputStream(in);
+        final int limit = 65536;
+        if (compressed == null || compressed.length == 0) return new byte[0];
+        try (GZIPInputStream gzip = new GZIPInputStream(new ByteArrayInputStream(compressed))) {
             ByteArrayOutputStream out = new ByteArrayOutputStream();
             byte[] buffer = new byte[4096];
             int read;
             while ((read = gzip.read(buffer)) != -1) {
+                if (read > limit - out.size()) return new byte[0];
                 out.write(buffer, 0, read);
             }
-            gzip.close();
             return out.toByteArray();
-        } catch (Throwable ignored) {
-            return compressed;
+        } catch (Exception invalidGzip) {
+            return compressed.length <= limit ? compressed : new byte[0];
         }
     }
 

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

@@ -19,9 +19,11 @@ import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 import org.json.JSONObject;
 
 public final class JCoreStorage {
+    private static final AtomicLong CONTENT_GENERATION = new AtomicLong();
     private static final String PREFS_NAME = "cn.jiguang.sdk.clean.prefs";
     private static final String KEY_APP_KEY = "app_key";
     private static final String KEY_CHANNEL = "channel";
@@ -230,8 +232,15 @@ public final class JCoreStorage {
         return getBooleanPref(null, KEY_DEBUG_MODE, sDebugMode);
     }
 
-    public static void setCollectionAuth(Context context, boolean auth) {
+    public static synchronized void setCollectionAuth(Context context, boolean auth) {
         putBooleanPref(context, KEY_COLLECTION_AUTH, auth);
+        if (!auth) {
+            CONTENT_GENERATION.incrementAndGet();
+        }
+    }
+
+    public static long getContentGeneration() {
+        return CONTENT_GENERATION.get();
     }
 
     public static boolean isCollectionAuth(Context context) {
@@ -426,8 +435,11 @@ public final class JCoreStorage {
         return getBooleanPref(context, KEY_PUSH_STOPPED, false);
     }
 
-    public static void setPushStopped(Context context, boolean stopped) {
+    public static synchronized void setPushStopped(Context context, boolean stopped) {
         putBooleanPref(context, KEY_PUSH_STOPPED, stopped);
+        if (stopped) {
+            CONTENT_GENERATION.incrementAndGet();
+        }
     }
 
     public static boolean isConnected(Context context) {