使用预览器实现多端预览

import { AbilityConstant, UIAbility, Want } from '@kit.AbilityKit'; 
import { hilog } from '@kit.PerformanceAnalysisKit'; 
import { window } from '@kit.ArkUI'; 
import display from '@ohos.display' 
 
export default class EntryAbility extends UIAbility { 
 
  private windowObj?: window.Window 
  private curBp: string = '' 
  //... 
  // 根据当前窗口尺寸更新断点 
  private updateBreakpoint(windowWidth: number) :void{ 
    // 将长度的单位由px换算为vp 
    let windowWidthVp = windowWidth / display.getDefaultDisplaySync().densityPixels 
    console.log('windowWidthVp = '+windowWidthVp) 
    let newBp: string = '' 
    if (windowWidthVp < 320) { 
      newBp = 'xs' 
    } else if (windowWidthVp < 600) { 
      newBp = 'sm' 
    } else if (windowWidthVp < 840) { 
      newBp = 'md' 
    } else { 
      newBp = 'lg' 
    } 
    if (this.curBp !== newBp) { 
      this.curBp = newBp 
      // 使用状态变量记录当前断点值 
      AppStorage.setOrCreate('currentBreakpoint', this.curBp) 
    } 
  } 
 
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void { 
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); 
  } 
 
  onDestroy(): void { 
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy'); 
  } 
 
  onWindowStageCreate(windowStage: window.WindowStage): void { 
    // Main window is created, set main page for this ability 
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate'); 
 
    windowStage.loadContent('pages/MediaQuerySample', (err, data) => { 
      if (err.code) { 
        hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); 
        return; 
      } 
      hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', JSON.stringify(data) ?? ''); 
    }); 
 
    windowStage.getMainWindow().then((windowObj) => { 
      this.windowObj = windowObj 
      // 获取应用启动时的窗口尺寸 
      this.updateBreakpoint(windowObj.getWindowProperties().windowRect.width) 
      // 注册回调函数，监听窗口尺寸变化 
      windowObj.on('windowSizeChange', (windowSize)=>{ 
        this.updateBreakpoint(windowSize.width) 
      }) 
    }); 
  } 
 
  onWindowStageDestroy(): void { 
    // Main window is destroyed, release UI related resources 
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy'); 
 
    try { 
      if (this.windowObj) { 
        this.windowObj.off('windowSizeChange') 
      } 
    } catch (err) { 
      console.log('show windowObj errMsg' + JSON.stringify(err)) 
    } 
  } 
 
  onForeground(): void { 
    // Ability has brought to foreground 
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground'); 
  } 
 
  onBackground(): void { 
    // Ability has back to background 
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground'); 
  } 
} 
// common/breakpointsystem.ets 
import mediaQuery from '@ohos.mediaquery' 
 
declare interface BreakPointTypeOption<T> { 
  xs?: T 
  sm?: T 
  md?: T 
  lg?: T 
  xl?: T 
  xxl?: T 
} 
 
export class BreakPointType<T> { 
  options: BreakPointTypeOption<T> 
 
  constructor(option: BreakPointTypeOption<T>) { 
    this.options = option 
  } 
 
  getValue(currentBreakPoint: string) { 
    if (currentBreakPoint === 'xs') { 
      return this.options.xs 
    } else if (currentBreakPoint === 'sm') { 
      return this.options.sm 
    } else if (currentBreakPoint === 'md') { 
      return this.options.md 
    } else if (currentBreakPoint === 'lg') { 
      return this.options.lg 
    } else if (currentBreakPoint === 'xl') { 
      return this.options.xl 
    } else if (currentBreakPoint === 'xxl') { 
      return this.options.xxl 
    } else { 
      return undefined 
    } 
  } 
} 
 
interface Breakpoint { 
  name: string 
  size: number 
  mediaQueryListener?: mediaQuery.MediaQueryListener 
} 
 
export class BreakpointSystem { 
  private currentBreakpoint: string = 'md' 
  private breakpoints: Breakpoint[] = [ 
    { name: 'xs', size: 0 }, { name: 'sm', size: 320 }, 
    { name: 'md', size: 600 }, { name: 'lg', size: 840 } 
  ] 
 
  private updateCurrentBreakpoint(breakpoint: string) { 
    if (this.currentBreakpoint !== breakpoint) { 
      this.currentBreakpoint = breakpoint 
      AppStorage.Set<string>('currentBreakpoint', this.currentBreakpoint) 
      console.log('on current breakpoint: ' + this.currentBreakpoint) 
    } 
  } 
 
  public register() { 
    this.breakpoints.forEach((breakpoint: Breakpoint, index) => { 
      let condition:string 
      if (index === this.breakpoints.length - 1) { 
        condition = '(' + breakpoint.size + 'vp<=width' + ')' 
      } else { 
        condition = '(' + breakpoint.size + 'vp<=width<' + this.breakpoints[index + 1].size + 'vp)' 
      } 
      console.log(condition) 
      breakpoint.mediaQueryListener = mediaQuery.matchMediaSync(condition) 
      breakpoint.mediaQueryListener.on('change', (mediaQueryResult) => { 
        if (mediaQueryResult.matches) { 
          this.updateCurrentBreakpoint(breakpoint.name) 
        } 
      }) 
    }) 
  } 
 
  public unregister() { 
    this.breakpoints.forEach((breakpoint: Breakpoint) => { 
      if(breakpoint.mediaQueryListener){ 
        breakpoint.mediaQueryListener.off('change') 
      } 
    }) 
  } 
} 
// MediaQuerySample.ets 
import { BreakpointSystem, BreakPointType } from './breakpointsystem' 
import { display } from '@kit.ArkUI'; 
 
@Entry 
@Component 
struct MediaQuerySample { 
  @StorageLink('currentBreakpoint') private currentBreakpoint: string = "md"; 
  @State private icon: Resource = $r('app.media.images2') 
  private breakpointSystem: BreakpointSystem = new BreakpointSystem() 
 
  aboutToAppear() { 
    this.breakpointSystem.register() 
  } 
 
  aboutToDisappear() { 
    this.breakpointSystem.unregister() 
  } 
  onPageShow(): void { 
    console.log('width='+JSON.stringify(display.getDefaultDisplaySync().width)) 
    console.log('height='+JSON.stringify(display.getDefaultDisplaySync().height)) 
    console.log('densityDPI='+JSON.stringify(display.getDefaultDisplaySync().densityDPI)) 
  } 
  build() { 
    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) { 
      Image(new BreakPointType({sm:$r('app.media.images2'), md:$r('app.media.images3'), lg:$r('app.media.images4')}).getValue(this.currentBreakpoint)!) 
        .height(100) 
        .width(100) 
        .objectFit(ImageFit.Contain) 
 
      Text(this.currentBreakpoint) 
        .fontSize(24) 
        .margin(10) 
    } 
    .width('100%') 
    .height('100%') 
  } 
}