unify-external-plugin-platform 0.0.3-79 → 0.0.3-80

package/dist/external-plugin.umd.js

@@ -83188,8 +83188,8 @@ var scanner_cameravue_type_template_id_00e9072f_scoped_true_render = function re
 };
 var scanner_cameravue_type_template_id_00e9072f_scoped_true_staticRenderFns = [];
 
-;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-85.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[4]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=template&id=74fe19f7&
-var scanner_camera_componentvue_type_template_id_74fe19f7_render = function render() {
+;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-85.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[4]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=template&id=1d5723dd&
+var scanner_camera_componentvue_type_template_id_1d5723dd_render = function render() {
   var _vm = this,
     _c = _vm._self._c;
   return _c('div', {
@@ -83323,7 +83323,7 @@ var scanner_camera_componentvue_type_template_id_74fe19f7_render = function rend
     }
   }, [_vm._v("旋转180°")])], 1)], 1) : _vm._e(), _vm._t("action")]], 2)])]);
 };
-var scanner_camera_componentvue_type_template_id_74fe19f7_staticRenderFns = [];
+var scanner_camera_componentvue_type_template_id_1d5723dd_staticRenderFns = [];
 
 ;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
 function _typeof(obj) {
@@ -84464,7 +84464,10 @@ _defineProperty(FounderPluginSocketService, "ws", void 0);
 var UdsPluginMethodCode;
 (function (UdsPluginMethodCode) {
   UdsPluginMethodCode["TurnOnCamera"] = "turnOnCamera";
+  UdsPluginMethodCode["TurnOnSubCamera"] = "turnOnSubCamera";
+  UdsPluginMethodCode["TurnOffCamera"] = "turnOffCamera";
   UdsPluginMethodCode["TakePhoto_Base64"] = "TakePhoto_Base64";
+  UdsPluginMethodCode["ReadIDCard"] = "ReadIDCard";
 })(UdsPluginMethodCode || (UdsPluginMethodCode = {}));
 class UdsPluginSocketService {
   static startConnect() {
@@ -84512,7 +84515,9 @@ class UdsPluginSocketService {
     if (data.FuncName === 'ShowVideo') {
       const event = new ScannerCameraRefreshPhotoEvent(data.result);
       return window.dispatchEvent(event);
-    } else if (data.FuncName === "CaptureBase64" || data.FuncName === "CaptureDualBase64") {
+    } else if (data.FuncName === "CaptureBase64" || data.FuncName === "CaptureDualBase64" || data.FuncName === "ReadIDCard"
+    // 开启主头/副头/关闭摄像头等指令的返回值，用于结束对应的 Promise（如 StartRunSub 副头开启）
+    || data.FuncName === "StartRunMain" || data.FuncName === "StartRunSub" || data.FuncName === "StopVideo") {
       this.requestStore.forEach(({
         resolve
       }) => {
@@ -84539,6 +84544,18 @@ class UdsPluginSocketService {
             arg: 0
           });
           break;
+        case UdsPluginMethodCode.TurnOnSubCamera:
+          method = JSON.stringify({
+            Func: "StartRunSub",
+            arg: 0
+          });
+          break;
+        case UdsPluginMethodCode.TurnOffCamera:
+          method = JSON.stringify({
+            Func: "StopVideo",
+            arg: 0
+          });
+          break;
         case UdsPluginMethodCode.TakePhoto_Base64:
           this.ws.send(JSON.stringify({
             Func: "SetJPGQuality",
@@ -84559,10 +84576,15 @@ class UdsPluginSocketService {
           method = JSON.stringify({
             Func: "CaptureBase64",
             arg: 0
+          }); // 0-jpg,1-bmp,2-png,3-tif格式
+          break;
+        case UdsPluginMethodCode.ReadIDCard:
+          method = JSON.stringify({
+            Func: "ReadIDCard",
+            arg: 0
           });
-        // 0-jpg,1-bmp,2-png,3-tif格式
+          break;
       }
-
       this.ws.send(method);
       return new Promise((resolve, reject) => {
         if (!this.requestStore) {
@@ -84580,10 +84602,103 @@ class UdsPluginSocketService {
   static async turnOnTheCamera() {
     await UdsPluginSocketService.read(UdsPluginMethodCode.TurnOnCamera);
   }
+  /**
+   * 开启副头摄像头
+   */
+  static async turnOnSubCamera() {
+    await UdsPluginSocketService.read(UdsPluginMethodCode.TurnOnSubCamera);
+  }
+  /**
+   * 关闭摄像头
+   */
+  static async turnOffCamera() {
+    await UdsPluginSocketService.read(UdsPluginMethodCode.TurnOffCamera);
+  }
   static async scanByCamera() {
     const res = await UdsPluginSocketService.read(UdsPluginMethodCode.TakePhoto_Base64);
     return res;
   }
+  /**
+   * 副摄像头拍照：先确保副头摄像头已开启，再进行 base64 拍照
+   * （CaptureBase64 以当前开启的摄像头为准，参考 UDSCamDemo：StartRunSub + CaptureBase64）
+   * @returns {Promise<string>} 图片 base64
+   */
+  static async scanBySubCamera() {
+    await UdsPluginSocketService.turnOnSubCamera();
+    return UdsPluginSocketService.scanByCamera();
+  }
+  /**
+   * 读取二代身份证
+   * 返回结构与其他读卡服务保持一致：{ info: {...}, headImage }
+   * 另保留指纹、旧证件号等原始字段，便于业务使用
+   */
+  static async idCardRead() {
+    const res = await UdsPluginSocketService.read(UdsPluginMethodCode.ReadIDCard);
+    if (!res || res === '0') {
+      throw Error('未匹配可用的紫图读卡器');
+    }
+    let readData = typeof res === 'string' ? JSON.parse(res) : res;
+    let {
+      CardType,
+      // S-身份证，I/Y-外国人居住证，J-港澳台通行证
+      Name,
+      NameENG,
+      Sex,
+      Nation,
+      BirthDate,
+      Addr,
+      ID,
+      OldID,
+      Office,
+      BeginDate,
+      EndDate,
+      Label,
+      Num,
+      HaveFinger,
+      FingerOne,
+      FingerTwo,
+      HeadPic
+    } = readData;
+    // 证件类型转换：S-身份证(1)，I/Y-外国人居住证(9)，J-港澳台通行证(9)
+    let cardType = '1';
+    let chineseName = '';
+    let nationality = '中国';
+    if (CardType === 'I' || CardType === 'Y') {
+      // 外国人居住证
+      cardType = '9';
+      chineseName = Name || '';
+      nationality = Nation || '中国'; // 外国人时Nation为国家名称
+    } else if (CardType === 'J') {
+      // 港澳台通行证
+      cardType = '9';
+    }
+    const IDCardData = {
+      info: {
+        cardType,
+        name: Name || '',
+        chineseName,
+        englishName: NameENG || '',
+        sex: Sex || '',
+        birthday: BirthDate || '',
+        address: Addr || '',
+        cardId: ID || '',
+        nationality,
+        nation: cardType === '1' ? Nation || '' : '',
+        police: Office || '',
+        validStart: BeginDate || '',
+        validEnd: EndDate || ''
+      },
+      headImage: HeadPic || '',
+      // 原始附加信息（保留，便于业务使用）
+      oldID: OldID || '',
+      label: Label || '',
+      num: Num || '',
+      haveFinger: HaveFinger || '',
+      fingerOne: FingerOne || '',
+      fingerTwo: FingerTwo || ''
+    };
+    return IDCardData;
+  }
 }
 _defineProperty(UdsPluginSocketService, "scannerCameraUrl", 'ws://127.0.0.1:8341');
 _defineProperty(UdsPluginSocketService, "ws", void 0);
@@ -85265,6 +85380,721 @@ _defineProperty(HanWangPluginService, "ws", void 0);
 _defineProperty(HanWangPluginService, "connectingPromise", new Promise((resolve, reject) => {}));
 _defineProperty(HanWangPluginService, "requestStore", []);
 _defineProperty(HanWangPluginService, "_isLinux", String(navigator.platform).indexOf("Linux") > -1);
+;// CONCATENATED MODULE: ./packages/service/external-plugins/viisan-plugin-socket.service.ts
+
+
+/**
+ * @author: lvcy
+ * @date: 2026-08-31
+ * @description：维山（Viisan）高拍仪 - 通过 WebSocket 与本地服务通信，实现高拍仪拍照及读卡功能
+ *
+ * 通信协议说明（参考 CamSDK samples）：
+ *   - WebSocket 地址：ws://127.0.0.1:9000
+ *   - 请求格式：JSON 字符串，包含 func（方法名）和 reqId（请求ID）等字段
+ *   - 响应格式：JSON 对象，result=0 表示成功，其他值表示异常（result=9 表示设备使用中）
+ *   - 拍照返回：imgBase64 数组（base64 编码的图片数据）和 mime 字段（图片类型，如 image/jpeg）
+ *   - 读卡返回：cardInfo 对象，包含姓名、性别、民族、生日、地址、身份证号、签发机关、有效期、头像照片等
+ */
+
+/** Viisan 高拍仪方法编码 */
+var ViisanMethodCode;
+(function (ViisanMethodCode) {
+  /** 获取摄像头设备信息（设备列表、分辨率等） */
+  ViisanMethodCode["GetCameraInfo"] = "GetCameraInfo";
+  /** 打开摄像头 */
+  ViisanMethodCode["OpenCamera"] = "OpenCamera";
+  /** 关闭摄像头 */
+  ViisanMethodCode["CloseCamera"] = "CloseCamera";
+  /** 设置图像算法参数（裁切方式、图像效果、补边等） */
+  ViisanMethodCode["SetCameraImageInfo"] = "SetCameraImageInfo";
+  /** 拍照（返回 base64 图片） */
+  ViisanMethodCode["CameraCapture"] = "CameraCapture";
+  /** 拍照（返回 base64 图片，用于人证比对页面） */
+  ViisanMethodCode["CameraCaptureBase64"] = "CameraCaptureBase64";
+  /** 获取/停止视频预览帧 */
+  ViisanMethodCode["GetCameraVideoBuff"] = "GetCameraVideoBuff";
+  /** 设置摄像头分辨率等参数 */
+  ViisanMethodCode["SetCameraInfo"] = "SetCameraInfo";
+  /** 读取二代身份证信息（通过高拍仪内置读卡器或外接读卡器） */
+  ViisanMethodCode["ReadIDCardInfo"] = "ReadIDCardInfo";
+  /** 人脸比对 */
+  ViisanMethodCode["FaceMatch"] = "FaceMatch";
+})(ViisanMethodCode || (ViisanMethodCode = {}));
+/**
+ * 裁切方式枚举
+ * 对应 SetCameraImageInfo 的 cropType 参数
+ */
+var ViisanCropType;
+(function (ViisanCropType) {
+  /** 不裁切 */
+  ViisanCropType[ViisanCropType["None"] = 0] = "None";
+  /** 单图裁切 */
+  ViisanCropType[ViisanCropType["SingleImage"] = 1] = "SingleImage";
+  /** 多图裁切 */
+  ViisanCropType[ViisanCropType["MultiImage"] = 2] = "MultiImage";
+  /** 曲面矫正 */
+  ViisanCropType[ViisanCropType["CurveCorrection"] = 3] = "CurveCorrection";
+  /** 单图桌面裁切（丹徒裁切） */
+  ViisanCropType[ViisanCropType["SingleDesktop"] = 6] = "SingleDesktop";
+  /** 多图桌面裁切 */
+  ViisanCropType[ViisanCropType["MultiDesktop"] = 7] = "MultiDesktop";
+  /** 自定义裁切 */
+  ViisanCropType[ViisanCropType["Custom"] = 9] = "Custom";
+})(ViisanCropType || (ViisanCropType = {}));
+/**
+ * 图像效果枚举
+ * 对应 SetCameraImageInfo 的 imageType 参数
+ */
+var ViisanImageType;
+(function (ViisanImageType) {
+  /** 彩色原色 */
+  ViisanImageType[ViisanImageType["ColorOriginal"] = 0] = "ColorOriginal";
+  /** 灰度图片 */
+  ViisanImageType[ViisanImageType["Grayscale"] = 1] = "Grayscale";
+  /** 黑白文档 */
+  ViisanImageType[ViisanImageType["BlackWhite"] = 2] = "BlackWhite";
+  /** 彩色文档 */
+  ViisanImageType[ViisanImageType["ColorDocument"] = 3] = "ColorDocument";
+  /** 红印文档 */
+  ViisanImageType[ViisanImageType["RedStamp"] = 4] = "RedStamp";
+  /** 蓝印文档 */
+  ViisanImageType[ViisanImageType["BlueStamp"] = 5] = "BlueStamp";
+  /** 彩色照片 */
+  ViisanImageType[ViisanImageType["ColorPhoto"] = 6] = "ColorPhoto";
+  /** 票据增强 */
+  ViisanImageType[ViisanImageType["ReceiptEnhance"] = 7] = "ReceiptEnhance";
+})(ViisanImageType || (ViisanImageType = {}));
+/**
+ * 补边方式枚举
+ * 对应 SetCameraImageInfo 的 fillBorderType 参数
+ */
+var ViisanFillBorderType;
+(function (ViisanFillBorderType) {
+  /** 不填充 */
+  ViisanFillBorderType[ViisanFillBorderType["None"] = 0] = "None";
+  /** 映射填充 */
+  ViisanFillBorderType[ViisanFillBorderType["MapFill"] = 1] = "MapFill";
+  /** 白色填充 */
+  ViisanFillBorderType[ViisanFillBorderType["WhiteFill"] = 2] = "WhiteFill";
+  /** 自动纯色填充 */
+  ViisanFillBorderType[ViisanFillBorderType["AutoColorFill"] = 3] = "AutoColorFill";
+})(ViisanFillBorderType || (ViisanFillBorderType = {}));
+/**
+ * 异物去除枚举
+ * 对应 SetCameraImageInfo 的 removalForeign 参数
+ */
+var ViisanRemovalForeign;
+(function (ViisanRemovalForeign) {
+  /** 无 */
+  ViisanRemovalForeign[ViisanRemovalForeign["None"] = 0] = "None";
+  /** 去除装订孔 */
+  ViisanRemovalForeign[ViisanRemovalForeign["BindingHoles"] = 2] = "BindingHoles";
+})(ViisanRemovalForeign || (ViisanRemovalForeign = {}));
+/**
+ * 旋转方式枚举
+ * 对应 SetCameraImageInfo 的 rotate 参数
+ */
+var ViisanRotateType;
+(function (ViisanRotateType) {
+  /** 不旋转 */
+  ViisanRotateType[ViisanRotateType["None"] = 0] = "None";
+  /** 旋转90度 */
+  ViisanRotateType[ViisanRotateType["Rotate90"] = 90] = "Rotate90";
+  /** 旋转180度 */
+  ViisanRotateType[ViisanRotateType["Rotate180"] = 180] = "Rotate180";
+  /** 旋转270度 */
+  ViisanRotateType[ViisanRotateType["Rotate270"] = 270] = "Rotate270";
+})(ViisanRotateType || (ViisanRotateType = {}));
+/**
+ * 维山（Viisan）高拍仪服务
+ *
+ * 通过 WebSocket 与 CamSDK 本地服务通信，提供高拍仪拍照功能。
+ * 使用方式：
+ *   1. 调用 openCamera() 打开摄像头
+ *   2. 调用 capture() 拍照，获取 base64 图片
+ *   3. 调用 closeCamera() 关闭摄像头
+ *
+ * 默认拍照参数：
+ *   - 裁切方式：单图裁切（cropType=1）
+ *   - 图像效果：彩色原色（imageType=0）
+ *   - 补边方式：不填充（fillBorderType=0）
+ *   - 异物去除：无（removalForeign=0）
+ *   - 旋转角度：不旋转（rotate=0）
+ *   - 水印：不使用
+ */
+class ViisanPluginService {
+  /** WebSocket 连接地址（CamSDK 本地服务默认端口 9000） */
+
+  /** WebSocket 实例 */
+
+  /** 当前请求的 Promise 存储队列 */
+
+  /** 当前打开的设备编号 */
+
+  /** 主摄像头（文档摄像头，funcType=1）设备编号 */
+
+  /** 副摄像头（人像摄像头，funcType=2）设备编号 */
+
+  /** 缓存的设备信息列表 */
+
+  /** 请求 ID 计数器 */
+
+  /** 视频预览帧回调（SDK 持续推送帧时触发） */
+
+  /**
+   * 生成唯一的请求 ID
+   * @returns 当前时间戳作为请求 ID
+   */
+  static generateReqId() {
+    return new Date().getTime() + ++this.reqIdCounter;
+  }
+  /**
+   * 开启 WebSocket 连接
+   * 如果连接已存在且处于 OPEN 或 CONNECTING 状态，直接复用，不再重复创建
+   * @returns 连接成功的 Promise
+   */
+  static startConnect() {
+    // 连接已打开或正在连接中，直接复用，避免重复建立连接
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return Promise.resolve(true);
+    }
+    const ws = new WebSocket(this.webSocketUrl);
+    let resolved;
+    const onConnect = new Promise(resolve => {
+      resolved = resolve;
+    });
+    ws.onopen = () => {
+      resolved(true);
+    };
+    ws.onmessage = event => {
+      this.handleMessage(event);
+    };
+    ws.onclose = () => {
+      this.handleClose();
+    };
+    ws.onerror = () => {
+      this.handleError();
+    };
+    this.ws = ws;
+    return onConnect;
+  }
+  /**
+   * 处理连接错误
+   * 拒绝所有等待中的请求
+   */
+  static handleError() {
+    this.requestStore.forEach(({
+      reject
+    }) => {
+      reject('handleError');
+    });
+    this.requestStore = [];
+    throw Error('统一插件平台维山高拍仪功能加载失败');
+  }
+  /**
+   * 处理连接关闭
+   * 拒绝所有等待中的请求
+   */
+  static handleClose() {
+    this.requestStore.forEach(({
+      reject
+    }) => {
+      reject('close');
+    });
+    this.requestStore = [];
+  }
+  /**
+   * 处理 WebSocket 接收到的消息
+   * 解析 JSON 响应，根据 result 字段判断是否成功
+   * result=0 表示成功，result=9 表示设备使用中（打开摄像头时忽略）
+   *
+   * 视频帧消息（GetCameraVideoBuff 推送）单独路由到 previewFrameCallback，
+   * 不进入 requestStore，避免与命令响应混淆
+   *
+   * @param msg WebSocket 消息事件
+   */
+  static handleMessage(msg) {
+    let data;
+    try {
+      data = JSON.parse(msg.data);
+    } catch (e) {
+      data = {
+        result: -1,
+        errorMsg: '消息解析失败'
+      };
+    }
+    // 视频预览帧：路由到回调，不进入 requestStore
+    if (data.func === ViisanMethodCode.GetCameraVideoBuff && data.result === 0 && data.imgBase64Str) {
+      if (this.previewFrameCallback) {
+        this.previewFrameCallback(data.imgBase64Str);
+      }
+      return;
+    }
+    // result != 0 且 result != 9 时，表示执行出错
+    if (data.result !== 0 && data.result !== 9) {
+      console.warn(`[ViisanPlugin] ${data.func} 执行失败: ${data.errorMsg}`);
+    }
+    // 将响应数据 resolve 给等待中的请求
+    this.requestStore.forEach(({
+      resolve
+    }) => {
+      resolve(data);
+    });
+    this.requestStore = [];
+  }
+  /**
+   * 向 WebSocket 发送 JSON 请求
+   *
+   * @param func 方法名（对应 ViisanMethodCode）
+   * @param params 附加参数（会与 func 和 reqId 合并为 JSON 发送）
+   * @returns 服务端响应的 Promise
+   */
+  static async send(func, params) {
+    await this.startConnect();
+    if (this.ws.readyState !== WebSocket.OPEN) {
+      throw Error('统一插件平台维山高拍仪连接未就绪');
+    }
+    const reqId = this.generateReqId();
+    const cmd = {
+      func,
+      reqId,
+      ...params
+    };
+    this.ws.send(JSON.stringify(cmd));
+    return new Promise((resolve, reject) => {
+      this.requestStore.push({
+        resolve,
+        reject
+      });
+    });
+  }
+  /**
+   * 获取摄像头设备信息
+   * 返回连接的所有高拍仪设备列表，同时缓存设备信息并识别主/副摄像头
+   *
+   * 设备功能类型（funcType）：
+   *   1 - 文档摄像头（主摄像头，用于扫描/拍照）
+   *   2 - 人像摄像头（副摄像头，用于人脸比对）
+   *
+   * @returns 设备信息数组
+   */
+  static async getCameraInfo() {
+    const res = await this.send(ViisanMethodCode.GetCameraInfo);
+    if (res.result !== 0 && res.result !== 9) {
+      throw Error('获取摄像头设备信息失败：' + (res.errorMsg || ''));
+    }
+    const devInfos = res.devInfo || [];
+    // 缓存设备信息
+    this.cachedDevInfos = devInfos;
+    // 识别主摄像头（funcType=1，文档摄像头）和副摄像头（funcType=2，人像摄像头）
+    this.mainCameraDevNum = -1;
+    this.secondaryCameraDevNum = -1;
+    for (const dev of devInfos) {
+      if (dev.funcType === 1 && this.mainCameraDevNum < 0) {
+        this.mainCameraDevNum = dev.id;
+      } else if (dev.funcType === 2 && this.secondaryCameraDevNum < 0) {
+        this.secondaryCameraDevNum = dev.id;
+      }
+    }
+    // 如果没有明确分类的设备，默认第一个为主摄像头
+    if (this.mainCameraDevNum < 0 && devInfos.length > 0) {
+      this.mainCameraDevNum = devInfos[0].id;
+    }
+    return devInfos;
+  }
+  /**
+   * 确保设备信息已加载
+   * 如果缓存为空，自动调用 getCameraInfo 获取设备列表
+   */
+  static async ensureDevInfo() {
+    if (this.cachedDevInfos.length === 0) {
+      console.log(1111111);
+      await this.getCameraInfo();
+    }
+  }
+  /**
+   * 打开摄像头
+   *
+   * @param devNum 设备编号，默认 0（第一个设备）
+   * @param mediaNum 视频格式编号，默认 0
+   * @param resolutionNum 分辨率编号，默认 0（使用默认分辨率）
+   * @param fps 帧率，默认 5
+   * @returns 打开结果
+   */
+  static async openCamera(devNum = 0, mediaNum = 0, resolutionNum = 0, fps = 5) {
+    const res = await this.send(ViisanMethodCode.OpenCamera, {
+      devNum,
+      mediaNum,
+      resolutionNum,
+      fps // 帧率
+    });
+
+    if (res.result !== 0 && res.result !== 9) {
+      throw Error('打开摄像头失败：' + (res.errorMsg || ''));
+    }
+    this.currentDevNum = devNum;
+    return res;
+  }
+  /**
+   * 关闭摄像头
+   *
+   * @param devNum 设备编号，默认使用当前打开的设备
+   * @returns 关闭结果
+   */
+  static async closeCamera(devNum) {
+    const num = devNum !== undefined ? devNum : this.currentDevNum;
+    if (num < 0) {
+      return; // 没有打开的摄像头，直接返回
+    }
+
+    const res = await this.send(ViisanMethodCode.CloseCamera, {
+      devNum: num
+    });
+    this.currentDevNum = -1;
+    return res;
+  }
+  /**
+   * 开启摄像头（指定主摄像头或副摄像头）
+   * 类似 eloam 的 turnOnTheCamera，自动根据 type 选择对应设备
+   *
+   * @param type 'main' - 主摄像头（文档摄像头，funcType=1）；'vice' - 副摄像头（人像摄像头，funcType=2）
+   */
+  static async turnOnTheCamera(type) {
+    await this.ensureDevInfo();
+    const devNum = type === 'main' ? this.mainCameraDevNum : this.secondaryCameraDevNum;
+    if (devNum < 0) {
+      throw Error(`未找到可用的${type === 'main' ? '主' : '副'}摄像头设备`);
+    }
+    // 如果当前已打开目标摄像头，无需重复操作
+    if (this.currentDevNum === devNum) {
+      return;
+    }
+    // 关闭当前已打开的摄像头（仅在不同设备间切换时）
+    if (this.currentDevNum >= 0) {
+      await this.closeCamera();
+    }
+    await this.openCamera(devNum);
+    // 主摄像头打开后立即设置图像参数（裁边等），预览和拍照都生效
+    if (type === 'main') {
+      await this.setCameraImageInfo({});
+    }
+  }
+  /**
+   * 主摄像头拍照
+   * 自动打开主摄像头（funcType=1 文档摄像头），设置图像参数后拍照
+   * 拍照完成后自动关闭摄像头
+   *
+   * @param options 可选的图像参数配置（裁切、图像效果、补边等）
+   * @returns 拍照结果 base64
+   */
+  static async scanByMainCamera(options) {
+    await this.ensureDevInfo();
+    const devNum = this.mainCameraDevNum >= 0 ? this.mainCameraDevNum : 0;
+    // 如果主摄像头未打开，先打开（不关闭已有连接，复用 WebSocket）
+    if (this.currentDevNum !== devNum) {
+      if (this.currentDevNum >= 0) {
+        await this.closeCamera();
+      }
+      await this.openCamera(devNum);
+    }
+    // 拍照（默认裁边：单图裁切）
+    const result = await this.capture(options);
+    return result.imgBase64;
+  }
+  /**
+   * 副摄像头拍照
+   * 自动打开副摄像头（funcType=2 人像摄像头），拍照后关闭
+   *
+   * @returns 拍照结果 base64
+   */
+  static async scanBySecondaryCamera() {
+    await this.ensureDevInfo();
+    if (this.secondaryCameraDevNum < 0) {
+      throw Error('未找到可用的副摄像头设备');
+    }
+    // 如果副摄像头未打开，先打开
+    if (this.currentDevNum !== this.secondaryCameraDevNum) {
+      if (this.currentDevNum >= 0) {
+        await this.closeCamera();
+      }
+      await this.openCamera(this.secondaryCameraDevNum);
+    }
+    // 副摄像头拍照使用默认参数（不裁切、彩色原色、不填充）
+    const result = await this.capture({
+      cropType: ViisanCropType.None,
+      imageType: ViisanImageType.ColorOriginal,
+      fillBorderType: ViisanFillBorderType.None
+    });
+    return result.imgBase64;
+  }
+  /**
+   * 统一拍照方法（根据类型选择主摄像头或副摄像头）
+   * 与 eloam 的 scanByCamera 用法一致
+   *
+   * @param type 'main' - 主摄像头拍照；'vice' - 副摄像头拍照
+   * @param options 可选的图像参数配置（仅主摄像头拍照时生效）
+   * @returns 拍照结果 base64
+   */
+  static async scanByCamera(type, options) {
+    switch (type) {
+      case 'main':
+        return this.scanByMainCamera(options);
+      case 'vice':
+        return this.scanBySecondaryCamera();
+      default:
+        throw Error('不支持的摄像头类型：' + type);
+    }
+  }
+  /**
+   * 停止摄像头
+   * 与 eloam 的 stopCamera 用法一致
+   *
+   * @param isMain true - 停止主摄像头；false - 停止副摄像头
+   */
+  static async stopCamera(isMain) {
+    const devNum = isMain ? this.mainCameraDevNum : this.secondaryCameraDevNum;
+    if (devNum >= 0) {
+      await this.closeCamera(devNum);
+    }
+  }
+  /**
+   * 设置视频预览帧回调
+   * SDK 在 startVideoPreview 后会持续推送帧数据，每帧通过回调返回
+   *
+   * @param callback 帧数据回调，参数为 base64 图片字符串；传 null 清除回调
+   */
+  static setPreviewFrameCallback(callback) {
+    this.previewFrameCallback = callback;
+  }
+  /**
+   * 开启视频预览流
+   * 调用后 SDK 会持续推送视频帧（通过 onTxtMessage 回调）
+   *
+   * @param devNum 设备编号
+   */
+  static async startVideoPreview(devNum) {
+    const num = devNum !== undefined ? devNum : this.currentDevNum;
+    if (num < 0) {
+      throw Error('没有已打开的摄像头，无法开启预览');
+    }
+    await this.send(ViisanMethodCode.GetCameraVideoBuff, {
+      devNum: num,
+      enable: true
+    });
+  }
+  /**
+   * 停止视频预览流
+   *
+   * @param devNum 设备编号
+   */
+  static async stopVideoPreview(devNum) {
+    const num = devNum !== undefined ? devNum : this.currentDevNum;
+    if (num < 0) {
+      return;
+    }
+    await this.send(ViisanMethodCode.GetCameraVideoBuff, {
+      devNum: num,
+      enable: false
+    });
+  }
+  /**
+   * 设置图像算法参数
+   * 在拍照前调用，配置裁切方式、图像效果、补边等参数
+   *
+   * @param options 图像参数配置
+   * @param options.cropType 裁切方式，默认 1（单图裁切）
+   * @param options.imageType 图像效果，默认 0（彩色原色）
+   * @param options.fillBorderType 补边方式，默认 0（不填充）
+   * @param options.removalForeign 异物去除，默认 0（无）
+   * @param options.rotate 旋转角度，默认 0（不旋转）
+   * @param options.dpi 照片 DPI，默认 0（使用设备默认值）
+   * @returns 设置结果
+   */
+  static async setCameraImageInfo(options = {}) {
+    const devNum = this.currentDevNum >= 0 ? this.currentDevNum : 0;
+    const res = await this.send(ViisanMethodCode.SetCameraImageInfo, {
+      devNum,
+      // 裁切方式，默认单图裁切（裁边）
+      cropType: options.cropType ?? ViisanCropType.SingleImage,
+      // 图像效果，默认彩色原色
+      imageType: options.imageType ?? ViisanImageType.ColorOriginal,
+      // 补边方式，默认不填充
+      fillBorderType: options.fillBorderType ?? ViisanFillBorderType.None,
+      // 异物去除，默认无
+      removalForeign: options.removalForeign ?? ViisanRemovalForeign.None,
+      // 旋转角度，默认不旋转
+      rotate: options.rotate ?? ViisanRotateType.None,
+      // 照片 DPI，0 表示默认
+      dpi: options.dpi ?? 0,
+      // OCR 语言 ID，不使用 OCR 时传 0
+      textOrientationLangId: 0
+    });
+    return res;
+  }
+  /**
+   * 高拍仪拍照
+   * 先设置图像参数，再执行拍照，返回 base64 格式的图片数据
+   *
+   * 默认参数：
+   *   - 裁切方式：单图裁切（cropType=1）
+   *   - 图像效果：彩色原色（imageType=0）
+   *   - 补边方式：不填充（fillBorderType=0）
+   *   - 不使用水印
+   *
+   * @param options 可选的图像参数配置，不传则使用默认参数
+   * @returns 拍照结果，包含 imgBase64（图片 base64 数据）和 mime（图片类型）
+   */
+  static async capture(options) {
+    const devNum = this.currentDevNum >= 0 ? this.currentDevNum : 0;
+    // 第一步：设置图像算法参数（裁切、图像效果、补边等）
+    await this.setCameraImageInfo(options || {});
+    // 第二步：执行拍照，mode='base64' 表示返回 base64 编码的图片
+    const res = await this.send(ViisanMethodCode.CameraCapture, {
+      devNum,
+      mode: 'base64' // 返回模式：base64 编码
+      // 不使用水印，不传 watermark 参数
+    });
+
+    if (res.result !== 0) {
+      throw Error('拍照失败：' + (res.errorMsg || ''));
+    }
+    // 拍照成功，返回第一张图片的 base64 数据和 mime 类型
+    // imgBase64 是数组，一般拍照返回一张图片
+    return {
+      imgBase64: res.imgBase64 && res.imgBase64[0] || '',
+      mime: res.mime || 'image/jpeg'
+    };
+  }
+  /**
+   * 便捷方法：打开摄像头并拍照
+   * 自动完成 打开摄像头 → 设置图像参数 → 拍照 的完整流程
+   *
+   * @param devNum 设备编号，默认 0
+   * @param options 可选的图像参数配置
+   * @returns 拍照结果
+   */
+  static async openAndCapture(devNum = 0, options) {
+    // 打开摄像头
+    await this.openCamera(devNum);
+    // 拍照
+    const result = await this.capture(options);
+    return result;
+  }
+  /**
+   * 读取二代身份证信息
+   * 通过高拍仪内置读卡器或外接身份证读卡器读取身份证信息及头像照片
+   *
+   * 请求参数：
+   *   - func: "ReadIDCardInfo"
+   *   - idType: 0（0 表示读取二代身份证）
+   *
+   * 返回 cardInfo 包含字段：
+   *   - name: 姓名
+   *   - folk: 民族
+   *   - gender: 性别（男/女）
+   *   - birth: 生日（格式 yyyyMMdd）
+   *   - id: 身份证号码
+   *   - address: 住址
+   *   - issue: 签发机关
+   *   - startDate: 有效期开始（格式 yyyyMMdd）
+   *   - endDate: 有效期结束（格式 yyyyMMdd 或 "长期"）
+   *   - imageBase64: 头像照片 base64
+   *   - mime: 照片 mime 类型
+   *   - fingerFeature: 指纹信息（可选）
+   *
+   * @returns 身份证信息，格式与其他高拍仪插件统一（info + headImage）
+   */
+  static async idCardRead() {
+    // 如果当前有摄像头打开，先关闭（读卡前需要释放设备）
+    if (this.currentDevNum >= 0) {
+      await this.closeCamera();
+    }
+    // 发送读卡请求
+    // idType=0 表示读取二代身份证
+    const res = await this.send(ViisanMethodCode.ReadIDCardInfo, {
+      idType: 0
+    });
+    if (res.result !== 0) {
+      throw Error('读取二代身份证失败：' + (res.errorMsg || ''));
+    }
+    const ci = res.cardInfo;
+    if (!ci) {
+      throw Error('未匹配可用的维山身份证读卡器');
+    }
+    // 解析身份证信息
+    let name = (ci.name || '').trim();
+    let sex = ci.gender || '';
+    let nation = ci.folk || '';
+    let birthday = ci.birth || '';
+    let address = ci.address || '';
+    let cardId = ci.id || '';
+    let police = ci.issue || '';
+    let validStart = ci.startDate || '';
+    let validEnd = ci.endDate || '';
+    let headImage = ci.imageBase64 || '';
+    // 默认按普通身份证处理
+    let cardType = '1';
+    let chineseName = '';
+    let englishName = '';
+    let nationality = '中国';
+    // 判断是否为外国人永居证（通过身份证号判断）
+    const isForeigners = IdCardCommonUtils.isForeignersIdCard(cardId);
+    if (isForeigners) {
+      cardType = '9'; // 永居证
+      chineseName = name;
+      englishName = name;
+      police = '中华人民共和国国家移民管理局'; // 永居证签发机关默认值
+      nationality = nation; // 永居证民族字段实际存放的是国籍
+      // nation 置空，永居证不读取民族
+    }
+
+    const IDCardData = {
+      info: {
+        cardType,
+        nationality,
+        name: name,
+        chineseName,
+        englishName,
+        sex,
+        birthday,
+        address,
+        cardId,
+        nation: isForeigners ? '' : nation,
+        police,
+        validStart,
+        validEnd
+      },
+      headImage
+    };
+    console.log('[ViisanPlugin] 读取二代身份证结果 ==>', IDCardData);
+    return IDCardData;
+  }
+  /**
+   * 关闭 WebSocket 连接
+   * 在不再需要使用高拍仪时调用，释放资源
+   */
+  static disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.requestStore = [];
+    this.currentDevNum = -1;
+    this.mainCameraDevNum = -1;
+    this.secondaryCameraDevNum = -1;
+    this.cachedDevInfos = [];
+    this.previewFrameCallback = null;
+  }
+}
+_defineProperty(ViisanPluginService, "webSocketUrl", 'ws://127.0.0.1:9000');
+_defineProperty(ViisanPluginService, "ws", void 0);
+_defineProperty(ViisanPluginService, "requestStore", []);
+_defineProperty(ViisanPluginService, "currentDevNum", -1);
+_defineProperty(ViisanPluginService, "mainCameraDevNum", -1);
+_defineProperty(ViisanPluginService, "secondaryCameraDevNum", -1);
+_defineProperty(ViisanPluginService, "cachedDevInfos", []);
+_defineProperty(ViisanPluginService, "reqIdCounter", 0);
+_defineProperty(ViisanPluginService, "previewFrameCallback", null);
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-85.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=script&lang=js&
 
 
@@ -85275,12 +86105,13 @@ _defineProperty(HanWangPluginService, "_isLinux", String(navigator.platform).ind
 
 
 
+
 const BEGIN_DATA = 'data:image/jpg;base64,';
 /* harmony default export */ var scanner_camera_componentvue_type_script_lang_js_ = ({
   name: "scanner-camera-component",
   props: {
-    /**
-     * 高拍仪型号 0-捷宇；3：方正高影仪；4：紫图速拍仪；5-良田；6-国产一体机；7-赞采；8-汉王高拍仪；9-本机摄像头拍照
+    /**
+     * 高拍仪型号 0-捷宇；3：方正高影仪；4：紫图速拍仪；5-良田；6-国产一体机；7-赞采；8-汉王高拍仪；9-本机摄像头拍照；10-维山高拍仪
      */
     machineType: {
       //
@@ -85390,6 +86221,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
       this.defaultVideoStream.getTracks().forEach(track => track.stop());
       this.defaultVideoStream = null;
     }
+    // 清理维山高拍仪预览轮询
+    this.stopViisanPreview();
   },
   methods: {
     // 浏览器标签页关闭
@@ -85414,18 +86247,23 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           // 汉王
           await HanWangPluginService.stopCamera();
           break;
+        case 10:
+          // 维山
+          this.stopViisanPreview();
+          await ViisanPluginService.stopCamera(this.camera === 0);
+          break;
       }
     },
-    /**
-     * 切换扫描、拍照
-     * @param val
+    /**
+     * 切换扫描、拍照
+     * @param val
      */
     selectChange(val) {
       let handleName = val === 1 ? 'start-vice' : 'start-main';
       this.handleAction(handleName);
     },
-    /**
-     * 拍照
+    /**
+     * 拍照
      */
     async takePictures() {
       switch (this.machineType) {
@@ -85442,7 +86280,9 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           }
         case 4:
           {
-            let res = await UdsPluginSocketService.scanByCamera();
+            // 紫图速拍仪
+            // 按当前选择的摄像头拍照：0-主头(文档)，1-副头(照片)
+            let res = this.camera === 1 ? await UdsPluginSocketService.scanBySubCamera() : await UdsPluginSocketService.scanByCamera();
             this.$emit('send-scanner-result', `${BEGIN_DATA}${res}`);
             break;
           }
@@ -85480,10 +86320,23 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
             this.$emit('send-scanner-result', `${BEGIN_DATA}${res}`);
             break;
           }
+        case 10:
+          {
+            // 维山高拍仪
+            let type = this.camera === 0 ? 'main' : 'vice';
+            // 帧消息已通过 callback 路由，不会干扰拍照响应，无需停止预览
+            let res = await ViisanPluginService.scanByCamera(type);
+            if (res) {
+              this.$emit('send-scanner-result', `${BEGIN_DATA}${res}`);
+            } else {
+              this.$message.error('拍照出错，请检查设备是否连接成功');
+            }
+            break;
+          }
       }
     },
-    /**
-     * 主摄像头
+    /**
+     * 主摄像头
      */
     async handleStartMain() {
       switch (this.machineType) {
@@ -85525,6 +86378,14 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           // 汉王高拍仪(主)
           await HanWangPluginService.turnOnTheCamera('main');
           break;
+        case 10:
+          // 维山高拍仪(主)
+          // 先停止之前的预览轮询
+          this.stopViisanPreview();
+          await ViisanPluginService.turnOnTheCamera('main');
+          // 开启视频预览帧轮询（每 300ms 获取一帧）
+          this.startViisanPreview();
+          break;
       }
     },
     async getEloamFrame() {
@@ -85536,9 +86397,28 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
       if (res.data.img == "") return;
       this.scannerVideoSrc = `${BEGIN_DATA}${res.data.img}`;
     },
-    /**
-     * 启动电脑默认摄像头
-     * @param type 'main' 主摄像头, 'vice' 副摄像头
+    /**
+     * 维山高拍仪 - 开启视频预览
+     * 调用一次 startVideoPreview，SDK 会持续推送帧数据到回调
+     */
+    startViisanPreview() {
+      // 设置帧回调
+      ViisanPluginService.setPreviewFrameCallback(imgBase64Str => {
+        this.scannerVideoSrc = `${BEGIN_DATA}${imgBase64Str}`;
+      });
+      // 启动预览流（只调用一次）
+      ViisanPluginService.startVideoPreview();
+    },
+    /**
+     * 维山高拍仪 - 停止视频预览
+     */
+    stopViisanPreview() {
+      ViisanPluginService.setPreviewFrameCallback(null);
+      ViisanPluginService.stopVideoPreview();
+    },
+    /**
+     * 启动电脑默认摄像头
+     * @param type 'main' 主摄像头, 'vice' 副摄像头
      */
     async startDefaultCamera(type) {
       await new Promise(resolve => {
@@ -85576,8 +86456,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
         this.loadSuccess = false;
       }
     },
-    /**
-     * 使用默认摄像头拍照
+    /**
+     * 使用默认摄像头拍照
      */
     takeDefaultCameraPicture() {
       if (!this.defaultVideoStream) {
@@ -85595,8 +86475,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
       const dataUrl = canvas.toDataURL('image/jpeg');
       this.$emit('send-scanner-result', dataUrl);
     },
-    /**
-     * 副摄像头
+    /**
+     * 副摄像头
      */
     async handleStartVice() {
       switch (this.machineType) {
@@ -85609,8 +86489,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           await FounderPluginSocketService.turnOnTheCamera();
           break;
         case 4:
-          // 紫图速拍仪
-          await UdsPluginSocketService.turnOnTheCamera();
+          // 紫图速拍仪（副头）
+          await UdsPluginSocketService.turnOnSubCamera();
           break;
         case 5:
           // 良田
@@ -85634,6 +86514,12 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           // 汉王高拍仪 副
           await HanWangPluginService.turnOnTheCamera('vice');
           break;
+        case 10:
+          // 维山高拍仪(副)
+          this.stopViisanPreview();
+          await ViisanPluginService.turnOnTheCamera('vice');
+          this.startViisanPreview();
+          break;
       }
     },
     async takePictureMerge(type) {
@@ -85715,9 +86601,9 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           break;
       }
     },
-    /**
-     * 处理旋转命令
-     * @param command 旋转命令：rotate-left(左旋90°), rotate-right(右旋90°), rotate-180(旋转180°)
+    /**
+     * 处理旋转命令
+     * @param command 旋转命令：rotate-left(左旋90°), rotate-right(右旋90°), rotate-180(旋转180°)
      */
     handleRotateCommand(command) {
       if (this.machineType !== 5) return; // 仅良田支持旋转
@@ -85767,8 +86653,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
           break;
       }
     },
-    /**
-     * 切换框选拍照模式
+    /**
+     * 切换框选拍照模式
      */
     async toggleSelectAreaMode() {
       if (this.machineType !== 5) {
@@ -85785,8 +86671,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
         this.isSelecting = false;
       }
     },
-    /**
-     * 校准缩放比例 - 完全参考 liangtian.html 的实现
+    /**
+     * 校准缩放比例 - 完全参考 liangtian.html 的实现
      */
     async calibrateZoomScale() {
       try {
@@ -85824,8 +86710,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
         this.$message.error('坐标校准失败，请重试');
       }
     },
-    /**
-     * 鼠标按下 - 开始框选
+    /**
+     * 鼠标按下 - 开始框选
      */
     handleMouseDown(e) {
       if (!this.isSelectAreaMode || this.machineType !== 5) return;
@@ -85836,8 +86722,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
       };
       e.preventDefault();
     },
-    /**
-     * 鼠标移动 - 更新框选框
+    /**
+     * 鼠标移动 - 更新框选框
      */
     handleMouseMove(e) {
       if (!this.isSelectAreaMode || !this.isSelecting) return;
@@ -85866,8 +86752,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
       };
       e.preventDefault();
     },
-    /**
-     * 鼠标松开 - 完成框选并拍照
+    /**
+     * 鼠标松开 - 完成框选并拍照
      */
     async handleMouseUp(e) {
       if (!this.isSelectAreaMode || !this.isSelecting) return;
@@ -85937,8 +86823,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
       this.selectBoxStyle = {};
       e.preventDefault();
     },
-    /**
-     * 鼠标离开 - 取消框选
+    /**
+     * 鼠标离开 - 取消框选
      */
     handleMouseLeave() {
       if (this.isSelectAreaMode && this.isSelecting) {
@@ -85950,10 +86836,10 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
 });
 ;// CONCATENATED MODULE: ./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=script&lang=js&
  /* harmony default export */ var component_scanner_camera_componentvue_type_script_lang_js_ = (scanner_camera_componentvue_type_script_lang_js_); 
-;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-67.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-67.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-67.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-67.use[3]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=style&index=0&id=74fe19f7&prod&lang=scss&
+;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-67.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-67.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-67.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-67.use[3]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=style&index=0&id=1d5723dd&prod&lang=scss&
 // extracted by mini-css-extract-plugin
 
-;// CONCATENATED MODULE: ./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=style&index=0&id=74fe19f7&prod&lang=scss&
+;// CONCATENATED MODULE: ./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue?vue&type=style&index=0&id=1d5723dd&prod&lang=scss&
 
 ;// CONCATENATED MODULE: ./packages/scanner/scanner-camera/src/component/scanner-camera-component.vue
 
@@ -85966,8 +86852,8 @@ const BEGIN_DATA = 'data:image/jpg;base64,';
 
 var scanner_camera_component_component = normalizeComponent(
   component_scanner_camera_componentvue_type_script_lang_js_,
-  scanner_camera_componentvue_type_template_id_74fe19f7_render,
-  scanner_camera_componentvue_type_template_id_74fe19f7_staticRenderFns,
+  scanner_camera_componentvue_type_template_id_1d5723dd_render,
+  scanner_camera_componentvue_type_template_id_1d5723dd_staticRenderFns,
   false,
   null,
   null,
@@ -86117,8 +87003,8 @@ scanner_camera.install = Vue => {
   Vue.component(scanner_camera.name, scanner_camera);
 };
 /* harmony default export */ var scanner_scanner_camera = (scanner_camera);
-;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-85.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[4]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/id-card-reader/id-card-reader-button/src/id-card-reader-button.vue?vue&type=template&id=27efe151&scoped=true&
-var id_card_reader_buttonvue_type_template_id_27efe151_scoped_true_render = function render() {
+;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-85.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[4]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/id-card-reader/id-card-reader-button/src/id-card-reader-button.vue?vue&type=template&id=00babc28&scoped=true&
+var id_card_reader_buttonvue_type_template_id_00babc28_scoped_true_render = function render() {
   var _vm = this,
     _c = _vm._self._c;
   return _c('div', {
@@ -86191,7 +87077,7 @@ var id_card_reader_buttonvue_type_template_id_27efe151_scoped_true_render = func
     }
   })], 2)], 1);
 };
-var id_card_reader_buttonvue_type_template_id_27efe151_scoped_true_staticRenderFns = [];
+var id_card_reader_buttonvue_type_template_id_00babc28_scoped_true_staticRenderFns = [];
 
 ;// CONCATENATED MODULE: ./packages/service/external-plugins/default-plugin-socket.service.ts
 
@@ -89236,6 +90122,8 @@ _defineProperty(JingLunPluginService, "idCardWebSocketUrl", 'http://127.0.0.1:18
 
 
 
+
+
 
 
 const DefaultFilePath = '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';
@@ -89286,7 +90174,7 @@ const DefaultFilePath = 'JVBERi0xLjcNCiW1tbW1DQoxIDAgb2JqDQo8PC9UeXBlL0NhdGFsb2c
       type: Boolean
     },
     /**
-     * 读卡器：0-默认读卡器及精伦读卡器；1-丽水一体机；2-沃斯德人证交互终端；3-中正人脸识别；4-华大读卡器；5-良田；6-捷宇信息交互终端；7-太极云软/Z300；8-华视电子读卡器；9-捷宇高拍仪读卡; 10-国产客户端一体机; 11-出入境读卡设备
+     * 读卡器：0-默认读卡器及精伦读卡器；1-丽水一体机；2-沃斯德人证交互终端；3-中正人脸识别；4-华大读卡器；5-良田；6-捷宇信息交互终端；7-太极云软/Z300；8-华视电子读卡器；9-捷宇高拍仪读卡; 10-国产客户端一体机; 11-出入境读卡设备；12-普天；13-精伦；14-紫图；15-维山
      * 人脸识别：0-默认人脸识别（拍照）；1-丽水一体机  2-沃斯德人证交互终端；3-中正人脸识别；5-良田；6-捷宇信息交互终端；10-国产客户端一体机
      * 读取社保卡：2-沃斯德人证交互终端；4-华大读卡器；5-国产客户端一体机
      * 签字板：0-有为签字板；1-汉王签字板；2-沃斯德人证交互终端签字；3-捷宇信息交互终端；4-太极云软签字/P-300；5:国产客户端签字板
@@ -89464,6 +90352,16 @@ const DefaultFilePath = 'JVBERi0xLjcNCiW1tbW1DQoxIDAgb2JqDQo8PC9UeXBlL0NhdGFsb2c
           idcardInfo = await JingLunPluginService.idCardRead();
           this.$emit('click', idcardInfo);
           break;
+        case 14:
+          // 紫图
+          idcardInfo = await UdsPluginSocketService.idCardRead();
+          this.$emit('click', idcardInfo);
+          break;
+        case 15:
+          // 维山高拍仪
+          idcardInfo = await ViisanPluginService.idCardRead();
+          this.$emit('click', idcardInfo);
+          break;
         default:
           this.$message.warning('请在首页右上角我的设备中设置读卡器选项！');
           break;
@@ -89743,11 +90641,11 @@ const DefaultFilePath = 'JVBERi0xLjcNCiW1tbW1DQoxIDAgb2JqDQo8PC9UeXBlL0NhdGFsb2c
 ;
 var id_card_reader_button_component = normalizeComponent(
   src_id_card_reader_buttonvue_type_script_lang_js_,
-  id_card_reader_buttonvue_type_template_id_27efe151_scoped_true_render,
-  id_card_reader_buttonvue_type_template_id_27efe151_scoped_true_staticRenderFns,
+  id_card_reader_buttonvue_type_template_id_00babc28_scoped_true_render,
+  id_card_reader_buttonvue_type_template_id_00babc28_scoped_true_staticRenderFns,
   false,
   null,
-  "27efe151",
+  "00babc28",
   null
   
 )