rtu_linux_services/camera-capture.service/rpc_handler.go

package main

import (
	"context"
	"encoding/json"
	"strconv"
	"strings"
	"sync"
	"time"

	"hnyfkj.com.cn/rtu/linux/baseapp"
	"hnyfkj.com.cn/rtu/linux/camera"
	"hnyfkj.com.cn/rtu/linux/dh_takephoto"
	"hnyfkj.com.cn/rtu/linux/hk_takephoto"
	"hnyfkj.com.cn/rtu/linux/utils/jsonrpc2"
)

var cameraMutex sync.Mutex

func getGigeCameraPower(ctx context.Context, req *jsonrpc2.Request) *jsonrpc2.Response {
	on, err := camera.GetGigeCameraPowerCtrl()
	if err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInternal, err.Error())
	}

	return jsonrpc2.BuildResponse(req, map[string]string{
		"enable": strconv.FormatBool(on),
	}, nil)
}

func setGigeCameraPower(ctx context.Context, req *jsonrpc2.Request) *jsonrpc2.Response {
	var params map[string]string
	if err := json.Unmarshal(req.Params, &params); err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, err.Error())
	}

	enable, ok := params["enable"]
	if !ok || enable == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'enable' parameter")
	}

	var on bool
	switch {
	case strings.EqualFold(enable, "true"), enable == "1":
		on = true
	case strings.EqualFold(enable, "false"), enable == "0":
		on = false
	default:
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "invalid 'enable' value")
	}

	if err := camera.PowerOnGigeCamera(on); err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInternal, err.Error())
	}

	return jsonrpc2.BuildResponse(req, "success", nil)
}

func checkGigeCamera(ctx context.Context, req *jsonrpc2.Request) *jsonrpc2.Response {
	var params map[string]string
	if err := json.Unmarshal(req.Params, &params); err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, err.Error())
	}

	ip, ok := params["ip"]
	if !ok || ip == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'ip' parameter")
	}

	prefix, ok := params["prefix"]
	if !ok || prefix == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'prefix' parameter")
	}

	gigeAddrCIDR := ip + "/" + prefix
	equal, err := camera.CidrEqualSemantic(eth1AddrCIDR, gigeAddrCIDR)
	if err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, err.Error())
	}

	if !equal {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "gige camera ip not in network")
	}

	if err := camera.PingOnce(ip, 1); err != nil {
		return jsonrpc2.BuildError(req, -32001, err.Error())
	}

	return jsonrpc2.BuildResponse(req, "success", nil)
}

func getSupportedCameraCount(ctx context.Context, req *jsonrpc2.Request) *jsonrpc2.Response {
	var params map[string]string
	if err := json.Unmarshal(req.Params, &params); err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, err.Error())
	}

	cameraType, ok := params["type"]
	if !ok || cameraType == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'type' parameter")
	}

	var count int
	cameraMutex.Lock()
	defer cameraMutex.Unlock()

	switch strings.ToLower(cameraType) {
	case "all":
		count = camera.GetSupportedCameraCount()
	case "hk":
		count = hk_takephoto.GetHKCameraCount()
	case "dh":
		count = dh_takephoto.GetDHCameraCount()
	default:
		return jsonrpc2.BuildError(req, -32001, "unsupported camera type")
	}

	return jsonrpc2.BuildResponse(req, strconv.Itoa(count), nil)
}

func setWaitAEDoneForTakePhoto(ctx context.Context, req *jsonrpc2.Request) *jsonrpc2.Response {
	var params map[string]string
	if err := json.Unmarshal(req.Params, &params); err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, err.Error())
	}

	waitAE, ok := params["waitAE"]
	if !ok || waitAE == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'waitAE' parameter")
	}

	switch waitAE {
	case "0":
		camera.SetWaitAEDoneForTakePhoto(0)
	case "1":
		camera.SetWaitAEDoneForTakePhoto(1)
	default:
		return jsonrpc2.BuildError(req, -32001, "invalid 'waitAE' value")
	}

	return jsonrpc2.BuildResponse(req, "success", nil)
}

func takePhoto(ctx context.Context, req *jsonrpc2.Request) *jsonrpc2.Response {
	var params map[string]string
	if err := json.Unmarshal(req.Params, &params); err != nil {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, err.Error())
	}

	format, ok := params["format"]
	if !ok || format == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'format' parameter")
	}

	outFilename, ok := params["outFilename"]
	if !ok || outFilename == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'outFilename' parameter")
	}

	timeoutMs, ok := params["timeoutMs"]
	if !ok || timeoutMs == "" {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "missing or empty 'timeoutMs' parameter")
	}

	if !strings.EqualFold(format, "jpg") {
		return jsonrpc2.BuildError(req, jsonrpc2.ErrInvalidParams, "unsupported format")
	}

	timeout, err := strconv.Atoi(timeoutMs)
	if err != nil || timeout <= 0 {
		timeout = 300
	}

	cameraMutex.Lock()
	defer cameraMutex.Unlock()

	baseapp.Logger.Infof("开始拍照, 请稍微...")
	var resp *jsonrpc2.Response

	start := time.Now()
	imgMark, err := camera.TakePhoto(
		camera.IMG_TYPE_JPG,
		outFilename,
		timeout,
	)
	elapsed := time.Since(start).Milliseconds()

	if err != nil {
		resp = jsonrpc2.BuildError(req, -32001, err.Error())
		baseapp.Logger.Errorf("拍照时发生错误: %v, 用时: %dms, 请修复所有问题后重试!!", err, elapsed)
	} else {
		resp = jsonrpc2.BuildResponse(req, map[string]any{
			"status": "success",
			"mark":   imgMark,
		}, nil)
		baseapp.Logger.Infof("拍照结束, 输出: \"%s\", 用时: %dms, 拍照信息: %+v", outFilename, elapsed, imgMark)
	}

	return resp
}