HarmonyOS CustomDialogController可否拦截返回事件？

import { AppRouter } from './AppRouter'  
import { AppDialog } from './AppDialog'  
import { PrivacyDialogViewBuilder } from './PrivacyDialogView';  
import { DefaultDialog } from './DefaultDialog';  
@Entry  
@Component  
struct Index {  
  @Builder  
  PageMap(name: string) {  
    DefaultDialog()  
  }  
  build() {  
    Navigation(AppRouter.getInstance().getPathStack()) {  
      Stack({ alignContent: Alignment.Center }) {  
        Column() {  
          Button('基于Navigation实现自定义弹窗', { stateEffect: true, type: ButtonType.Capsule })  
            .onClick(() => {  
              AppDialog  
                .build(wrapBuilder(PrivacyDialogViewBuilder))  
                .onBackPressed((): boolean => true)  
                .open();  
            })  
  
        }  
      }  
      .height("100%")  
      .width("100%")  
    }  
    .hideTitleBar(true)  
    .navDestination(this.PageMap)  
  }  
}

import { AppDialog } from './AppDialog'  
  
@Builder  
export function PrivacyDialogViewBuilder() {  
  PrivacyDialogView()  
}  
  
@Component  
struct PrivacyDialogView {  
  scroller: Scroller = new Scroller()  
  
  build() {  
    Column() {  
      Text("温馨提示")  
        .fontSize(18)  
        .padding(15)  
      Scroll(this.scroller) {  
        Text('请勿返回')  
        .fontSize(16)  
        .padding(15)  
      }.scrollable(ScrollDirection.Vertical)  
      .height(240)  
  
      Button('同意', { type: ButtonType.Capsule })  
        .onClick(() => {  
          AppDialog.instance.close();  
        }).margin({ top: 10, bottom: 10 })  
        .width("80%")  
      Button('不同意', { stateEffect: false, buttonStyle: ButtonStyleMode.TEXTUAL })  
        .onClick(() => {  
          AppDialog.instance.close();  
        }).margin({ bottom: 10 })  
    }  
    .backgroundColor(Color.White)  
    .borderRadius(15)  
    .width(250)  
  }  
}

import { AppRouter } from './AppRouter';  
import { AppDialog, AppDialogOption } from './AppDialog';  
  
@Component  
export struct DefaultDialog {  
  private dialogOptions?: AppDialogOption;  
  @State opacityNum: number = 1;  
  aboutToAppear(): void {  
    this.dialogOptions = AppRouter.getLastParams() as AppDialogOption;  
  }  
  build() {  
    NavDestination() {  
      Stack({  
        alignContent: this.dialogOptions?.styles?.align  
      }) {  
  
        Column() {  
        }  
        .width("100%")  
        .height("100%")  
        .backgroundColor(this.dialogOptions?.styles?.background)  
        .opacity(this.opacityNum)  
        .transition(  
          TransitionEffect.OPACITY.animation({  
            duration: 300,  
            curve: Curve.Friction  
          })  
        )  
        .onClick(() => {  
          let res = false;  
          if (this.dialogOptions?.onBackPressed) {  
            res = this.dialogOptions?.onBackPressed();  
          }  
          if (res) {  
            return;  
          }  
          animateTo({  
            duration: 300,  
            curve: Curve.Friction,  
            onFinish: () => {  
              AppDialog.instance.close();  
            }  
          }, () => {  
            this.opacityNum = 0  
          })  
        })  
        Column() {  
          this.dialogOptions?.view?.builder(this.dialogOptions?.params)  
        }  
        .opacity(this.opacityNum)  
        .transition(  
          TransitionEffect.scale({ x: 0, y: 0 }).animation({  
            duration: 300,  
            curve: Curve.Friction  
          })  
        )  
      }  
      .width("100%")  
      .height("100%")  
    }  
    .mode(NavDestinationMode.DIALOG)  
    .hideTitleBar(true)  
    .onBackPressed(this.dialogOptions?.onBackPressed)  
  }  
}

import { AppRouter } from './AppRouter';  
export class AppDialog {  
  static instance: AppDialog;  
  private lastIndex: number = 0;  
  private options?: AppDialogOption;  
  
  public static buildWithOptions(options?: AppDialogOption): AppDialog {  
    let instance: AppDialog = new AppDialog();  
    instance.lastIndex = AppRouter.getInstance().getPathStack().size() - 1;  
    instance.options = options;  
    AppDialog.instance = instance;  
    return instance;  
  }  
  public static build(builder: WrappedBuilder<Object[]>): AppDialog {  
    let options: AppDialogOption = new AppDialogOption();  
    options.view = builder;  
    return AppDialog.buildWithOptions(options);  
  }  
  public static closeAll(): void {  
    AppRouter.getInstance().getPathStack().removeByName('defaultDialog');  
  }  
  public open(): AppDialog {  
    AppRouter.getInstance().getPathStack().pushPathByName('defaultDialog', this.options);  
    return this;  
  }  
  public onBackPressed(callback: () => boolean): AppDialog {  
    this.options!.onBackPressed = callback;  
    return this;  
  }  
  public close(): void {  
    if (AppRouter.getInstance().getPathStack().size() >= this.lastIndex) {  
      AppRouter.getInstance().getPathStack().popToIndex(this.lastIndex);  
    }  
  }  
}  
export class AppDialogOption {  
  view?: WrappedBuilder<Object[]>  
  params?: Object  
  onClose?: () => void  
  onPop?: (data: PopInfo) => void  
  onBackPressed?: () => boolean  
  styles?: AppDialogStyle = new AppDialogStyle()  
}  
export class AppDialogStyle {  
  transparent: boolean = false  
  background: string = 'rgba(0,0,0,0.5)'  
  radius: Length = 5  
  align: Alignment = Alignment.Center  
}

import { HashMap } from '@kit.ArkTS';  
export interface RouterParams {  
  name?: string,  
  onPop?: (data: PopInfo) => void  
}  
export class AppRouter {  
  private static instance = new AppRouter();  
  private pathStack: NavPathStack = new NavPathStack();  
  private routeMap: HashMap<string, WrappedBuilder<[object]>> = new HashMap();  
  
  public static getInstance(): AppRouter {  
    return AppRouter.instance;  
  }  
  public getPathStack(): NavPathStack {  
    return this.pathStack;  
  }  
  public addRouteMap(name: string, builder:  
    WrappedBuilder<[object]>): void {  
    this.routeMap.set(name, builder)  
  }  
  private pushPath(name: string): void {  
    this.pathStack.pushPath({ name: name })  
  }  
  public static push(name: string): void {  
    AppRouter.instance.pushPath(name);  
  }  
  public static openDialog(name: string, params?: RouterParams): void {  
    AppRouter.instance.pathStack.pushPath({  
      name: name, param: params, onPop: (data: PopInfo) => {  
        if (params?.onPop) {  
          params.onPop!(data);  
        }  
      }  
    });  
  }  
  public static replace(name: string, params?: RouterParams): void {  
    AppRouter.instance.pathStack.replacePath({ name: name, param: params });  
  }  
  public static getParams(name: string): string {  
    return JSON.stringify(AppRouter.instance.pathStack.getParamByName(name));  
  }  
  public static getLastParams(): Object {  
    return AppRouter.instance.pathStack.getParamByIndex(AppRouter.instance.pathStack.size()-1) as Object;  
  }  
  public static pop(): void {  
    AppRouter.instance.pathStack.pop();  
  }  
  public static popWithResult(params: RouterParams): void {  
    AppRouter.instance.pathStack.pop(params);  
  }  
}