OpenDlpFile/manager/OpeningDialogManager.ets

/*
 * Copyright (c) 2025 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import Constants from '../../common/constant';
import { HiLog } from '../../common/HiLog';
import { common, Want } from '@kit.AbilityKit';
import ViewAbilityService from '../../rpc/ViewAbility/service/ViewAbilityService';
import { DecryptState, OpenDlpFileManager } from './OpenDlpFileManager';
import { FileParseType } from '../../bean/data/FileParseType';
import OpenDlpFileData from '../data/OpenDlpFileData';
import FileUtils from '../../common/FileUtils/FileUtils';
import ErrorManager from '../handler/ErrorHandler';
import { emitter } from '@kit.BasicServicesKit';
import StartSandboxHandler from '../handler/StartSandboxHandler';

const TAG = 'OpeningDialogManager';

interface DecryptingState {
  uri: string,
  dialogTimeout: boolean, // 弹框是否超过250ms，拉弹框之前状态设置未false，超时回调设置为true
  needStartAbility: boolean, // 弹框超时后，是否需要拉沙箱
  hasDecrypted: boolean, // 用于判断是否是用户主动取消“正在打开弹框”场景
  needShowDialog: boolean, // 用于判断是否需要“正在打开”弹框
  isZip: boolean, // 用于zip格式，用户取消“正在打开”弹框判断
}

export default class OpeningDialogManager {
  private static instance: OpeningDialogManager;
  // 是否正在弹框
  private _showDialogState: boolean = false;
  // SEA拉起UEA后，是否注册回调
  private _hasCallback: boolean = false;
  // 是否正在处理弹框逻辑
  private _isChargeDecrypting: boolean = false;
  private _decryptingMap: Map<string, DecryptingState>;
  private _isTerminalSelf: boolean = false;
  private _isWaitingShowToast: boolean = false;
  private checkShowDialogStateEvent = async () => {
    HiLog.info(TAG, 'receive CHECK_SHOW_DIALOG_STATE');
    this.checkShowDialogState();
  };

  private constructor() {
    this._decryptingMap = new Map<string, DecryptingState>();
    emitter.on(Constants.CHECK_SHOW_DIALOG_STATE, this.checkShowDialogStateEvent);
  }

  public unRegisterEmitEvent() {
    HiLog.debug(TAG, 'unRegisterEmitEvent');
    emitter.off(Constants.CHECK_SHOW_DIALOG_STATE, this.checkShowDialogStateEvent);
  }

  private printAllDecryptingMap(): void {
    HiLog.debug(TAG, `printAllDecryptingMap ${this._decryptingMap.size}`);
    this._decryptingMap.forEach((value, key) => {
      HiLog.debug(TAG, `key ${FileUtils.getFileNameByUri(key)}, uri ${FileUtils.getFileNameByUri(value.uri)},
      dialogTimeout ${value.dialogTimeout}, needStartAbility ${value.needStartAbility},
      hasDecrypted ${value.hasDecrypted}, needShowDialog ${value.needShowDialog}, isZip ${value.isZip}`);
    });
  }

  static getInstance(): OpeningDialogManager {
    if (!OpeningDialogManager.instance) {
      OpeningDialogManager.instance = new OpeningDialogManager();
    }
    return OpeningDialogManager.instance;
  }

  public setIsWaitingShowToast(value: boolean) {
    this._isWaitingShowToast = value;
  }

  public getIsWaitingShowToast(): boolean {
    return this._isWaitingShowToast;
  }

  public getShowDialogState(): boolean {
    HiLog.debug(TAG, `getShowDialogState ${this._showDialogState}`);
    return this._showDialogState;
  }

  public getHasCallback(): boolean {
    HiLog.debug(TAG, `getHasCallback ${this._hasCallback}`);
    return this._hasCallback;
  }

  public setIsTerminalSelf(value: boolean) {
    HiLog.debug(TAG, `setIsTerminalSelf ${value}`);
    this._isTerminalSelf = value;
  }

  public getIsTerminalSelf(): boolean {
    HiLog.debug(TAG, `getIsTerminalSelf ${this._isTerminalSelf}`);
    return this._isTerminalSelf;
  }

  public getIsDecryptingByRequestId(requestId: string): boolean {
    this.printAllDecryptingMap();
    const isDecrypting = this._decryptingMap.has(requestId);
    HiLog.info(TAG, `getIsDecryptingByRequestId requestId ${requestId} isDecrypting ${isDecrypting}`);
    return isDecrypting;
  }

  public getIsDecrypting(): boolean {
    this.printAllDecryptingMap();
    const isDecrypting = this._decryptingMap.size > 0;
    HiLog.info(TAG, `getIsDecrypting isDecrypting ${isDecrypting}`);
    return isDecrypting;
  }

  public setIsChargeDecrypting(value: boolean) {
    HiLog.info(TAG, `setIsChargeDecrypting ${value}`);
    this._isChargeDecrypting = value;
  }

  public getIsChargeDecrypting(): boolean {
    HiLog.info(TAG, `getIsChargeDecrypting ${this._isChargeDecrypting}`);
    return this._isChargeDecrypting;
  }

  public deleteRequestId(requestId: string) {
    this.printAllDecryptingMap();
    HiLog.info(TAG, `deleteRequestId requestId ${requestId}`);
    this._decryptingMap.delete(requestId);
  }

  // 判断是否需要show toast，这次不需要就等timeout的回调
  public getCanShowToast(): boolean {
    this.printAllDecryptingMap();
    const requestId = this.getDecryptingRequestIdByToast();
    if (!requestId) {
      HiLog.error(TAG, 'no getDecryptingRequestIdByToast');
      return true;
    }
    const decryptingState = this._decryptingMap.get(requestId);
    const dialogTimeout = decryptingState?.dialogTimeout ?? true;
    const needShowDialog = decryptingState?.needShowDialog ?? true;
    HiLog.info(TAG, `getCanShowToast dialogTimeout ${dialogTimeout} needShowDialog ${needShowDialog}
    showDialogState ${this._showDialogState}`);
    if (!needShowDialog || dialogTimeout) {
      return true;
    }
    if (!dialogTimeout && this._showDialogState) {
      return false;
    }
    return true;
  }

  // 判断是否需要拉起沙箱，这次不需要就等timeout的回调
  public getNeedStartAbility(requestId: string): boolean {
    this.printAllDecryptingMap();
    HiLog.info(TAG, `OpeningDialogManager getNeedStartAbility requestId ${requestId}`);
    const decryptingState: DecryptingState | undefined = this._decryptingMap.get(requestId);
    if (!decryptingState) {
      HiLog.error(TAG, 'getNeedStartAbility not isDecrypting');
      return false;
    }
    const timeout = decryptingState.dialogTimeout;
    HiLog.info(TAG, `OpeningDialogManager getNeedStartAbility requestId ${requestId}, timeout ${timeout},
    showDialogState ${this._showDialogState}`);
    if (!this._showDialogState || timeout) {
      HiLog.info(TAG, 'can startAbility');
      return true;
    }
    decryptingState.needStartAbility = true;
    this.printAllDecryptingMap();
    return false;
  }

  // 判断是否可以拉起沙箱，即用户是否手动终止弹框
  public getCanStartAbility(requestId: string): boolean {
    this.printAllDecryptingMap();
    const isDecrypting = this._decryptingMap.has(requestId);
    HiLog.info(TAG, `getCanStartAbility requestId ${requestId}, isDecrypting ${isDecrypting}`);
    return isDecrypting;
  }

  // 弹框消失的回调，需要判断是否是用户主动终止解密流程
  public async dialogDisappear(requestId: string): Promise<void> {
    this.printAllDecryptingMap();
    HiLog.info(TAG, `OpeningDialogManager dialogDisappear requestId ${requestId}`);
    this._showDialogState = false;
    const decryptingState: DecryptingState | undefined = this._decryptingMap.get(requestId);
    if (!decryptingState) {
      HiLog.info(TAG, 'dialogDisappear uri is not decrypting');
      return;
    }
    const hasDecrypted = decryptingState.hasDecrypted;
    const isZip = decryptingState.isZip;
    HiLog.info(TAG, `dialogDisappear hasDecrypted ${hasDecrypted} isZip ${isZip}`);
    if (!hasDecrypted || (!hasDecrypted && isZip)) { // 如果正在解密且不需要拉弹框，是用户主动终止解密流程
      HiLog.info(TAG, 'user close opening dialog');
      await OpenDlpFileManager.getInstance().deleteStatus(decryptingState.uri);
      this._decryptingMap.delete(requestId);
      this._isChargeDecrypting = false;
      this.printAllDecryptingMap();
    }
  }

  // 弹框超过250ms的回调
  public async dialogTimeout(requestId: string): Promise<void> {
    this.printAllDecryptingMap();
    HiLog.info(TAG, `OpeningDialogManager dialogTimeout requestId ${requestId}`);
    const decryptingState: DecryptingState | undefined = this._decryptingMap.get(requestId);
    if (!decryptingState) {
      HiLog.info(TAG, 'dialogTimeout uri is not decrypting');
      await ErrorManager.getInstance().startHandleError(requestId);
      return;
    }
    decryptingState.dialogTimeout = true;
    await ErrorManager.getInstance().startHandleError(requestId);
    this.printAllDecryptingMap();
    if (decryptingState.needStartAbility) { // 弹框超时，且需要拉起沙箱，就去拉沙箱
      const startSandboxRet = await StartSandboxHandler.getInstance().startSandbox();
      if (startSandboxRet.errcode !== Constants.ERR_CODE_SUCCESS) {
        HiLog.error(TAG, 'OpeningDialogManager startSandbox error');
      }
      this._decryptingMap.delete(requestId);
    }
  }

  private async showDialog(requestId: string): Promise<void> {
    this.printAllDecryptingMap();
    this._showDialogState = await ViewAbilityService.getInstance().showDialog(true, requestId);
    HiLog.info(TAG, `OpeningDialogManager showDialog requestId: ${requestId}, state: ${this._showDialogState}`);
  }

  private async hideDialog(): Promise<void> {
    HiLog.info(TAG, 'OpeningDialogManager hideDialog start');
    await ViewAbilityService.getInstance().showDialog(false);
  }

  private getDecryptingRequestId(): string | undefined {
    this.printAllDecryptingMap();
    for (const entry of this._decryptingMap) {
      if (!entry[1].needStartAbility && !entry[1].hasDecrypted) {
        HiLog.info(TAG, `getDecryptingRequestId found requestId ${entry[0]}`);
        return entry[0];
      }
    }
    HiLog.info(TAG, 'getDecryptingRequestId not found');
    return undefined;
  }

  private getDecryptingRequestIdByToast(): string | undefined {
    this.printAllDecryptingMap();
    for (const entry of this._decryptingMap) {
      if (entry[1].hasDecrypted) {
        HiLog.info(TAG, `getDecryptingRequestIdByToast found requestId ${entry[0]}`);
        return entry[0];
      }
    }
    HiLog.info(TAG, 'getDecryptingRequestIdByToast not found');
    return undefined;
  }


  // 根据解密状态，校验是否需要拉起弹框
  public async checkShowDialogState(): Promise<void> {
    this.printAllDecryptingMap();
    this._hasCallback = true;
    const isDecrypting = this._decryptingMap.size > 0;
    const requestId = this.getDecryptingRequestId();
    HiLog.info(TAG, `OpeningDialogManager checkShowDialogState showDialogState ${this._showDialogState},
    isDecrypting ${isDecrypting}, requestId ${requestId}, isChargeDecrypting ${this._isChargeDecrypting}`);

    if (!isDecrypting && !this._isChargeDecrypting) { // 没在处理弹框逻辑或解密逻辑，需要取消弹框
      await this.hideDialog();
      await ViewAbilityService.getInstance().sendDisconnectMsgWithTimeout();
      return;
    }

    if (!requestId) {
      HiLog.info(TAG, 'OpeningDialogManager checkShowDialogState getDecryptingRequestId not found');
      return;
    }
    if (isDecrypting && !this._showDialogState) { // 正在解密，且没拉起弹框，需要拉起弹框
      this._showDialogState = true;
      await this.showDialog(requestId);
      return;
    }
  }

  // openDLPFile前调用，或者zip格式提前调用
  public async showOpeningDialog(uri: string, requestId: string, needShowDialog: boolean,
    isZip?: boolean): Promise<void> {
    this.printAllDecryptingMap();
    HiLog.info(TAG, 'OpeningDialogManager showOpeningDialog');
    if (this._decryptingMap.has(requestId)) {
      HiLog.info(TAG, 'OpeningDialogManager showOpeningDialog is decrypting');
      return;
    }
    const decryptingState: DecryptingState = {
      uri: uri,
      dialogTimeout: false,
      needStartAbility: false,
      hasDecrypted: false,
      needShowDialog: needShowDialog,
      isZip: isZip ?? false,
    }
    this._decryptingMap.set(requestId, decryptingState);
    this.printAllDecryptingMap();
    if (this._showDialogState) {
      HiLog.info(TAG, 'is showing OpeningDialog');
      return;
    }
    if (!needShowDialog) {
      HiLog.info(TAG, 'no need showDialog');
      return;
    }
    await this.showDialog(requestId);
  }

  // 根据大小不需要弹框，但是调用penDLPFile接口超过500ms都没返回，拉起“正在打开”弹框
  public async showOpeningDialogByTimeout(requestId: string): Promise<void> {
    const viewContext = AppStorage.get('viewContext') as common.ServiceExtensionContext;
    if (!viewContext) {
      HiLog.error(TAG, 'showOpeningDialogByTimeout viewContext null');
      return;
    }
    this.printAllDecryptingMap();
    HiLog.info(TAG, 'OpeningDialogManager showOpeningDialogByTimeout');
    const decryptingState: DecryptingState | undefined = this._decryptingMap.get(requestId);
    if (!decryptingState) {
      HiLog.error(TAG, 'showOpeningDialogByTimeout not isDecrypting');
      return;
    }
    decryptingState.needShowDialog = true;
    this.printAllDecryptingMap();
    if (this._showDialogState) {
      HiLog.info(TAG, 'showOpeningDialogByTimeout is showing OpeningDialog');
      return;
    }
    await this.loadOpeningDialogUIExtAbility(viewContext);
    await this.showDialog(requestId);
  }

  // openDLPFile结束后调用
  public async hideOpeningDialog(requestId: string): Promise<void> {
    this.printAllDecryptingMap();
    HiLog.info(TAG, `OpeningDialogManager hideOpeningDialog requestId ${requestId}`);
    const decryptingState: DecryptingState | undefined = this._decryptingMap.get(requestId);
    if (!decryptingState) {
      HiLog.info(TAG, 'hideOpeningDialog uri is not decrypting');
      return;
    }
    decryptingState.hasDecrypted = true;
    this.printAllDecryptingMap();
    HiLog.info(TAG, `hideOpeningDialog showDialogState ${this._showDialogState}`);
    if (!this._showDialogState) {
      return;
    }
    await this.hideDialog();
  }

  // 拉沙箱之前调用
  public setNeedStartAbility(requestId: string): void {
    this.printAllDecryptingMap();
    HiLog.info(TAG, `OpeningDialogManager setNeedStartAbility requestId ${requestId}`);
    const decryptingState: DecryptingState | undefined = this._decryptingMap.get(requestId);
    if (!decryptingState) {
      HiLog.info(TAG, 'setNeedStartAbility uri is not decrypting');
      return;
    }
    decryptingState.needStartAbility = true;
    this._isChargeDecrypting = false;
    this.printAllDecryptingMap();
  }

  // zip格式提前调用后因为各种原因失败
  public async hideOpeningDialogByFailed(requestId: string): Promise<void> {
    this.printAllDecryptingMap();
    const isDecrypting = this._decryptingMap.has(requestId);
    HiLog.info(TAG, `hideOpeningDialogByFailed requestId ${requestId}, isDecrypting ${isDecrypting}`);
    if (!isDecrypting) {
      HiLog.info(TAG, 'hideOpeningDialogByFailed uri is not decrypting');
      return;
    }
    HiLog.info(TAG, `hideOpeningDialogByFailed showDialogState ${this._showDialogState}`);
    if (!this._showDialogState) {
      return;
    }
    await this.hideDialog();
    await ViewAbilityService.getInstance().sendDisconnectMsgWithTimeout();
  }

  // 根据文件打包类型，文件大小判断是否拉起弹框
  public async loadOpeningDialog(context: common.ServiceExtensionContext, fileSize: number,
    openDlpFileData: OpenDlpFileData, state: DecryptState, parseType?: FileParseType): Promise<void> {
    HiLog.info(TAG, `OpeningDialogManager loadOpeningDialog fileSize: ${fileSize} parseType: ${parseType}`);
    if ((parseType === FileParseType.ZIP && fileSize >= Constants.DIALOG_SHOW_SIZE_ZIP) ||
      (parseType === FileParseType.RAW && fileSize >= Constants.DIALOG_SHOW_SIZE_RAW)) {
      HiLog.info(TAG, 'need show opening dialog');
      openDlpFileData.needShowToast = true;
      this._hasCallback = false;
      await this.loadOpeningDialogUIExtAbility(context);
      if (parseType === FileParseType.ZIP) {
        HiLog.info(TAG, 'zip type show opening dialog advance');
        await this.showOpeningDialog(openDlpFileData.uri, openDlpFileData.requestId, true, true);
      }
      return;
    }
    HiLog.info(TAG, 'no need show opening dialog');
    this._hasCallback = true;
  }

  // viewAbility正常结束
  public async unLoadOpeningDialogNormal(): Promise<void> {
    this.printAllDecryptingMap();
    this._isChargeDecrypting = false;
    const isDecrypting = this._decryptingMap.size > 0;
    HiLog.info(TAG, `OpeningDialogManager unLoadOpeningDialogNormal isDecrypting ${isDecrypting}`);
    if (isDecrypting) {
      HiLog.info(TAG, 'isDecrypting, no need hideDialog');
      return;
    }
    await this.hideDialog();
  }

  // viewAbility异常结束
  public async unLoadOpeningDialogAbnormal(): Promise<void> {
    HiLog.info(TAG, 'unLoadOpeningDialogAbnormal start');
    this._isChargeDecrypting = false;
    await this.hideDialog();
    await ViewAbilityService.getInstance().sendDisconnectMsg();
  }

  private async loadOpeningDialogUIExtAbility(context: common.ServiceExtensionContext): Promise<boolean> {
    HiLog.info(TAG, 'begin loadOpeningDialog');
    let uiExtWant: Want = {
      bundleName: Constants.DLP_MANAGER_BUNDLE_NAME,
      abilityName: Constants.DLP_OPENING_DIALOG_UI_EXT_ABILITY,
      moduleName: 'entry',
      parameters: {
        'ability.want.params.uiExtensionType': 'sys/commonUI',
      }
    };
    try {
      await context.requestModalUIExtension(uiExtWant);
      HiLog.info(TAG, 'requestModalUIExtension success');
      return true;
    } catch (err) {
      HiLog.wrapError(TAG, err, 'requestModalUIExtension error');
      return false;
    }
  }
}