@conecli/cone-render 0.10.1-shop3.5 → 0.10.1-shop3.51

package/dist/utils/harmonyCallRouter.h5.ts

@@ -0,0 +1 @@
+const HARMONY_ROUTER_PLUGIN = 'JDHybridRouterPlugin'
  
  routerURL: string
  
  routerParam?: {
    [key: string]: any
  }
  
  callBackName?: string
  
  timeout?: number
  
  return new Promise((resolve, reject) => {
    if (!params?.routerURL) {
      return reject({ 
        status: '-103', 
        msg: 'routerURL参数不能为空' 
      })
    }
    if (typeof window?.XWebView?._callNative !== 'function') {
      return reject({ 
        status: '-100', 
        msg: '鸿蒙JSBridge不存在: window.XWebView._callNative' 
      })
    }
    const { routerURL, routerParam, callBackName, timeout = DEFAULT_TIMEOUT } = params
    
    const plugin = HARMONY_ROUTER_PLUGIN
    const action = HARMONY_ASYNC_ACTION
    const callbackId = callBackName || HARMONY_CALLBACK_ID + '_' + Date.now() + '_' + Math.round(Math.random()*10000)
    const callNativeParams = {
      plugin,
      action,
      params: {
        routerURL,
        routerParam: routerParam || {}
      },
      callbackId,
      callbackType: '1'
    }
    const callNativeParamsStr = JSON.stringify(callNativeParams)
    let timeoutId: number | null = null
    const timeoutError = {
      status: '-107',
      msg: `路由[${routerURL}]调用超时（${timeout}ms），请检查路由服务是否正常或者地址填写是否正确！`,
      data: null
    }
    if (timeout > 0) {
      timeoutId = window.setTimeout(() => {
        const pendingIndex = harmonyPendingPromises.findIndex(p => p.callbackId === callbackId)
        if (pendingIndex !== -1) {
          const { callBackName: pendingCallBackName } = harmonyPendingPromises[pendingIndex]
          
          if (pendingCallBackName && typeof window[pendingCallBackName] === 'function') {
            try {
              window[pendingCallBackName](timeoutError)
            } catch (callbackError) {
              console.warn('自定义回调函数执行异常:', callbackError)
            }
          }
          
          harmonyPendingPromises.splice(pendingIndex, 1)
        }
        
        reject(timeoutError)
      }, timeout)
    }
    handleHarmonyAsyncCall(callNativeParamsStr, callbackId, resolve, reject, callBackName, timeoutId)
  })
  callbackId: string
  resolve: Function
  reject: Function
  callBackName?: string
  timeoutId?: number | null
  callNativeParamsStr: string,
  callbackId: string,
  resolve: Function,
  reject: Function,
  callBackName?: string,
  timeoutId?: number | null
  try {
    const XBRIDGE_EVENT = 'XBridge_Event'
    
    harmonyPendingPromises.push({
      callbackId,
      resolve,
      reject,
      callBackName,
      timeoutId
    })
    const eventHandler = (event: any) => {
      try {
        const result = event?.detail?.data
        const parseResult = typeof result === 'string' ? JSON.parse(result) : result
        const { status, data, msg, callbackId: resultCallbackId } = parseResult || {}
        const pendingIndex = harmonyPendingPromises.findIndex(p => p.callbackId === resultCallbackId)
        if (pendingIndex === -1) return
        const { 
          resolve: pendingResolve, 
          reject: pendingReject, 
          callBackName: pendingCallBackName,
          timeoutId: pendingTimeoutId 
        } = harmonyPendingPromises[pendingIndex]
        if (pendingTimeoutId) {
          clearTimeout(pendingTimeoutId)
        }
        if (pendingCallBackName && typeof window[pendingCallBackName] === 'function') {
          try {
            window[pendingCallBackName](parseResult)
          } catch (callbackError) {
            console.warn('自定义回调函数执行异常:', callbackError)
          }
        }
        if (status === '0') {
          const successResult = data 
            ? parseResult 
            : { status: '0', data: null, msg: msg || '调用成功' }
          pendingResolve(successResult)
        } else {
          pendingReject(parseResult)
        }
        window.removeEventListener(XBRIDGE_EVENT, eventHandler)
        harmonyPendingPromises.splice(pendingIndex, 1)
      } catch (error) {
        window.removeEventListener(XBRIDGE_EVENT, eventHandler)
        
        const pendingIndex = harmonyPendingPromises.findIndex(p => p.callbackId === callbackId)
        if (pendingIndex !== -1) {
          const { 
            reject: pendingReject, 
            callBackName: pendingCallBackName,
            timeoutId: pendingTimeoutId 
          } = harmonyPendingPromises[pendingIndex]
          
          if (pendingTimeoutId) {
            clearTimeout(pendingTimeoutId)
          }
          
          if (pendingCallBackName && typeof window[pendingCallBackName] === 'function') {
            try {
              window[pendingCallBackName]({
                status: '-106',
                msg: '调用结果处理异常',
                data: error
              })
            } catch (callbackError) {
              console.warn('自定义回调函数执行异常:', callbackError)
            }
          }
          
          pendingReject({
            status: '-106',
            msg: '调用结果处理异常',
            data: error
          })
          harmonyPendingPromises.splice(pendingIndex, 1)
        }
      }
    }
    window.addEventListener(XBRIDGE_EVENT, eventHandler)
    try {
      window?.XWebView?._callNative?.(callNativeParamsStr)
    } catch (nativeError) {
      if (timeoutId) {
        clearTimeout(timeoutId)
      }
      
      window.removeEventListener(XBRIDGE_EVENT, eventHandler)
      const pendingIndex = harmonyPendingPromises.findIndex(p => p.callbackId === callbackId)
      if (pendingIndex !== -1) {
        const { callBackName: pendingCallBackName } = harmonyPendingPromises[pendingIndex]
        
        if (pendingCallBackName && typeof window[pendingCallBackName] === 'function') {
          try {
            window[pendingCallBackName]({
              status: '-106',
              msg: '原生调用执行失败',
              data: nativeError
            })
          } catch (callbackError) {
            console.warn('自定义回调函数执行异常:', callbackError)
          }
        }
        
        harmonyPendingPromises.splice(pendingIndex, 1)
      }
      reject({
        status: '-106',
        msg: '原生调用执行失败',
        data: nativeError
      })
    }
  } catch (error) {
    if (timeoutId) {
      clearTimeout(timeoutId)
    }
    
    reject({
      status: '-106',
      msg: '异步调用初始化异常',
      data: error
    })
  }
  harmonyPendingPromises = []