@greensoul/expo-native-wechat 0.4.0

package/android/src/main/java/expo/modules/nativewechat/ExpoNativeWechatModule.kt

@@ -0,0 +1,509 @@
+package expo.modules.nativewechat
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Bitmap
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.core.os.bundleOf
+import com.tencent.mm.opensdk.modelbase.BaseReq
+import com.tencent.mm.opensdk.modelbase.BaseResp
+import com.tencent.mm.opensdk.modelbiz.SubscribeMessage
+import com.tencent.mm.opensdk.modelbiz.WXLaunchMiniProgram
+import com.tencent.mm.opensdk.modelbiz.WXOpenBusinessWebview
+import com.tencent.mm.opensdk.modelbiz.WXOpenCustomerServiceChat
+import com.tencent.mm.opensdk.modelbiz.WXOpenBusinessView
+import com.tencent.mm.opensdk.modelmsg.SendAuth
+import com.tencent.mm.opensdk.modelmsg.SendMessageToWX
+import com.tencent.mm.opensdk.modelmsg.WXImageObject
+import com.tencent.mm.opensdk.modelmsg.WXMediaMessage
+import com.tencent.mm.opensdk.modelmsg.WXMiniProgramObject
+import com.tencent.mm.opensdk.modelmsg.WXTextObject
+import com.tencent.mm.opensdk.modelmsg.WXVideoObject
+import com.tencent.mm.opensdk.modelmsg.WXWebpageObject
+import com.tencent.mm.opensdk.modelpay.PayReq
+import com.tencent.mm.opensdk.openapi.IWXAPI
+import com.tencent.mm.opensdk.openapi.IWXAPIEventHandler
+import com.tencent.mm.opensdk.openapi.WXAPIFactory
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.nativewechat.ExpoNativeWechatUtils.DownloadBitmapCallback
+import okhttp3.Call
+import java.io.IOException
+
+
+class ExpoNativeWechatModule : Module(), IWXAPIEventHandler {
+    private var appid: String? = null
+    private var registered = false
+    private var wxApi: IWXAPI? = null
+    private val REDIRECT_INTENT_ACTION = "com.hector.nativewechat.ACTION_REDIRECT_INTENT"
+    private val reactContext
+        get() = requireNotNull(appContext.reactContext)
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    override fun definition() = ModuleDefinition {
+        Name("ExpoNativeWechat")
+
+        Function("getConstants") {
+            return@Function bundleOf(
+                "WXSceneSession" to SendMessageToWX.Req.WXSceneSession,
+                "WXSceneTimeline" to SendMessageToWX.Req.WXSceneTimeline,
+                "WXSceneFavorite" to SendMessageToWX.Req.WXSceneFavorite,
+                "WXMiniProgramTypeRelease" to WXLaunchMiniProgram.Req.MINIPTOGRAM_TYPE_RELEASE,
+                "WXMiniProgramTypeTest" to WXLaunchMiniProgram.Req.MINIPROGRAM_TYPE_TEST,
+                "WXMiniProgramTypePreview" to WXLaunchMiniProgram.Req.MINIPROGRAM_TYPE_PREVIEW
+            )
+        }
+
+        Events("ResponseData", "ResponseFromNotification")
+
+        Function("registerApp") { params: RegisterAppParams ->
+            appid = params.appid
+            registered = true
+
+            wxApi = WXAPIFactory.createWXAPI(reactContext, appid, true);
+
+            val success = wxApi?.registerApp(appid)
+
+            appContext.reactContext?.registerReceiver(object : BroadcastReceiver() {
+                override fun onReceive(context: Context, intent: Intent) {
+                    handleIntent(intent.extras!!["intent"] as Intent?)
+                }
+            }, IntentFilter(REDIRECT_INTENT_ACTION), Context.RECEIVER_EXPORTED);
+
+            this@ExpoNativeWechatModule.sendEvent(
+                "ResponseData", bundleOf(
+                    "success" to success,
+                    "id" to params.id
+                )
+            )
+        }
+
+        Function("isWechatInstalled") { params: BasicRequestParams ->
+            val installed = wxApi?.isWXAppInstalled()
+
+            this@ExpoNativeWechatModule.sendEvent(
+                "ResponseData", bundleOf(
+                    "success" to installed,
+                    "id" to params.id
+                )
+            )
+        }
+
+        Function("sendAuthRequest") { params: SendAuthRequestParams ->
+            var req = SendAuth.Req()
+
+            req.scope = params.scope
+            req.state = req.state
+
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+        Function("shareText") { params: ShareTextParams ->
+            val text = params.text
+            val scene = params.scene
+
+            val textObj = WXTextObject()
+            textObj.text = text
+
+            val msg = WXMediaMessage()
+            msg.mediaObject = textObj
+            msg.description = text
+
+            val req = SendMessageToWX.Req()
+            req.message = msg
+            req.scene = scene
+
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+        Function("shareImage") { params: ShareImageParams ->
+            val src = params.src
+            val scene = params.scene
+
+            ExpoNativeWechatUtils.downloadFileAsBitmap(src, object : DownloadBitmapCallback {
+                override fun onFailure(call: Call, e: IOException) {
+                    this@ExpoNativeWechatModule.sendEvent(
+                        "ResponseData", bundleOf(
+                            "id" to params.id,
+                            "success" to false,
+                            "message" to e.localizedMessage
+                        )
+                    )
+                }
+
+                override fun onResponse(bitmap: Bitmap) {
+                    val imgObj = WXImageObject(bitmap)
+                    val msg = WXMediaMessage()
+                    msg.mediaObject = imgObj
+
+                    bitmap?.let {
+                        msg.thumbData = ExpoNativeWechatUtils.bmpToByteArray(bitmap, 32, true)
+                    }
+
+                    val req = SendMessageToWX.Req()
+                    req.message = msg
+                    req.scene = scene
+
+                    sendEvent(
+                        "ResponseData", bundleOf(
+                            "id" to params.id,
+                            "success" to wxApi?.sendReq(req)
+                        )
+                    )
+
+                }
+            })
+        }
+
+        Function("shareWebpage") { params: ShareWebpageParams ->
+            val webpageUrl = params.webpageUrl
+            val title = params.title
+            val description = params.description
+            val coverUrl = params.coverUrl
+            val scene = params.scene
+
+            val webpageObj = WXWebpageObject()
+            webpageObj.webpageUrl = webpageUrl
+
+            val msg = WXMediaMessage(webpageObj)
+            msg.title = title
+            msg.description = description
+
+            val onCoverDownloaded: (Bitmap?) -> Unit = { bitmap ->
+                bitmap?.let {
+                    msg.thumbData = ExpoNativeWechatUtils.bmpToByteArray(bitmap, 32, true)
+                }
+
+                val req = SendMessageToWX.Req()
+                req.message = msg
+                req.scene = scene
+
+                sendEvent(
+                    "ResponseData", bundleOf(
+                        "id" to params.id,
+                        "success" to wxApi?.sendReq(req)
+                    )
+                )
+            }
+
+            if (!coverUrl.isNullOrEmpty()) {
+                ExpoNativeWechatUtils.downloadFileAsBitmap(
+                    coverUrl,
+                    object : DownloadBitmapCallback {
+                        override fun onFailure(call: Call, e: IOException) {
+                            this@ExpoNativeWechatModule.sendEvent(
+                                "ResponseData", bundleOf(
+                                    "id" to params.id,
+                                    "success" to false,
+                                    "message" to e.localizedMessage
+                                )
+                            )
+                        }
+
+                        override fun onResponse(bitmap: Bitmap) {
+                            onCoverDownloaded(bitmap)
+                        }
+                    })
+            } else {
+                onCoverDownloaded(null)
+            }
+        }
+
+        Function("shareVideo") { params: ShareVideoParams ->
+            val videoUrl = params.videoUrl
+            val videoLowBandUrl = params.videoLowBandUrl
+            val title = params.title
+            val description = params.description
+            val coverUrl = params.coverUrl
+            val scene = params.scene
+
+            val video = WXVideoObject()
+            video.videoUrl = videoUrl
+
+            if (videoLowBandUrl != null) video.videoLowBandUrl = videoLowBandUrl
+
+            val msg = WXMediaMessage(video)
+            msg.title = title
+            msg.description = description
+
+            val onCoverDownloaded: (Bitmap?) -> Unit = { bitmap ->
+                bitmap?.let {
+                    msg.thumbData = ExpoNativeWechatUtils.bmpToByteArray(bitmap, 32, true)
+                }
+
+                val req = SendMessageToWX.Req()
+                req.message = msg
+                req.scene = scene
+
+                sendEvent(
+                    "ResponseData", bundleOf(
+                        "id" to params.id,
+                        "success" to wxApi?.sendReq(req)
+                    )
+                )
+            }
+
+            if (!coverUrl.isNullOrEmpty()) {
+                ExpoNativeWechatUtils.downloadFileAsBitmap(
+                    coverUrl,
+                    object : DownloadBitmapCallback {
+                        override fun onFailure(call: Call, e: IOException) {
+                            this@ExpoNativeWechatModule.sendEvent(
+                                "ResponseData", bundleOf(
+                                    "id" to params.id,
+                                    "success" to false,
+                                    "message" to e.localizedMessage
+                                )
+                            )
+                        }
+
+                        override fun onResponse(bitmap: Bitmap) {
+                            onCoverDownloaded(bitmap)
+                        }
+                    })
+            } else {
+                onCoverDownloaded(null)
+            }
+        }
+
+        Function("shareMiniProgram") { params: ShareMiniProgramParams ->
+            val webpageUrl = params.webpageUrl
+            val userName = params.userName
+            val path = params.path
+            val title = params.title
+            val description = params.description
+            val coverUrl = params.coverUrl
+            val withShareTicket = params.withShareTicket
+            val miniProgramType = params.miniProgramType
+            val scene = params.scene
+
+            val miniProgramObj = WXMiniProgramObject()
+            miniProgramObj.webpageUrl = webpageUrl
+            miniProgramObj.miniprogramType = miniProgramType
+            miniProgramObj.userName = userName
+            miniProgramObj.path = path
+            miniProgramObj.withShareTicket = withShareTicket!!
+
+            val msg = WXMediaMessage(miniProgramObj)
+            msg.title = title
+            msg.description = description
+
+            val onCoverDownloaded: (Bitmap?) -> Unit = { bitmap ->
+                bitmap?.let {
+                    msg.thumbData = ExpoNativeWechatUtils.bmpToByteArray(bitmap, 32, true)
+                }
+
+                val req = SendMessageToWX.Req()
+                req.message = msg
+                req.scene = scene
+
+                sendEvent(
+                    "ResponseData", bundleOf(
+                        "id" to params.id,
+                        "success" to wxApi?.sendReq(req)
+                    )
+                )
+            }
+
+            if (!coverUrl.isNullOrEmpty()) {
+                ExpoNativeWechatUtils.downloadFileAsBitmap(
+                    coverUrl,
+                    object : DownloadBitmapCallback {
+                        override fun onFailure(call: Call, e: IOException) {
+                            this@ExpoNativeWechatModule.sendEvent(
+                                "ResponseData", bundleOf(
+                                    "id" to params.id,
+                                    "success" to false,
+                                    "message" to e.localizedMessage
+                                )
+                            )
+                        }
+
+                        override fun onResponse(bitmap: Bitmap) {
+                            onCoverDownloaded(bitmap)
+                        }
+                    })
+            } else {
+                onCoverDownloaded(null)
+            }
+        }
+
+        Function("requestPayment") { params: RequestPaymentParams ->
+            val payReq = PayReq()
+
+            payReq.partnerId = params.partnerId
+            payReq.prepayId = params.prepayId
+            payReq.nonceStr = params.nonceStr
+            payReq.timeStamp = params.timeStamp
+            payReq.sign = params.sign
+            payReq.packageValue = "Sign=WXPay"
+            payReq.extData = params.extData
+            payReq.appId = appid
+
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(payReq)
+                )
+            )
+        }
+
+        Function("requestSubscribeMessage") { params: RequestSubscribeMsgParams ->
+            val templateId = params.templateId
+            val reserved = params.reserved
+            val scene = params.scene
+
+            val req = SubscribeMessage.Req()
+            req.scene = scene;
+            req.templateID = templateId;
+            req.reserved = reserved;
+
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+        Function("launchMiniProgram") { params: LaunchMiniprogramParams ->
+            val userName = params.userName
+            val path = params.path
+            val miniProgramType = params.miniProgramType
+
+            val req = WXLaunchMiniProgram.Req()
+            req.userName = userName;
+            req.path = path;
+            req.miniprogramType = miniProgramType;
+
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+        Function("openCustomerService") { params: OpenCustomerServiceParams ->
+            val corpId = params.corpid
+            val url = params.url
+
+            val req = WXOpenCustomerServiceChat.Req()
+            req.corpId = corpId
+            req.url = url
+
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+        Function("appPureSignContract") { params: AppPureSignContractParams ->
+            val req = WXOpenBusinessWebview.Req()
+            req.businessType = 12 // 固定值
+            
+            val queryInfo = HashMap<String, String>()
+            queryInfo["pre_entrustweb_id"] = params.preEntrustwebId
+            req.queryInfo = queryInfo
+            
+            sendEvent(
+                "ResponseData", bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+        Function("requestMerchantTransfer") { params: RequestMerchantTransferParams ->
+
+            val wxSdkVersion = wxApi?.wxAppSupportAPI ?: 0
+            if (wxSdkVersion < com.tencent.mm.opensdk.constants.Build.OPEN_BUSINESS_VIEW_SDK_INT) {
+
+                sendEvent(
+                    "ResponseData",
+                    bundleOf(
+                        "id" to params.id,
+                        "success" to false,
+                        "errorCode" to -1,
+                        "errorStr" to "微信版本过低，请升级到8.0.45及以上版本"
+                    )
+                )
+                return@Function
+            }
+
+            val req = WXOpenBusinessView.Req()
+            req.businessType = "requestMerchantTransfer"
+
+            val encodedMchId = java.net.URLEncoder.encode(params.mchId, "UTF-8")
+
+            val encodedAppId = java.net.URLEncoder.encode(appid ?: "", "UTF-8")
+
+            val encodedPackage = java.net.URLEncoder.encode(params.packageStr, "UTF-8")
+
+            val query = "mchId=${encodedMchId}&appId=${encodedAppId}&package=${encodedPackage}"
+            req.query = query
+
+            sendEvent("ResponseData", bundleOf("id" to params.id, "success" to wxApi?.sendReq(req)))
+        }
+
+        // 通用的 openBusinessView 接口
+        // 支持所有 businessType，如 'mp_business_type', 'wxpayScoreDetail', 'wxpayScoreEnable' 等
+        Function("openBusinessView") { params: OpenBusinessViewParams ->
+            val wxSdkVersion = wxApi?.wxAppSupportAPI ?: 0
+            if (wxSdkVersion < com.tencent.mm.opensdk.constants.Build.OPEN_BUSINESS_VIEW_SDK_INT) {
+                sendEvent(
+                    "ResponseData",
+                    bundleOf(
+                        "id" to params.id,
+                        "success" to false,
+                        "errorCode" to -1,
+                        "errorStr" to "微信版本过低，请升级到8.0.45及以上版本"
+                    )
+                )
+                return@Function
+            }
+
+            val req = WXOpenBusinessView.Req()
+            req.businessType = params.businessType
+            req.query = params.query
+            req.extInfo = params.extInfo ?: ""
+
+            sendEvent(
+                "ResponseData",
+                bundleOf(
+                    "id" to params.id,
+                    "success" to wxApi?.sendReq(req)
+                )
+            )
+        }
+
+    }
+
+    fun handleIntent(intent: Intent?) {
+        wxApi!!.handleIntent(intent, this)
+    }
+
+    override fun onReq(req: BaseReq?) {}
+
+    override fun onResp(baseResp: BaseResp?) {
+        val convertedData = NativeWechatRespDataHelper.downcastResp(baseResp)
+
+        sendEvent("ResponseFromNotification", convertedData)
+    }
+
+}