CameraMachine/electron/controller/camera.js

'use strict';
const { Controller } = require('ee-core');
const Log = require('ee-core/log');
const { checkCameraControlCmdExists, closeCameraControlTips, isProcessRunning, onProcessClosed, removeProcessClosedListener } = 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; // 标记相机控制软件是否已经启动

// 缓存相机列表数据，供多窗口共享
let cachedCameraList = [];

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

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

  async connect() {
    try {
      console.log('==================');
      console.log(readConfigFile());

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

      if(readConfigFile().controlType === 'digiCamControl'){
        console.log('========1==========');

        // 主动检测：如果软件未启动或进程已关闭，先启动软件
        if (!isSoftwareStarted || !isProcessRunning()) {
          console.log('启动 digiCamControl 软件...');
          await checkCameraControlCmdExists();
          await CMD('All_Minimize');
          await closeCameraControlTips();
          isSoftwareStarted = true;
          console.log('digiCamControl 软件启动完成，等待初始化...');
          await new Promise(resolve => setTimeout(resolve, 5000)); // 等待软件初始化
        }

        // 获取相机参数
        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,
        }
      }else{
        // SmartShooter 逻辑
        // 主动检测：如果软件未启动或进程已关闭，先启动软件
        if (!isSoftwareStarted || !isProcessRunning()) {
          Log.info('启动 SmartShooter 软件...');
          await checkCameraControlCmdExists();
          isSoftwareStarted = true;
          Log.info('SmartShooter 软件启动完成，等待初始化...');
          await new Promise(resolve => setTimeout(resolve, 10000)); // 等待软件初始化
        }

        // 检查相机状态
        let res = await checkCamera().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) {

      let msg = '请安装SmartShooter5软件'
      if(readConfigFile().controlType === 'digiCamControl') msg = '请安装digiCamControl软件，并打开digiCamControl软件的web服务，端口为5513'
      return {
        status:-1,
        msg,
      }
    }
  }

  /**
   * 启动预览
   */
  async liveShow(data) {
    try {
      const point_name = data?.point_name || 'A';
      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';
      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;