capacitor-jpush-core 0.0.1

package/android/src/main/kotlin/com/capacitor/jpush/core/JPush.kt

@@ -0,0 +1,261 @@
+package com.capacitor.jpush.core
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import cn.jpush.android.api.JPushInterface
+import cn.jpush.android.data.JPushConfig
+import cn.jpush.android.helper.Logger
+import cn.jpush.android.ups.JPushUPSManager
+import com.capacitor.jpush.core.JPushReceiver.Companion.ACTION_REGISTRATION_COMPLETED
+import com.getcapacitor.JSObject
+
+
+class JPush(private val context: Context) {
+
+    private val TAG = "JPush"
+    private val sequenceCallbackMap = mutableMapOf<Int, String>()
+    private var sequence = 0
+    private var hasInit = false
+
+    /**
+     * 初始化极光推送服务
+     *
+     * @param appKey     应用密钥
+     * @param channel    渠道
+     * @param production 是否为生产环境
+     */
+    fun setupJPush(appKey: String, channel: String, production: Boolean) {
+        try {
+            Logger.d(
+                TAG,
+                "初始化极光推送，appKey: $appKey, production: $production, channel: $channel"
+            )
+            if (!hasInit) {
+                hasInit = true
+                // 设置调试模式
+                JPushInterface.setDebugMode(!production)
+                // init也要设置key，
+                val config = JPushConfig()
+                config.setjAppKey(appKey)
+                JPushInterface.init(context, config)
+                // 开启回调才能收到点击事件，这坑排查了很久...
+                JPushInterface.setNotificationCallBackEnable(context, true)
+            }
+
+            // 使用JPushUPSManager.registerToken方法动态设置appKey（文档推荐方式）
+            // https://docs.jiguang.cn/jpush/client/Android/android_api#开启推送业务功能-api
+            // context: 应用上下文
+            // appId: 在极光官网注册应用时生成的 APPKEY
+            // appKey: 填 null 即可
+            // appSecret: 填空即可
+            // callback: 该接口的结果回调，状态码为 0 则说明调用成功，其它值均为失败
+            JPushUPSManager.registerToken(
+                context,
+                appKey,
+                null,
+                ""
+            ) { tokenResult ->
+                Log.d(TAG, tokenResult.toString())
+                tokenResult?.let {
+                    // 和iOS端统一, 使用监听传递成功和失败结果。
+                    if (it.returnCode == 0) {
+                        val data = JSObject().apply {
+                            put("registrationID", getRegistrationID())
+                        }
+                        sendEventBroadcast(context, ACTION_REGISTRATION_COMPLETED, data)
+                    } else {
+                        val data = JSObject().apply {
+                            put("errorCode", it.returnCode)
+                            put("errorMessage", "注册失败，错误码: ${it.returnCode}")
+                        }
+                        sendEventBroadcast(context, JPushReceiver.ACTION_REGISTRATION_FAILED, data)
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "初始化极光推送失败: ${e.message}")
+            e.printStackTrace()
+            // 初始化异常，发送注册失败广播
+            val data = JSObject().apply {
+                put("errorCode", -1)
+                put("errorMessage", e.message ?: "未知错误")
+            }
+            sendEventBroadcast(context, JPushReceiver.ACTION_REGISTRATION_FAILED, data)
+        }
+    }
+
+    /**
+     * 发送事件广播
+     */
+    private fun sendEventBroadcast(context: Context, action: String, data: JSObject) {
+        val intent = Intent(action).apply {
+            putExtra(JPushReceiver.EXTRA_DATA, data.toString())
+        }
+        context.sendBroadcast(intent)
+    }
+
+    /**
+     * 获取设备的注册ID
+     *
+     * @return 注册ID，如果未注册则返回空字符串
+     */
+    fun getRegistrationID(): String {
+        try {
+            val registrationID = JPushInterface.getRegistrationID(context)
+            Log.d(TAG, "获取注册ID: $registrationID")
+            return registrationID
+        } catch (e: Exception) {
+            Log.e(TAG, "获取注册ID失败: ${e.message}")
+            return ""
+        }
+    }
+
+    /**
+     * 设置别名
+     *
+     * @param alias      别名
+     * @param seq        序列号，用户自定义，用来标识操作唯一性
+     * @param callbackId 回调ID
+     * @return 是否设置成功
+     */
+    fun setAlias(alias: String, seq: Int?, callbackId: String): Boolean {
+        try {
+            val sequence = seq ?: 0
+            sequenceCallbackMap[sequence] = callbackId
+
+            Log.d(TAG, "设置别名: $alias, seq: $sequence")
+            JPushInterface.setAlias(context, sequence, alias)
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "设置别名失败: ${e.message}")
+            return false
+        }
+    }
+
+    /**
+     * 清除别名
+     *
+     * @param seq        序列号，用户自定义，用来标识操作唯一性
+     * @param callbackId 回调ID
+     * @return 是否清除成功
+     */
+    fun deleteAlias(seq: Int?, callbackId: String): Boolean {
+        try {
+            val sequence = seq ?: 0
+            sequenceCallbackMap[sequence] = callbackId
+
+            Log.d(TAG, "清除别名, seq: $sequence")
+            JPushInterface.deleteAlias(context, sequence)
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "清除别名失败: ${e.message}")
+            return false
+        }
+    }
+
+    /**
+     * 设置标签（替换所有现有标签）
+     *
+     * @param tags       标签列表
+     * @param seq        序列号，用户自定义，用来标识操作唯一性
+     * @param callbackId 回调ID
+     * @return 是否设置成功
+     */
+    fun setTags(tags: List<String>, seq: Int?, callbackId: String): Boolean {
+        try {
+            val sequence = seq ?: 0
+            sequenceCallbackMap[sequence] = callbackId
+            val tagSet = tags.toMutableSet()
+
+            Log.d(TAG, "设置标签: $tags, seq: $sequence")
+            JPushInterface.setTags(context, sequence, tagSet)
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "设置标签失败: ${e.message}")
+            return false
+        }
+    }
+
+    /**
+     * 添加标签
+     *
+     * @param tags       标签列表
+     * @param seq        序列号，用户自定义，用来标识操作唯一性
+     * @param callbackId 回调ID
+     * @return 是否添加成功
+     */
+    fun addTags(tags: List<String>, seq: Int?, callbackId: String): Boolean {
+        try {
+            val sequence = seq ?: 0
+            sequenceCallbackMap[sequence] = callbackId
+            val tagSet = tags.toMutableSet()
+
+            Log.d(TAG, "添加标签: $tags, seq: $sequence")
+            JPushInterface.addTags(context, sequence, tagSet)
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "添加标签失败: ${e.message}")
+            return false
+        }
+    }
+
+    /**
+     * 删除标签
+     *
+     * @param tags       标签列表
+     * @param seq        序列号，用户自定义，用来标识操作唯一性
+     * @param callbackId 回调ID
+     * @return 是否删除成功
+     */
+    fun deleteTags(tags: List<String>, seq: Int?, callbackId: String): Boolean {
+        try {
+            val sequence = seq ?: 0
+            sequenceCallbackMap[sequence] = callbackId
+            val tagSet = tags.toMutableSet()
+
+            Log.d(TAG, "删除标签: $tags, seq: $sequence")
+            JPushInterface.deleteTags(context, sequence, tagSet)
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "删除标签失败: ${e.message}")
+            return false
+        }
+    }
+
+    /**
+     * 清除所有标签
+     *
+     * @param seq        序列号，用户自定义，用来标识操作唯一性
+     * @param callbackId 回调ID
+     * @return 是否清除成功
+     */
+    fun cleanTags(seq: Int?, callbackId: String): Boolean {
+        try {
+            val sequence = seq ?: 0
+            sequenceCallbackMap[sequence] = callbackId
+
+            Log.d(TAG, "清除所有标签, seq: $sequence")
+            JPushInterface.cleanTags(context, sequence)
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "清除所有标签失败: ${e.message}")
+            return false
+        }
+    }
+
+    /**
+     * 设置未读角标数量
+     *
+     * @param badge 角标数量，0 表示清空角标
+     * @return 是否设置成功
+     */
+    fun setBadge(badge: Int): Boolean {
+        // 设置角标数字(目前仅支持华为手机)
+        // 如果需要调用这个接口，还需要在 AndroidManifest.xml 里配置华为指定的权限
+        JPushInterface.setBadgeNumber(context, badge)
+        return true
+    }
+
+}

package/android/src/main/kotlin/com/capacitor/jpush/core/JPushPlugin.kt

@@ -0,0 +1,431 @@
+package com.capacitor.jpush.core
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+
+
+
+
+@CapacitorPlugin(
+    name = "JPush",
+    permissions = [
+        Permission(strings = ["android.permission.POST_NOTIFICATIONS"], alias = JPushPlugin.NOTIFICATIONS_STATUS_KEY)
+    ]
+)
+class JPushPlugin : Plugin() {
+
+    private val TAG = "JPushPlugin"
+    private lateinit var jPush: JPush
+    private var isInitialized = false
+    private var activeClearBadge = false // 是否自动清除角标
+
+    companion object {
+        // 移除private修饰符，让常量在类外部可见
+        const val NOTIFICATIONS_STATUS_KEY = "permission"
+        
+        // JPush事件名称常量
+        const val NOTIFICATION_RECEIVED = "notificationReceived"
+        const val NOTIFICATION_OPENED = "notificationOpened"
+        const val CUSTOM_MESSAGE_RECEIVED = "customMessageReceived"
+        const val REGISTRATION_COMPLETED = "registrationCompleted"
+        const val REGISTRATION_FAILED = "registrationFailed"
+    }
+
+
+    // 保存获取注册ID的回调
+    private var registrationIdCall: PluginCall? = null
+    
+    // 广播接收器，用于接收JPush事件
+    private val broadcastReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            val action = intent.action
+            val dataString = intent.getStringExtra(JPushReceiver.EXTRA_DATA)
+
+            if (dataString.isNullOrEmpty()) {
+                return
+            }
+
+            try {
+                val data = JSObject(dataString)
+
+                when (action) {
+                JPushReceiver.ACTION_REGISTRATION_COMPLETED -> {
+                    // 处理注册完成事件
+                    Log.d(TAG, "注册完成: $dataString")
+                    notifyListeners(REGISTRATION_COMPLETED, data)
+
+                    // 如果有等待的注册ID回调，则解析并返回
+                    registrationIdCall?.let {
+                        val registrationID = data.getString("registrationID") ?: ""
+                        val ret = JSObject().apply {
+                            put("registrationID", registrationID)
+                        }
+                        it.resolve(ret)
+                        registrationIdCall = null
+                    }
+                }
+                JPushReceiver.ACTION_REGISTRATION_FAILED -> {
+                    // 处理注册失败事件
+                    Log.d(TAG, "注册失败: $dataString")
+                    notifyListeners(REGISTRATION_FAILED, data)
+                }
+                JPushReceiver.ACTION_NOTIFICATION_RECEIVED -> {
+                    // 处理收到通知事件
+                    Log.d(TAG, "收到通知: $dataString")
+                    notifyListeners(NOTIFICATION_RECEIVED, data)
+                }
+                JPushReceiver.ACTION_NOTIFICATION_OPENED -> {
+                    // 处理点击通知事件
+                    Log.d(TAG, "点击通知: $dataString")
+                    notifyListeners(NOTIFICATION_OPENED, data)
+                }
+                JPushReceiver.ACTION_CUSTOM_MESSAGE_RECEIVED -> {
+                    // 处理收到自定义消息事件
+                    Log.d(TAG, "收到自定义消息: $dataString")
+                    notifyListeners(CUSTOM_MESSAGE_RECEIVED, data)
+                }
+
+            }
+            } catch (e: Exception) {
+                Log.e(TAG, "处理广播事件失败: ${e.message}")
+            }
+        }
+    }
+
+    override fun load() {
+        super.load()
+        jPush = JPush(context)
+
+        // 注册广播接收器
+        registerBroadcastReceiver()
+
+        Log.d(TAG, "JPushPlugin 已加载")
+    }
+
+    override fun handleOnResume() {
+        super.handleOnResume()
+        
+        // 当应用回到前台时，如果配置了activeClearBadge为true，则清除角标
+        if (activeClearBadge) {
+            Log.d(TAG, "应用回到前台，清除角标")
+            jPush.setBadge(0)
+        }
+    }
+
+    override fun handleOnDestroy() {
+        super.handleOnDestroy()
+
+        // 注销广播接收器
+        unregisterBroadcastReceiver()
+
+        Log.d(TAG, "JPushPlugin 已销毁")
+    }
+
+    /**
+     * 初始化极光推送服务
+     */
+    @PluginMethod
+    fun setupJPush(call: PluginCall) {
+        // 从Capacitor配置中读取参数
+        val appKey = config.getString("appKey")
+        val channel = config.getString("channel", "Android")
+        val production = config.getBoolean("production", false)
+        activeClearBadge = config.getBoolean("activeClearBadge", false)
+
+        if (appKey.isNullOrEmpty()) {
+            call.reject("appKey 不能为空")
+            return
+        }
+
+        // 初始化极光推送（异步）
+        jPush.setupJPush(appKey, channel, production)
+        isInitialized = true
+        // 直接返回成功，初始化结果通过事件通知
+        call.resolve()
+    }
+
+    /**
+     * 获取设备的注册ID
+     */
+    @PluginMethod
+    fun getRegistrationID(call: PluginCall) {
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val registrationID = jPush.getRegistrationID()
+
+        if (registrationID.isNotEmpty()) {
+            val ret = JSObject().apply {
+                put("registrationID", registrationID)
+            }
+            call.resolve(ret)
+        } else {
+            // 保存回调，等待注册完成
+            this.registrationIdCall = call
+        }
+    }
+
+    /**
+     * 设置别名
+     */
+    @PluginMethod
+    fun setAlias(call: PluginCall) {
+        val alias = call.getString("alias")
+        
+        val seq = call.getInt("seq")
+
+        if (alias.isNullOrEmpty()) {
+            call.reject("alias 不能为空")
+            return
+        }
+
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val success = jPush.setAlias(alias, seq, call.callbackId)
+
+        if (success) {
+            call.resolve()
+        } else {
+            call.reject("设置别名失败")
+        }
+    }
+
+    /**
+     * 清除别名
+     */
+    @PluginMethod
+    fun deleteAlias(call: PluginCall) {
+        val seq = call.getInt("seq")
+        
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val success = jPush.deleteAlias(seq, call.callbackId)
+
+        if (success) {
+            call.resolve()
+        } else {
+            call.reject("清除别名失败")
+        }
+    }
+
+    /**
+     * 设置标签（替换所有现有标签）
+     */
+    @PluginMethod
+    fun setTags(call: PluginCall) {
+        val tagsArray = call.getArray("tags")
+        val seq = call.getInt("seq")
+        
+        val tags = mutableListOf<String>()
+        if (tagsArray != null) {
+            for (i in 0 until tagsArray.length()) {
+                tagsArray.getString(i)?.let { tags.add(it) }
+            }
+        }
+
+        if (tags.isEmpty()) {
+            call.reject("tags 不能为空")
+            return
+        }
+
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val success = jPush.setTags(tags, seq, call.callbackId)
+
+        if (success) {
+            call.resolve()
+        } else {
+            call.reject("设置标签失败")
+        }
+    }
+
+    /**
+     * 添加标签
+     */
+    @PluginMethod
+    fun addTags(call: PluginCall) {
+        val tagsArray = call.getArray("tags")
+        val seq = call.getInt("seq")
+        
+        val tags = mutableListOf<String>()
+        if (tagsArray != null) {
+            for (i in 0 until tagsArray.length()) {
+                tagsArray.getString(i)?.let { tags.add(it) }
+            }
+        }
+
+        if (tags.isEmpty()) {
+            call.reject("tags 不能为空")
+            return
+        }
+
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val success = jPush.addTags(tags, seq, call.callbackId)
+
+        if (success) {
+            call.resolve()
+        } else {
+            call.reject("添加标签失败")
+        }
+    }
+
+    /**
+     * 删除标签
+     */
+    @PluginMethod
+    fun deleteTags(call: PluginCall) {
+        val tagsArray = call.getArray("tags")
+        val seq = call.getInt("seq")
+        
+        val tags = mutableListOf<String>()
+        if (tagsArray != null) {
+            for (i in 0 until tagsArray.length()) {
+                tagsArray.getString(i)?.let { tags.add(it) }
+            }
+        }
+
+        if (tags.isEmpty()) {
+            call.reject("tags 不能为空")
+            return
+        }
+
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val success = jPush.deleteTags(tags, seq, call.callbackId)
+
+        if (success) {
+            call.resolve()
+        } else {
+            call.reject("删除标签失败")
+        }
+    }
+
+    /**
+     * 清除所有标签
+     */
+    @PluginMethod
+    fun cleanTags(call: PluginCall) {
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val success = jPush.cleanTags(null, call.callbackId)
+
+        if (success) {
+            call.resolve()
+        } else {
+            call.reject("清除标签失败")
+        }
+    }
+
+    /**
+     * 检查推送权限
+     */
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            // Android 13以下：通知权限不是运行时权限，默认授予
+            val permissionsResult = JSObject()
+            permissionsResult.put("permission", "granted")
+            call.resolve(permissionsResult)
+        } else {
+            // Android 13+：使用Capacitor框架的权限检查机制
+            super.checkPermissions(call)
+        }
+    }
+
+    /**
+     * 请求推送权限
+     */
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            // Android 13以下：通知权限不是运行时权限，默认授予
+            val permissionsResult = JSObject()
+            permissionsResult.put(NOTIFICATIONS_STATUS_KEY, "granted")
+            call.resolve(permissionsResult)
+        } else {
+            // Android 13+：使用Capacitor框架的权限请求机制
+            super.requestPermissionForAlias(NOTIFICATIONS_STATUS_KEY, call, "permissionsCallback")
+        }
+    }
+
+    @PermissionCallback
+    private fun permissionsCallback(call: PluginCall) {
+        this.checkPermissions(call)
+    }
+
+    /**
+     * 设置未读角标数量
+     */
+    @PluginMethod
+    fun setBadge(call: PluginCall) {
+        if (!isInitialized) {
+            call.reject("极光推送未初始化，请先调用initJPush方法")
+            return
+        }
+
+        val badge = call.getInt("badge", 0) ?: 0
+
+        jPush.setBadge(badge)
+        call.resolve()
+    }
+
+    /**
+     * 注册广播接收器
+     */
+    private fun registerBroadcastReceiver() {
+        val filter = IntentFilter().apply {
+            addAction(JPushReceiver.ACTION_REGISTRATION_COMPLETED)
+            addAction(JPushReceiver.ACTION_REGISTRATION_FAILED)
+            addAction(JPushReceiver.ACTION_NOTIFICATION_RECEIVED)
+            addAction(JPushReceiver.ACTION_NOTIFICATION_OPENED) // 取消注释，接收点击通知事件
+            addAction(JPushReceiver.ACTION_CUSTOM_MESSAGE_RECEIVED)
+        }
+
+        ContextCompat.registerReceiver(context, broadcastReceiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
+    }
+
+    /**
+     * 注销广播接收器
+     */
+    private fun unregisterBroadcastReceiver() {
+        try {
+            context.unregisterReceiver(broadcastReceiver)
+        } catch (e: Exception) {
+            Log.e(TAG, "注销广播接收器失败: ${e.message}")
+        }
+    }
+
+}