CameraMachine/electron/controller/camera.js

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

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

let  isOPen = true
let isSoftwareStarted = false; // 标记相机控制软件是否已经启动
class CameraController extends Controller {
  constructor(ctx) {
    super(ctx);
  }

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

        // 首先尝试获取相机参数
        let res = await getParams('iso').catch(e=>{
          console.log('getParams failed:', e);
          isOPen = false;
          return null;
        });

        if(res === '未将对象引用设置到对象的实例。' || !res){
          // 相机未连接，检查是否需要启动软件
          if (!isSoftwareStarted) {
            console.log('启动 digiCamControl 软件...');
            await checkCameraControlCmdExists();
            await CMD('All_Minimize');
            await closeCameraControlTips();
            isSoftwareStarted = true;
            console.log('digiCamControl 软件启动完成，等待初始化...');
            await new Promise(resolve => setTimeout(resolve, 5000)); // 等待软件初始化

            // 软件启动后再次检查相机状态
            res = await getParams('iso').catch(e=>{
              console.log('软件启动后检查相机失败:', e);
              return null;
            });
          }

          // 如果仍然失败，返回错误
          if(res === '未将对象引用设置到对象的实例。' || !res) {
            return {
              status:-1,
              msg: isSoftwareStarted ? "相机硬件未连接，请检查相机连接。" : "相机控制软件启动失败。",
            }
          }
        }

        return {
          status:2,
          msg:res,
        }
      }else{
        // SmartShooter 逻辑
        let res = await checkCamera().catch(e=>{
          Log.info('checkCamera:'+e);
          isOPen = false;
        })

        if(res?.device_status  === -1 ){
          // 相机未连接，检查是否需要启动软件
          if (!isSoftwareStarted) {
            Log.info('启动 SmartShooter 软件...');
            await checkCameraControlCmdExists();
            isSoftwareStarted = true;
            Log.info('SmartShooter 软件启动完成，等待初始化...');
            await new Promise(resolve => setTimeout(resolve, 10000)); // 等待软件初始化

            // 软件启动后再次检查相机状态
            res = await checkCamera().catch(e=>{
              Log.info('软件启动后检查相机失败:'+e);
            });
          }

          // 无论是否启动了软件，如果相机还是未连接，返回相应状态
          if (res?.device_status === -1) {
            return {
              status: -1,
              msg: isSoftwareStarted ? "相机硬件未连接，请检查相机连接。" : "相机控制软件启动失败。",
            };
          }
        }

        if(res?.device_status  === 2){
          isOPen = true;
          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() {
    try {
      await liveShow();
      if(readConfigFile().controlType === 'digiCamControl'){
        await  CMD('All_Minimize')
      }
      return true;
    } catch (error) {
      console.error('eeee启动直播失败:', error);
      throw error;
    }
  }

  /**
   * 结束预览
   */
  async liveHide() {
    try {
      await liveHide();
      return true;
    } 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;
    }
  }

  // 示例：使用 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;