@onekeyfe/react-native-jpush 0.0.0-stage → 6.7.0-22

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OneKey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# `@onekeyfe/react-native-jpush`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Clean-room JPush (`6.0.0` iOS / `5.9.0` Android) and JCore (`5.2.0`) React Native Nitro module for OneKey.
+
+See the authoritative behavioral and wire-protocol specification in [`docs/SPEC.md`](./docs/SPEC.md).
+
+## Features
+
+- **Nitro JSI + React Native Bridge**: Implements `HybridReactNativeJpushSpec` (Nitro Modules) and exports `JPush` (default) + `JCore` (named) 100% compatible with `jpush-react-native` and `jcore-react-native` in `app-monorepo`.
+- **Clean-Room Native Source**: Full Objective-C/Swift (`ios/`) and Java/Kotlin (`android/`) source implementation with zero obfuscated `.a` or `.jar` binaries.
+- **Production Wire Protocol**: 10-byte UDP SIS (`'U','G'`), asymmetric 24-byte Client->Server and 20-byte Server->Client TCP framing, AES-256-CBC & SM4-CBC encryption, multi-IP waterfall failover, registered fast-login, exponential backoff auto-reconnect, HTTP `/v3/report` & iOS Badge report, and Android `:pushcore` AIDL IPC.
+
+## Verification
+
+```sh
+# TypeScript, ESLint, Jest, and Nitro codegen
+yarn workspace @onekeyfe/react-native-jpush nitrogen
+yarn workspace @onekeyfe/react-native-jpush typecheck
+yarn workspace @onekeyfe/react-native-jpush lint
+yarn workspace @onekeyfe/react-native-jpush test
+
+# 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/ReactNativeJpush.podspec

@@ -0,0 +1,66 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeJpush"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-jpush.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/include/*.h",
+    "ios/jcore/*.{h,m}",
+    "ios/jpush/*.{h,m}",
+    "ios/bridge/*.{h,m}",
+    "ios/*.swift",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.exclude_files = "ios/tests/**/*"
+
+  s.public_header_files = [
+    "ios/include/*.h",
+    "ios/jcore/*.h",
+    "ios/jpush/*.h",
+    "ios/bridge/RCTJPushEventQueue.h",
+    "ios/bridge/RCTJPushModule.h",
+  ]
+
+  s.frameworks = [
+    "UIKit",
+    "CFNetwork",
+    "CoreFoundation",
+    "CoreTelephony",
+    "CoreLocation",
+    "SystemConfiguration",
+    "CoreGraphics",
+    "Foundation",
+    "Security",
+    "Network",
+    "UserNotifications",
+  ]
+  s.libraries = ["z", "resolv"]
+
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/include\" \"$(PODS_TARGET_SRCROOT)/ios/jcore\" \"$(PODS_TARGET_SRCROOT)/ios/jpush\" \"$(PODS_TARGET_SRCROOT)/ios/bridge\""
+  }
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'ReactNativeNativeLogger'
+
+  load 'nitrogen/generated/ios/ReactNativeJpush+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+
+  s.test_spec "Tests" do |test_spec|
+    test_spec.source_files = "ios/tests/**/*.{m,swift}"
+  end
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(reactnativejpush)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME reactnativejpush)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/reactnativejpush+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,144 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeJpush_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/reactnativejpush+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeJpush_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.reactnativejpush"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  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 }
+        showStandardStreams = true
+      }
+    }
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+  implementation project(":onekeyfe_react-native-native-logger")
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.json:json:20231013"
+}

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); }
+}