CameraMachine/electron/controller/camera.js

'use strict';
const { Controller } = require('ee-core');
const Log = require('ee-core/log');
const { checkCameraControlCmdExists, closeCameraControlTips, isProcessRunning, onProcessClosed, removeProcessClosedListener, getController } = require('../utils/camera');
const {
  checkCamera,
  liveShow: liveShowApi, liveHide: liveHideApi, setParams, capture, getParams,CMD,captureLive,closeOtherWindow } = require('../api/camera');

const { readConfigFile } = require('../utils/config');

let  isOPen = true
let isSoftwareStarted = false; // 标记相机控制软件是否已经启动

// 缓存相机列表数据，供多窗口共享（CameraLists 中已包含各相机的 ISO 配置）
let cachedCameraList = [];

// 注册进程关闭事件监听器，当软件被关闭时重置标志
onProcessClosed(() => {
  Log.info('相机控制软件已关闭，重置 isSoftwareStarted 标志');
  isSoftwareStarted = false;
});

class CameraController extends Controller {
  constructor(ctx) {
    super(ctx);
  }

  async connect(params = {}) {
    const isMultiCameraMode = params?.isMultiCameraMode ?? false;
    try {
      console.log('==================');
      console.log(readConfigFile());
      console.log('[CAMERA-DEBUG] connect() - isMultiCameraMode:', isMultiCameraMode);

      // 主动检测：即使 isSoftwareStarted 为 true，也要检查进程是否还在运行（兜底机制）
      console.log('[CAMERA-DEBUG] connect() 检查状态 - isSoftwareStarted:', isSoftwareStarted, 'isProcessRunning():', isProcessRunning());
      if (isSoftwareStarted && !isProcessRunning()) {
        console.log('[CAMERA-DEBUG] 检测到 isSoftwareStarted 为 true 但进程已关闭，重置标志');
        Log.info('检测到 isSoftwareStarted 为 true 但进程已关闭，重置标志');
        isSoftwareStarted = false;
      }

      if (!isSoftwareStarted || !isProcessRunning()) {
        console.log('[CAMERA-DEBUG] 准备启动相机控制软件 - isSoftwareStarted:', isSoftwareStarted, 'isProcessRunning:', isProcessRunning());
        const ready = await checkCameraControlCmdExists();
        if (ready && ready.status === -1) {
          return ready;
        }
        isSoftwareStarted = true;
        const startedType = getController().type;
        console.log('[CAMERA-DEBUG] 相机控制软件已启动，类型:', startedType);
        if (startedType === 'digiCamControl') {
          await CMD('All_Minimize');
          await closeCameraControlTips();
          await new Promise(resolve => setTimeout(resolve, 5000));
        } else {
          Log.info('SmartShooter 软件启动完成，等待初始化...');
          await new Promise(resolve => setTimeout(resolve, 10000));
        }
      }

      // 启动完成后再读类型。选目录时可能把 digiCamControl 改成 SmartShooter6
      if (getController().type === 'digiCamControl') {
        console.log('========1==========');
        let res = await getParams('iso').catch(e=>{
          console.log('getParams failed:', e);
          isOPen = false;
          return null;
        });

        if(res === '未将对象引用设置到对象的实例。' || !res){
          return {
            status:-1,
            msg: "相机硬件未连接，请检查相机连接。",
          }
        }

        return {
          status:2,
          msg:res,
        }
      }

      console.log('[CAMERA-DEBUG] SmartShooter 分支 - isSoftwareStarted:', isSoftwareStarted, 'isProcessRunning():', isProcessRunning());
      let res = await checkCamera(isMultiCameraMode).catch(e=>{
        Log.info('checkCamera:'+e);
        isOPen = false;
        return { device_status: -1 };
      })

      if (res?.device_status === -1) {
        return {
          status: -1,
          msg: "相机硬件未连接，请检查相机连接。",
        };
      }

      if(res?.device_status  === 2){
        isOPen = true;
        if (res.CameraLists) {
          cachedCameraList = res.CameraLists;
        }
        return  {
          ...res,
          status:2
        };
      }

      return {
        status:-1,
        msg:"相机未连接，请链接相机。",
      }


    } catch (error) {

      const controlType = getController().type
      let msg = '请安装 Smart Shooter 5 或 Smart Shooter 6'
      if(controlType === 'SmartShooter') msg = '请安装 Smart Shooter 5'
      if(controlType === 'SmartShooter6') msg = '请安装 Smart Shooter 6 或 Smart Shooter 5'
      if(controlType === 'digiCamControl') msg = '请安装digiCamControl软件，并打开digiCamControl软件的web服务，端口为5513'
      return {
        status:-1,
        msg,
      }
    }
  }

  /**
   * 启动预览
   */
  async liveShow(data) {
    try {
      const point_name = data?.point_name || 'A';

      Log.info('liveShow：打开预览'+point_name);
      return await liveShowApi(point_name);
      if(readConfigFile().controlType === 'digiCamControl'){
        await  CMD('All_Minimize')
      }
      return { success: true, point_name };
    } catch (error) {
      console.error('启动预览失败:', error);
      throw error;
    }
  }

  /**
   * 结束预览
   */
  async liveHide(data) {
    try {
      const point_name = data?.point_name || 'A';
      Log.info('liveShow：关闭'+point_name);
      return  await liveHideApi(point_name);
      return { success: true, point_name };
    } catch (error) {
      throw error;
    }
  }

  /**
   * 设置参数
   */
  async setParams(params) {
    try {
      console.log(params);
      await setParams(params);
      return true;
    } catch (error) {
      throw error;
    }
  }

  async takePictures(isLive=true) {
    try {
      if(isLive){

        await captureLive();
      }else{

        await capture();
      }
      return true;
    } catch (error) {
      throw error;
    }
  }

  /**
   * 获取缓存的相机列表（供设置页面等子窗口调用）
   */
  async getCameraList() {
    return {
      CameraLists: cachedCameraList,
      status: cachedCameraList.length > 0 ? 2 : 0,
      msg: cachedCameraList.length > 0 ? '获取成功' : '暂无相机列表'
    };
  }

  // 示例：使用 fetchData 函数进行 HTTP 请求
  async fetchExampleData() {
    const options = {
      hostname: 'example.com',
      port: 443,
      path: '/api/data',
      method: 'GET'
    };

    try {
      const data = await fetchData(options);
      console.log('Fetched data:', data);
      return data;
    } catch (error) {
      console.error('Fetch data failed:', error);
      throw error;
    }
  }
}

CameraController.toString = () => '[class CameraController]';
module.exports = CameraController;