@trtc/calls-uikit-vue 4.5.3 → 4.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trtc/calls-uikit-vue",
-  "version": "4.5.3",
+  "version": "4.5.4",
   "main": "./tuicall-uikit-vue.umd.js",
   "module": "./tuicall-uikit-vue.es.js",
   "types": "./types/index.d.ts",

package/src/Components/components/common/AutoPlayDialog/AutoPlayDialog.vue

@@ -16,6 +16,7 @@ export default {
 <script lang="ts" setup>
 import { ref, onMounted, onUnmounted } from '../../../../adapter-vue';
 import { TUIStore, StoreName, NAME, TUIGlobal } from '../../../../TUICallService/index';
+import { TUICallKitAPI } from '../../../../TUICallService/index';
 import { useTranslate } from '../../../hooks';
 const t = useTranslate();
 // The onAutoPlayFailed event is listened in CallService at initialization time and its result is
@@ -40,6 +41,7 @@ onUnmounted(() => {
 
 const handleResumePlaybackClick = () => {
   TUIStore.update(StoreName.CALL, NAME.IS_SHOW_AUTO_PLAY_DIALOG, false);
+  TUICallKitAPI?._autoPlayResume?.();
 };
 </script>
 

package/src/TUICallService/CallService/engineEventHandler.ts

@@ -48,6 +48,7 @@ export default class EngineEventHandler {
     callEngine.on(TUICallEvent.ON_USER_INVITING, this._handleOnUserInviting, this); // 通话存在邀请他人时, 通话里的所有人都会抛出
     callEngine.on(TUICallEvent.SDK_READY, this._handleSDKReady, this); // SDK Ready 回调
     callEngine.on(TUICallEvent.KICKED_OUT, this._handleKickedOut, this); // 未开启多端登录时, 多端登录收到的被踢事件
+    // @ts-ignore
     callEngine.on(TUICallEvent.MESSAGE_SENT_BY_ME, this._messageSentByMe, this);
     // @ts-ignore
     TUICallEvent.CALL_MESSAGE && callEngine.on(TUICallEvent.CALL_MESSAGE, this._handleCallMessage, this); // call message card display event
@@ -75,6 +76,7 @@ export default class EngineEventHandler {
     callEngine.off(TUICallEvent.ON_USER_INVITING, this._handleOnUserInviting, this);
     callEngine.off(TUICallEvent.SDK_READY, this._handleSDKReady, this);
     callEngine.off(TUICallEvent.KICKED_OUT, this._handleKickedOut, this);
+    // @ts-ignore
     callEngine.off(TUICallEvent.MESSAGE_SENT_BY_ME, this._messageSentByMe, this);
     // @ts-ignore
     TUICallEvent.ON_USER_NETWORK_QUALITY_CHANGED && callEngine.off(TUICallEvent.ON_USER_NETWORK_QUALITY_CHANGED, this._handleNetworkQuality, this);

package/src/TUICallService/CallService/index.ts

@@ -27,7 +27,7 @@ const TUIGlobal: ITUIGlobal = TuiGlobal.getInstance();
 const TUIStore: ITUIStore = TuiStore.getInstance();
 const uiDesign = UIDesign.getInstance();
 uiDesign.setTUIStore(TUIStore);
-const version = '4.5.3';
+const version = '4.5.4';
 import AIAssistant from './AIAssistant'; // 仅 web 支持 AI 实时字幕
 const frameWork = 'vue3';
 export { TUIGlobal, TUIStore, uiDesign };
@@ -52,10 +52,12 @@ export default class TUICallService {
   private _wasmReadyResolve;
   private _isInitialized = false;
   // Use an arrow function to keep the `this` binding when registering/unregistering the listener.
-  private _handleAutoPlayFailed = () => {
+  private _handleAutoPlayFailed = (event: any) => {
     this._tuiCallEngine?.reportLog?.({
       name: 'TUICallkit.onAutoPlayFailed',
     });
+    // @ts-ignore
+    this._autoPlayResume = event?.resume; // webrtc 自动恢复播放失败需要自己调用
     TUIStore.update(StoreName.CALL, NAME.IS_SHOW_AUTO_PLAY_DIALOG, true);
   };
 
@@ -116,6 +118,7 @@ export default class TUICallService {
         frameWork,
         // @ts-ignore
         language: 6,
+        // @ts-ignore
         callkitVersion: version,
         isFromChat: isFromChat || false,
         component,

package/src/TUICallService/CallService/miniProgram.ts

@@ -1,4 +1,5 @@
 import { CallMediaType, CallStatus } from '../const/index';
+import { checkDevicePermission } from '../utils/permission';
 
 export function initialUI() {
   // 收起键盘
@@ -34,7 +35,9 @@ export async function beforeCall(type: CallMediaType, that: any) {
       microphone: true,
       camera: type === CallMediaType.VIDEO,
     };
-    const hasDevicePermission = await that._tuiCallEngine.deviceCheck(deviceMap); // miniProgram 检查设备权限
+    // `deviceCheck` is not implemented by @trtc/call-engine-lite-wx, so use the
+    // mini-program permission utility to pre-check microphone/camera access.
+    const hasDevicePermission = await checkDevicePermission(deviceMap); // miniProgram 检查设备权限
     return hasDevicePermission ? CallStatus.CALLING : CallStatus.IDLE;
   } catch (error) {
     console.debug(error);

package/src/TUICallService/UIKitModal/UIKitModal.ts

@@ -1,12 +1,19 @@
 // @ts-nocheck
 import type { UIKitModalOptions, UIKitModalResult } from './type';
-import  TUICallKitServer from '../CallService';
+// Use the explicit `/index` path so the WeChat mini-program `require`, which
+// only appends `.js` and does not resolve a directory to its `index.js`, can
+// locate the module.
+import  TUICallKitServer from '../CallService/index';
+
+// Native WeChat mini-program only exposes `wx`, while uniapp exposes `uni`.
+// Fall back to `wx` when `uni` is not defined so the modal works in both.
+const platform: any = typeof uni !== 'undefined' ? uni : wx;
 
 const URL_REGEX = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/i;
 const FULL_URL_REGEX = /(https?:\/\/[^\s]+)/g;
 
 function isDevEnvironment(): boolean {
-  const accountInfo = uni.getAccountInfoSync?.();
+  const accountInfo = platform.getAccountInfoSync?.();
   const envVersion = accountInfo?.miniProgram?.envVersion;
   return envVersion === 'develop' || envVersion === 'trial';
 }
@@ -82,7 +89,7 @@ const createUIKitModal = (options: UIKitModalOptions): Promise<UIKitModalResult>
     const processedContent = processContent(options.content);
     const hasLink = !!url;
 
-    uni.showModal({
+    platform.showModal({
       title: options.title || '',
       content: processedContent,
       cancelText: '取消',
@@ -91,10 +98,10 @@ const createUIKitModal = (options: UIKitModalOptions): Promise<UIKitModalResult>
         const action = res.confirm ? 'confirm' : 'cancel';
         if (res.confirm) {
           if (hasLink && url) {
-            uni.setClipboardData({
+            platform.setClipboardData({
               data: url,
               success: () => {
-                uni.showToast({ title: '链接已复制', icon: 'success' });
+                platform.showToast({ title: '链接已复制', icon: 'success' });
               },
             });
           }

package/src/TUICallService/utils/permission.ts

@@ -0,0 +1,294 @@
+/**
+ * WeChat mini-program permission utility.
+ *
+ * NOTE: This module is only referenced inside `// @if process.env.BUILD_TARGET='MINI'`
+ * conditional-compilation blocks, so it will be tree-shaken out of the web builds.
+ * `wx` global typings are not available in this package, therefore `// @ts-ignore`
+ * is used before each `wx.*` call, following the same convention as `miniProgram.ts`.
+ *
+ * Distinguishes two levels of permission denial:
+ * 1. Mini-program level: the user has rejected the scope in this mini-program.
+ *    Fix: call wx.openSetting to let the user toggle it.
+ * 2. System level: WeChat itself lacks the OS-level permission (Settings >
+ *    Privacy > Microphone / Camera on iOS, App Permissions on Android).
+ *    Fix: guide the user to the system settings page (cannot be opened
+ *    programmatically).
+ */
+
+// ── Permission Scope Constants ──
+export const PermissionScope = {
+  RECORD: 'scope.record',
+  CAMERA: 'scope.camera',
+} as const;
+
+// ── Result Types ──
+export interface PermissionCheckResult {
+  /** Whether the permission is granted. */
+  granted: boolean;
+  /** Human-readable tip shown to the user. */
+  tip: string;
+  /**
+   * Denial level:
+   * - 'mini-program': rejected within this mini-program → wx.openSetting works.
+   * - 'system': WeChat lacks the OS permission → user must go to system settings.
+   * - 'granted': already authorized.
+   */
+  level: 'granted' | 'mini-program' | 'system';
+}
+
+// ── Helpers ──
+
+/**
+ * Get the raw authSetting snapshot from WeChat.
+ */
+function getAuthSetting(): Promise<any> {
+  return new Promise((resolve) => {
+    // @ts-ignore
+    wx.getSetting({
+      success(res: any) {
+        resolve(res.authSetting);
+      },
+      fail() {
+        resolve({});
+      },
+    });
+  });
+}
+
+/**
+ * Attempt to authorize a scope via wx.authorize.
+ */
+function authorizeScope(
+  scope: string,
+): Promise<{ success: boolean; errMsg: string }> {
+  return new Promise((resolve) => {
+    // @ts-ignore
+    wx.authorize({
+      scope,
+      success() {
+        resolve({ success: true, errMsg: '' });
+      },
+      fail(err: any) {
+        resolve({ success: false, errMsg: err.errMsg || '' });
+      },
+    });
+  });
+}
+
+/**
+ * Check whether a scope has been explicitly denied by the user at the
+ * mini-program level (authSetting returns false for that key).
+ */
+function isMiniProgramDenied(authSetting: any, scope: string): boolean {
+  return authSetting[scope] === false;
+}
+
+// ── Public API ──
+
+/**
+ * Check and request microphone permission.
+ *
+ * - No camera permission → calls can still proceed (video call falls back to audio).
+ * - No microphone permission → calls MUST be blocked; user is guided to settings.
+ *
+ * The result's `level` field tells you whether the permission is already
+ * granted, denied at the mini-program level (wx.openSetting can fix it),
+ * or denied at the system level (user must go to OS settings manually).
+ */
+export async function checkMicrophonePermission(): Promise<PermissionCheckResult> {
+  const authSetting = await getAuthSetting();
+
+  // Already granted
+  if (authSetting[PermissionScope.RECORD] === true) {
+    return {
+      granted: true,
+      tip: '',
+      level: 'granted',
+    };
+  }
+
+  // Mini-program level: user has explicitly rejected the scope before.
+  if (isMiniProgramDenied(authSetting, PermissionScope.RECORD)) {
+    return {
+      granted: false,
+      tip: '您已拒绝麦克风权限，请前往小程序设置页面开启麦克风权限后重试',
+      level: 'mini-program',
+    };
+  }
+
+  // Scope is undefined — never requested. Try to authorize.
+  const result = await authorizeScope(PermissionScope.RECORD);
+
+  if (result.success) {
+    return { granted: true, tip: '', level: 'granted' };
+  }
+
+  // Authorization failed.
+  // If the native permission dialog was never shown (user actively cancelled
+  // or system-level block), errMsg typically contains "auth deny".
+  // When the OS-level permission is off, wx.authorize fails immediately
+  // without showing the dialog — we treat this as a system-level issue.
+  const isSystemLevelDenial =
+    !result.errMsg.includes('cancel') &&
+    !result.errMsg.includes('deny');
+
+  // Heuristic: if the error message suggests the dialog did NOT appear,
+  // it is very likely a system-level block.
+  if (isSystemLevelDenial || result.errMsg.includes('system')) {
+    return {
+      granted: false,
+      tip: '您的微信没有麦克风权限，请前往手机系统设置 > 微信，开启麦克风权限后重试',
+      level: 'system',
+    };
+  }
+
+  // User dismissed the native dialog or denied it → mini-program level.
+  return {
+    granted: false,
+    tip: '您拒绝了麦克风权限，请前往小程序设置页面开启麦克风权限后重试',
+    level: 'mini-program',
+  };
+}
+
+/**
+ * Check camera permission.
+ *
+ * Camera permission is REQUIRED for video calls — a denial MUST block the
+ * call (both for initiating and for answering). For audio calls this check
+ * is irrelevant and should be skipped by the caller.
+ *
+ * Tip wording here reflects the blocking policy: it tells the user that
+ * video calls cannot proceed without camera permission, and points them to
+ * the appropriate settings page (mini-program vs. system level).
+ */
+export async function checkCameraPermission(): Promise<PermissionCheckResult> {
+  const authSetting = await getAuthSetting();
+
+  if (authSetting[PermissionScope.CAMERA] === true) {
+    return { granted: true, tip: '', level: 'granted' };
+  }
+
+  if (isMiniProgramDenied(authSetting, PermissionScope.CAMERA)) {
+    return {
+      granted: false,
+      tip: '您已拒绝摄像头权限，无法发起或接听视频通话，请前往小程序设置页面开启摄像头权限后重试',
+      level: 'mini-program',
+    };
+  }
+
+  const result = await authorizeScope(PermissionScope.CAMERA);
+
+  if (result.success) {
+    return { granted: true, tip: '', level: 'granted' };
+  }
+
+  const isSystemLevelDenial =
+    !result.errMsg.includes('cancel') &&
+    !result.errMsg.includes('deny');
+
+  if (isSystemLevelDenial || result.errMsg.includes('system')) {
+    return {
+      granted: false,
+      tip: '您的微信没有摄像头权限，无法发起或接听视频通话，请前往手机系统设置 > 微信，开启摄像头权限后重试',
+      level: 'system',
+    };
+  }
+
+  return {
+    granted: false,
+    tip: '您拒绝了摄像头权限，无法发起或接听视频通话，请前往小程序设置页面开启摄像头权限后重试',
+    level: 'mini-program',
+  };
+}
+
+/**
+ * Handle a failed permission check by showing the appropriate dialog and
+ * optionally navigating to the settings page.
+ *
+ * Resolves with `{ confirm }` describing the user's choice:
+ * - confirm === true : the user clicked the primary button (前往设置 for the
+ *   mini-program level, or 我知道了 for the system level).
+ * - confirm === false: the user cancelled the dialog (only possible for the
+ *   mini-program level, which shows a 取消 button).
+ *
+ * Callers can use this to decide follow-up behavior, e.g. a callee rejecting
+ * the incoming call when the user cancels the mandatory permission dialog.
+ */
+export function handlePermissionDenied(result: PermissionCheckResult): Promise<{ confirm: boolean }> {
+  return new Promise((resolve) => {
+    if (result.level === 'mini-program') {
+      // Mini-program level: open the mini-program settings page.
+      // @ts-ignore
+      wx.showModal({
+        title: '权限提示',
+        content: result.tip,
+        confirmText: '前往设置',
+        cancelText: '取消',
+        success(modalRes: any) {
+          if (modalRes.confirm) {
+            // @ts-ignore
+            wx.openSetting({
+              complete() {
+                resolve({ confirm: true });
+              },
+            });
+          } else {
+            resolve({ confirm: false });
+          }
+        },
+        fail() {
+          resolve({ confirm: false });
+        },
+      });
+    } else {
+      // System level: can only guide the user, cannot open system settings.
+      // @ts-ignore
+      wx.showModal({
+        title: '权限提示',
+        content: result.tip,
+        showCancel: false,
+        confirmText: '我知道了',
+        success() {
+          resolve({ confirm: true });
+        },
+        fail() {
+          resolve({ confirm: false });
+        },
+      });
+    }
+  });
+}
+
+/**
+ * Combined device-permission pre-check used as the mini-program replacement
+ * for `tuiCallEngine.deviceCheck(deviceMap)`.
+ *
+ * - Microphone is mandatory for every call (audio and video).
+ * - Camera is mandatory only for video calls (`deviceMap.camera === true`).
+ *
+ * When a required permission is missing, the corresponding guidance dialog is
+ * shown (via `handlePermissionDenied`) and `false` is returned so the caller
+ * can abort / postpone the call. Returns `true` only when all required
+ * permissions are granted.
+ */
+export async function checkDevicePermission(
+  deviceMap: { microphone?: boolean; camera?: boolean } = {},
+): Promise<boolean> {
+  if (deviceMap.microphone) {
+    const micResult = await checkMicrophonePermission();
+    if (!micResult.granted) {
+      await handlePermissionDenied(micResult);
+      return false;
+    }
+  }
+
+  if (deviceMap.camera) {
+    const cameraResult = await checkCameraPermission();
+    if (!cameraResult.granted) {
+      await handlePermissionDenied(cameraResult);
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/TUICallService/utils/validate/avoidRepeatedCall.ts

@@ -17,6 +17,10 @@ export function avoidRepeatedCall() {
       if (isCallingSet.has(this)) {
         console.warn((`${NAME.PREFIX}previous ${name}() is ongoing, please avoid repeated calls`));
         // throw new Error(`previous ${name}() is ongoing, please avoid repeated calls`);
+        // Guard the method call itself: some classes decorated with
+        // `avoidRepeatedCall` (e.g. CallManager) do not implement
+        // `getTUICallEngineInstance`. Using `?.()` short-circuits when the
+        // method is absent instead of throwing "is not a function".
         this?.getTUICallEngineInstance()?.reportLog?.({
           name: 'TUICallKit.avoidRepeatedCall.fail',
           data: { name },
@@ -38,7 +42,7 @@ export function avoidRepeatedCall() {
     descriptor.value.clearCallState = function(instance: any) {
       isCallingSet.delete(instance);
     };
-    
+
     return descriptor;
   };
 }

package/src/index.ts

@@ -37,7 +37,7 @@ const TUICallType = {
   AUDIO_CALL: 1,
   VIDEO_CALL: 2,
 };
-const Version = '4.5.3'; // basic-demo 原来上报使用
+const Version = '4.5.4'; // basic-demo 原来上报使用
 
 // 输出产物
 export {