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

package/README.md

@@ -19,6 +19,39 @@ yarn workspace @onekeyfe/react-native-jpush typecheck
 yarn workspace @onekeyfe/react-native-jpush lint
 yarn workspace @onekeyfe/react-native-jpush test
 
-# Native iOS & Android E2E protocol verification (uses non-production demo key 1f2027d3cfb1b51dac664c42)
+# Resolve JUnit dependencies and run the core/FCM module suites
+(cd example/react-native/android && ./gradlew :onekeyfe_react-native-jpush:testDebugUnitTest :onekey-jpush-fcm:testDebugUnitTest)
+
+# macOS: native host build/protocol regressions (loopback servers and isolated RN/Android shims)
 python3 native-modules/react-native-jpush/scripts/verify_clean_sdk.py
 ```
+
+Java and Objective-C host fixtures live in `tests/android` and `tests/ios`; Python only builds, runs and checks artifacts. Android host tests use real JUnit 4.13.2 from the Gradle dependency cache. The FCM Gradle suite uses Robolectric and real Firebase message/task types, with mocked external token requests. These checks do not establish physical-device or cloud delivery.
+
+The external Jiguang sandbox register/login test is explicitly skipped by default. Set `JPUSH_LIVE_TESTS=1` when running either Android test entry to enable it; then all network/protocol/assertion failures fail the test. CI runs both host suites plus Gradle FCM tests. A manual `native-tests` workflow can enable the same cloud check with `jpush_live_cloud`.
+
+## Android Google / FCM source transport
+
+The optional Android source library in `android/fcm` replaces the opaque Jiguang FCM plugin. It delegates the Google transport to the official Firebase Messaging SDK and forwards tokens and messages into this package's JCore/JPush pipeline. Link it alongside the project's autolinked JPush module (the alias below matches app-monorepo):
+
+```groovy
+// settings.gradle, after React Native autolinking
+include ':onekey-jpush-fcm'
+project(':onekey-jpush-fcm').projectDir = new File(project(':jpush-react-native').projectDir, 'fcm')
+
+// app/build.gradle: replace cn.jiguang.sdk.plugin:fcm
+// Keep this dependency scoped to the Google distribution.
+googleImplementation project(':onekey-jpush-fcm')
+```
+
+The host retains its existing `google-services.json` and Google Services Gradle plugin. Firebase auto-init stays disabled; JPush initialization requests the token after authorization. Granting authorization after a previously unauthorized init also requests registration without reconnecting. Cloud acceptance requires the matching Firebase credentials configured in the Jiguang sender.
+
+### Client enforcement of stopped/authorization controls
+
+Vendor payloads do not need to change. `FcmMessagingService.handleIntent` checks `stopPush()` and collection authorization before calling the pinned Firebase Messaging 25.0.1 receive handler. This covers Firebase's automatic background display of notification/combined payloads as well as data-only delivery. Authorized messages retain Firebase's normal dispatch and deduplication; callback-level guards remain. Blocked events are discarded and are not replayed on resume or authorization grant. Keep the receive-entry integration tests when upgrading Firebase because this override uses its internal public receive hook.
+
+The optional Google module disables Firebase notification delegation and removes the unguarded fallback service. A private startup provider clears any existing Google Play services notification delegate on Android 10+ after an upgrade, without requesting a token or changing consent. Other delegates are preserved. The provider runs before JS initialization, including when push is stopped or consent is absent. Existing delegation is revoked when the updated app first starts; code in a never-started update cannot revoke an already-installed delegate. Direct-boot reception before user unlock is not enabled.
+
+For vendor background notification/combined payloads, Firebase still owns display after the gate allows delivery. Their click action must remain `cn.jpush.android.intent.NOTIFICATION_OPENED` so the private JPush activity receives `JMessageExtra`. Data-only payloads continue through the native arrival/custom-message pipeline.
+
+Device acceptance must cover background notification-only, combined and data-only payloads: normal authorized delivery, no display/callback after stop or authorization withdrawal, normal delivery after resume/regrant, and an upgrade from existing Play services delegation. Robolectric tests run Firebase's real Intent receive/display code with only its transport acknowledgement mocked; they do not establish vendor cloud or physical-device acceptance.

package/android/build.gradle

@@ -107,6 +107,7 @@ android {
   testOptions {
     unitTests.returnDefaultValues = true
     unitTests.all {
+      inputs.property("jpushLiveTests", System.getenv("JPUSH_LIVE_TESTS") ?: "0")
       testLogging {
         events "passed", "skipped", "failed", "standardOut", "standardError"
         outputs.upToDateWhen { false }

package/android/fcm/build.gradle

@@ -0,0 +1,36 @@
+apply plugin: 'com.android.library'
+
+android {
+  namespace 'com.onekey.jpush.fcm'
+  compileSdkVersion rootProject.ext.compileSdkVersion
+
+  defaultConfig {
+    minSdkVersion rootProject.ext.minSdkVersion
+    targetSdkVersion rootProject.ext.targetSdkVersion
+    consumerProguardFiles 'consumer-rules.pro'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  testOptions {
+    unitTests.includeAndroidResources = true
+  }
+}
+
+def coreProject = rootProject.subprojects.find {
+  it.projectDir.canonicalFile == projectDir.parentFile.canonicalFile
+}
+if (coreProject == null) {
+  throw new GradleException('The FCM library requires the autolinked JPush core project.')
+}
+
+dependencies {
+  implementation project(coreProject.path)
+  implementation 'com.google.firebase:firebase-messaging:25.0.1'
+  testImplementation 'junit:junit:4.13.2'
+  testImplementation 'org.robolectric:robolectric:4.17'
+  testImplementation 'org.mockito:mockito-core:5.20.0'
+}

package/android/fcm/consumer-rules.pro

@@ -0,0 +1,2 @@
+# The core SDK discovers this optional transport by its fixed class name.
+-keep class com.onekey.jpush.fcm.FcmPushManager { public <init>(); }

package/android/fcm/src/main/AndroidManifest.xml

@@ -0,0 +1,25 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+  <application>
+    <meta-data android:name="firebase_messaging_auto_init_enabled" android:value="false" />
+    <meta-data android:name="firebase_messaging_notification_delegation_enabled" android:value="false" />
+    <provider
+      android:name="com.onekey.jpush.fcm.FcmInitProvider"
+      android:authorities="${applicationId}.onekey.fcm.init"
+      android:exported="false" />
+    <service
+      android:name="com.google.firebase.messaging.FirebaseMessagingService"
+      tools:node="remove" />
+    <service android:name="com.onekey.jpush.fcm.FcmMessagingService" android:exported="false">
+      <intent-filter>
+        <action android:name="com.google.firebase.MESSAGING_EVENT" />
+      </intent-filter>
+    </service>
+    <activity android:name="cn.jpush.android.service.JNotifyActivity" android:exported="false">
+      <intent-filter>
+        <action android:name="cn.jpush.android.intent.NOTIFICATION_OPENED" />
+        <category android:name="android.intent.category.DEFAULT" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>

package/android/fcm/src/main/java/com/onekey/jpush/fcm/FcmInitProvider.java

@@ -0,0 +1,25 @@
+package com.onekey.jpush.fcm;
+
+import android.app.NotificationManager;
+import android.content.Context;
+import android.os.Build;
+import cn.jiguang.plugins.push.common.JLogger;
+import cn.jpush.android.service.InitProvider;
+
+public final class FcmInitProvider extends InitProvider {
+    @Override
+    public boolean onCreate() {
+        super.onCreate();
+        Context context = getContext();
+        if (context != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            NotificationManager notifications = context.getSystemService(NotificationManager.class);
+            // Firebase caches delegation initialization across upgrades, so manifest opt-out alone
+            // does not revoke an existing Play services delegate.
+            if (notifications != null && "com.google.android.gms".equals(notifications.getNotificationDelegate())) {
+                notifications.setNotificationDelegate(null);
+                JLogger.i("FCM notification delegation disabled");
+            }
+        }
+        return true;
+    }
+}

package/android/fcm/src/main/java/com/onekey/jpush/fcm/FcmMessagingService.java

@@ -0,0 +1,84 @@
+package com.onekey.jpush.fcm;
+
+import android.content.Intent;
+import android.os.Bundle;
+import cn.jiguang.api.JCoreManager;
+import cn.jiguang.core.JCoreStorage;
+import cn.jiguang.plugins.push.common.JLogger;
+import cn.jpush.android.api.JThirdPlatFormInterface;
+import cn.jpush.android.local.ActionHelper;
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import java.util.Map;
+import org.json.JSONObject;
+
+public final class FcmMessagingService extends FirebaseMessagingService {
+    @Override
+    public void handleIntent(Intent intent) {
+        // Firebase may display background notifications before onMessageReceived is called.
+        if (JCoreStorage.isPushStopped(this) || !JCoreStorage.isCollectionAuth(this)) {
+            JLogger.i("FCM receive blocked by push or authorization state");
+            return;
+        }
+        super.handleIntent(intent);
+    }
+
+    @Override
+    public void onNewToken(String token) {
+        if (JCoreStorage.isPushStopped(this) || !JCoreStorage.isCollectionAuth(this)) {
+            return;
+        }
+        // Initialize the transport without fetching and submitting this token a second time.
+        JCoreManager.init(getApplicationContext());
+        FcmPushManager.acceptToken(getApplicationContext(), token);
+    }
+
+    @Override
+    public void onMessageReceived(RemoteMessage remoteMessage) {
+        if (JCoreStorage.isPushStopped(this) || !JCoreStorage.isCollectionAuth(this)) {
+            return;
+        }
+        try {
+            Map<String, String> data = remoteMessage.getData();
+            String raw = data.get("JMessageExtra");
+            JSONObject message;
+            if (raw == null || raw.isEmpty()) {
+                message = new JSONObject(data);
+            } else {
+                String decoded = JThirdPlatFormInterface.decodeMessageJson(raw);
+                if (decoded == null) {
+                    JLogger.w("FCM payload rejected");
+                    return;
+                }
+                message = new JSONObject(decoded);
+            }
+            RemoteMessage.Notification notification = remoteMessage.getNotification();
+            if (notification != null) {
+                if (!message.has("n_title") && !message.has("title")) {
+                    message.put("n_title", notification.getTitle());
+                }
+                if (!message.has("n_content") && !message.has("alert") && !message.has("content")) {
+                    message.put("n_content", notification.getBody());
+                }
+            }
+            if (!message.has("msg_id") && !message.has("_jmsgid_") && !message.has("_j_msgid")) {
+                message.put("msg_id", remoteMessage.getMessageId());
+            }
+            if (!message.has("n_extras") && !message.has("extras") && !data.containsKey("JMessageExtra")) {
+                message.put("n_extras", new JSONObject(data));
+            }
+            raw = message.toString();
+            Bundle payload = new Bundle();
+            payload.putString("JMessageExtra", raw);
+            payload.putByte("platform", (byte) 8);
+            ActionHelper.getInstance().doAction(
+                getApplicationContext(),
+                JThirdPlatFormInterface.ACTION_PLUGIN_PALTFORM_ON_MESSAGING,
+                payload
+            );
+            JLogger.i("FCM message forwarded to native dispatcher");
+        } catch (Exception invalidMessage) {
+            JLogger.w("FCM payload rejected");
+        }
+    }
+}

package/android/fcm/src/main/java/com/onekey/jpush/fcm/FcmPushManager.java

@@ -0,0 +1,69 @@
+package com.onekey.jpush.fcm;
+
+import android.content.Context;
+import android.os.Bundle;
+import cn.jiguang.core.JCoreStorage;
+import cn.jiguang.plugins.push.common.JLogger;
+import cn.jpush.android.api.JPushInterface;
+import cn.jpush.android.api.JThirdPlatFormInterface;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.messaging.FirebaseMessaging;
+
+public final class FcmPushManager extends JThirdPlatFormInterface {
+    @Override
+    public void init(Context context) {
+        FirebaseApp.initializeApp(context);
+    }
+
+    @Override
+    public void register(Context context, Bundle options) {
+        init(context);
+    }
+
+    @Override
+    public String getToken(final Context context) {
+        FirebaseMessaging.getInstance().getToken().addOnCompleteListener(task -> {
+            if (!task.isSuccessful()) {
+                Exception error = task.getException();
+                JLogger.w("FCM token request failed type="
+                    + (error != null ? error.getClass().getSimpleName() : "unknown"));
+                return;
+            }
+            acceptToken(context, task.getResult());
+        });
+        return JCoreStorage.getThirdToken(context, (byte) 8);
+    }
+
+    static void acceptToken(Context context, String token) {
+        if (token == null || token.isEmpty() || JCoreStorage.isPushStopped(context)
+            || !JCoreStorage.isCollectionAuth(context)) {
+            return;
+        }
+        Bundle result = new Bundle();
+        result.putString(KEY_TOKEN, token);
+        result.putByte(KEY_PLATFORM, (byte) 8);
+        doAction(context, ACTION_REGISTER_TOKEN, result);
+        JLogger.i("FCM token submitted to JCore");
+    }
+
+    @Override
+    public boolean isSupport(Context context) {
+        if (context == null) {
+            return false;
+        }
+        int status = GoogleApiAvailabilityLight.getInstance().isGooglePlayServicesAvailable(context);
+        if (status != 0) {
+            JLogger.w("FCM Google Play services unavailable code=" + status);
+        }
+        return status == 0;
+    }
+
+    @Override public byte getRomType(Context context) { return 8; }
+    @Override public String getRomName() { return "fcm"; }
+    @Override public boolean isNeedClearToken(Context context) { return false; }
+    @Override public String getAppkey(Context context) { return FirebaseApp.getInstance().getOptions().getApiKey(); }
+    @Override public String getAppId(Context context) { return FirebaseApp.getInstance().getOptions().getApplicationId(); }
+    @Override public void clearNotification(Context context, int id) { JPushInterface.clearNotificationById(context, id); }
+    @Override public void clearAllNotification(Context context) { JPushInterface.clearAllNotifications(context); }
+}