fis_lib_measure/lib/view/mobile_view/mobile_measure_view.dart

import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/define.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/exam_info.dart';
import 'package:fis_measure/process/layout/configuration.dart';
import 'package:fis_measure/process/workspace/measure_controller.dart';
import 'package:fis_measure/process/workspace/measure_data_controller.dart';
import 'package:fis_measure/process/workspace/measure_data_helper.dart';
import 'package:fis_measure/process/workspace/measure_handler.dart';
import 'package:fis_measure/view/gesture/positioned_touch_cursor.dart';
import 'package:fis_measure/view/mobile_view/mobile_measure_main_view.dart';
import 'package:fis_ui/index.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:flutter/services.dart';

import 'widgets/image_pagination.dart';

/// 测量主页面
class MobileMeasureMainPage extends StatefulWidget implements FWidget {
  const MobileMeasureMainPage(
    this.token,
    this.recordCode,
    this.patientCode,
    this.remedicalCode,
    this.remedicalAISelectedInfoCode, {
    this.isCanWriteReport = false,
    this.supportsPortraitMode = true,
    this.onEditReport,
    Key? key,
  }) : super(key: key);

  ///是否支持竖屏
  final bool supportsPortraitMode;
  final String token;
  final String patientCode;
  final String remedicalCode;
  final String recordCode;
  final String? remedicalAISelectedInfoCode;
  final bool isCanWriteReport;
  final void Function()? onEditReport;

  @override
  State<StatefulWidget> createState() => _MobileMeasureMainPageState();
}

class _MobileMeasureMainPageState extends State<MobileMeasureMainPage> {
  /// 数据
  final measureData = Get.find<MeasureDataController>();

  String _remedicalCode = '';

  late final application = Get.find<IApplication>();

  // final mouseState = Get.put<IMouseState>(MouseState());

  /// 页面loadding
  bool loaded = false;

  // /// 图片loadding
  bool isShowLoading = true;

  ///检查图片信息表
  List<ExamImageInfo> examImageInfoList = [];

  late final measureHandler = Get.find<IMeasureHandler>();

  /// 测量控制器
  late MeasureController measureController = Get.put(MeasureController(
    "",
    imagesFetchFunc: (code) async {
      return examImageInfoList;
    },
  ));

  /// 获取测量图片所需的图片组 并且写入控制器中 加载
  void getExamImageInfoList(List<RemedicalInfoDTO> remedicals) async {
    examImageInfoList = remedicals.map((e) {
      final imgInfo = e.terminalImages!;
      final vidUrl = measureData.chooseImageUrl(imgInfo);
      return ExamImageInfo(
        vidUrl,
        imgInfo.previewUrl!,
        remedicalCode: e.remedicalCode,
      );
    }).toList();

    measureController = Get.put(MeasureController(
      "",
      imagesFetchFunc: (code) async {
        return examImageInfoList;
      },
    ));

    await measureController.load();

    final selectedImageIndex = examImageInfoList.indexWhere(
      (element) =>
          element.url == measureData.itemCurrentImage &&
          (element.remedicalCode ?? '') == _remedicalCode,
    );
    if (selectedImageIndex > -1) {
      // 命中当前选择图像   !!!  此时触发图像的加载
      measureController.examInfo.selectedImageIndex = selectedImageIndex;
    }
  }

  void newImageLoading(sender, e) {
    isShowLoading = e;
    setState(() {});
  }

  /// 初始化卡尺样式部分
  Future<void> _initTouchModuel() async {
    Get.put<ITouchPointState>(TouchPointState());
  }

  @override
  void initState() {
    _remedicalCode = widget.remedicalCode;
    _initTouchModuel();
    SystemChrome.setEnabledSystemUIMode(SystemUiMode.immersive);
    SystemChrome.setSystemUIChangeCallback((systemOverlaysAreVisible) async {
      await Future.delayed(const Duration(seconds: 1));
      SystemChrome.setEnabledSystemUIMode(SystemUiMode.immersive);
    });
    measureHandler.onNewImageLoadStatueChanged.addListener(newImageLoading);
    loadLayoutConfig();
    setImageInfo();
    initDefaultMeasureSystemSetting();
    super.initState();
  }

  /// 初始化默认用户设置
  void initDefaultMeasureSystemSetting() {
    final defaultMobileMeasureSystemSetting = MeasureSystemSettingDTO(
      cursorSize: 16,
      shapeCursorSize: 30,
      showResultWindow: true,
      fontSize: 14,
      showCursorLine: true,
      showDepthGuideline: true,
      showBriefAnnotation: true,
      autoSnapDistance: '20',
      minCursorDistance: '20',
      annotationFontSize: 14,
      distanceUnit: Unit.cm,
      areaUnit: Unit.cm2,
      velocityUnit: Unit.cms,
      timeUnit: Unit.msec,
    );
    measureData.measureSystemSetting = defaultMobileMeasureSystemSetting;
  }

  void setImageInfo() {
    measureData.measureInfoData = MeasureInfoData(
      patientCode: widget.patientCode,
      recordCode: widget.recordCode,
      remedicalCode: _remedicalCode,
    );
  }

  /// 加载图像布局配置
  void loadLayoutConfig() async {
    await LayoutConfiguration.ins.loadData();
    setState(() {
      // 加载图像数据
      _initData();
    });
  }

  void onImageLoaded(Object sender, ExamImageInfo? e) async {
    // measureHandler.changeImageLoaded = true;
    if (!mounted) return;
    final currentImage = measureData.remedicalList.firstWhereOrNull(
      (element) =>
          element.terminalImages!.imageUrl == e!.url ||
          element.terminalImages!.originImageUrl == e.url,
    );
    if (currentImage != null) {
      /// 获取图片详细信息
      var remedicalInfo = await MeasureDataHelper.getImageInfo(
        currentImage.remedicalCode ?? '',
        widget.remedicalAISelectedInfoCode,
      );
      if (remedicalInfo != null) {
        measureData.aiResults = remedicalInfo.diagnosisResult ?? '';

        /// ai 良恶性 判断是否有ai
        measureData.diagnosisConclusion = remedicalInfo.diagnosisConclusion;
        if (remedicalInfo.carotidResult != null) {
        } else {}
        try {
          if (e != null) {
            Future.delayed(const Duration(milliseconds: 100), () {
              measureController.playerController.play();
            });
            setState(() {
              loaded = true;
              measureHandler.newImageLoading = false;
            });
          }
        } catch (error) {
          setState(() {
            loaded = true;
            measureHandler.newImageLoading = false;
          });
        }
      }
    }
  }

  @override
  void dispose() {
    if (widget.supportsPortraitMode) {
      SystemChrome.setPreferredOrientations([
        DeviceOrientation.portraitUp,
      ]);
    }
    SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual,
        overlays: SystemUiOverlay.values);
    SystemChrome.setSystemUIChangeCallback((systemOverlaysAreVisible) async {
      // do nothing
    });
    measureHandler.onNewImageLoadStatueChanged.removeListener(newImageLoading);
    super.dispose();
  }

  @override
  FWidget build(BuildContext context) {
    FWidget body;
    if (!loaded) {
      const loadingWidget = FCenter(child: FCircularProgressIndicator());
      body = FRow(
        children: const [
          FExpanded(
            child: loadingWidget,
          ),
        ],
      );
    } else {
      body = QuickFWidget(
        Stack(
          children: [
            Align(
              alignment: Alignment.topLeft,
              child: FRow(
                children: [
                  FExpanded(
                    child: FColumn(
                      mainAxisSize: MainAxisSize.max,
                      children: [
                        FExpanded(
                          child: isShowLoading
                              ? const FCenter(
                                  child: FCircularProgressIndicator(),
                                )
                              : MobileMeasureMainView(
                                  isCanWriteReport: widget.isCanWriteReport,
                                  onEditReport: widget.onEditReport,
                                ),
                        )
                      ],
                    ),
                  ),
                ],
              ),
            ),
            ImagePagination(measureController: measureController),
          ],
        ),
      );
    }

    return FCenter(
      child: FContainer(
        color: Colors.black,
        child: FSafeArea(bottom: false, child: body),
      ),
    );
  }

  void _initData() async {
    List<RemedicalInfoDTO> remedicals = [];
    loaded = false;

    List<RemedicalItemList> value =
        await MeasureDataHelper.getRemedicalList.call(
      widget.patientCode,
      widget.recordCode,
    );

    for (RemedicalItemList remedicalItemList in value) {
      remedicals.addAll(remedicalItemList.remedicalList ?? []);
    }

    /// 获取样式
    // _getMeasureSystemSetting();

    measureData.remedicalList = remedicals;
    RemedicalInfoDTO? remedicalInfo = await MeasureDataHelper.getImageInfo.call(
      _remedicalCode,
      widget.remedicalAISelectedInfoCode,
    );
    if (remedicalInfo != null) {
      measureData.aiResults = remedicalInfo.diagnosisResult ?? '';

      if (remedicalInfo.terminalImages != null) {
        loaded = true;
        final TerminalImageDTO imgInfo = remedicalInfo.terminalImages!;
        measureData.itemCurrentImage = measureData.chooseImageUrl(imgInfo);
        getExamImageInfoList(remedicals);
      }
    }

    measureController.imageLoaded.removeListener(onImageLoaded);
    measureController.imageLoaded.addListener(onImageLoaded);
  }
}