AI-Enhanced Image and Text Creation

const photoViewPicker = new photoAccessHelper.PhotoViewPicker();

const photoSelectOptions = new photoAccessHelper.PhotoSelectOptions();
photoSelectOptions.MIMEType = photoAccessHelper.PhotoViewMIMETypes.IMAGE_TYPE;
photoSelectOptions.maxSelectNumber = CommonConstants.LIMIT_PICKER_NUM - selectedNum;

Image(item)
  .objectFit(ImageFit.Contain)
  .enableAnalyzer(true)
  .dynamicRangeMode(DynamicRangeMode.HIGH)

public static options: image.DecodingOptions = {
  index: 0,
  editable: false,
  desiredPixelFormat: image.PixelMapFormat.RGBA_8888,
};


static createPixelMap(uri: string): ImageInfo | undefined {
  let imageInfo: ImageInfo | undefined;
  try {
    let file = fileIo.openSync(uri, fileIo.OpenMode.READ_ONLY);
    let displayName = file.name;
    let imageResource = image.createImageSource(file.fd);
    let pixelMap = imageResource.createPixelMapSync(FileUtils.options);
    imageInfo = { imagePixelMap: pixelMap, imageName: displayName };
    fileIo.closeSync(file);
  } catch (error) {
    Logger.error(FileUtils.tag, `createPixelMap error: ${JSON.stringify(error)}`);
  }
  return imageInfo;
}

private permissions: Array<Permissions> = [
  'ohos.permission.CAMERA',
  'ohos.permission.MICROPHONE',
  'ohos.permission.MEDIA_LOCATION',
  'ohos.permission.READ_IMAGEVIDEO',
  'ohos.permission.WRITE_IMAGEVIDEO',
];
      abilityAccessCtrl.createAtManager().requestPermissionsFromUser(DataUtils.context, this.permissions).then(() => {
        this.surfaceId = this.mXComponentController.getXComponentSurfaceId();
        this.initCamera();
        this.getThumbnail();
      })

setEnableLivePhoto(isMovingPhoto: boolean) {
  try {
    if (this.photoOutput?.isMovingPhotoSupported()) {
      this.photoOutput?.enableMovingPhoto(isMovingPhoto);
    }
  } catch (error) {
    Logger.error(this.tag, `The setEnableLivePhoto call failed. error: ${JSON.stringify(error)}`);
  }
}

import { MovingPhotoView, MovingPhotoViewController, MovingPhotoViewAttribute } from '@ohos.multimedia.movingphotoview';

  @StorageLink(CommonConstants.KEY_MOVING_DATA) src: photoAccessHelper.MovingPhoto | undefined = undefined;
  @StorageLink(CommonConstants.KEY_IMAGE_INFO) imageInfoArr: Array<ImageInfo> = [];
  @State isMuted: boolean = false;
  async aboutToAppear(): Promise<void> {
    // ...
    this.requestMovingPhoto();
  }

  private requestMovingPhoto() {
    let photoAsset: photoAccessHelper.PhotoAsset =
      AppStorage.get(CommonConstants.KEY_PHOTO_ASSET) as photoAccessHelper.PhotoAsset;
    if (photoAsset === undefined) {
      return;
    }
    let requestOptions: photoAccessHelper.RequestOptions = {
      deliveryMode: photoAccessHelper.DeliveryMode.FAST_MODE,
    }
    photoAccessHelper.MediaAssetManager.requestMovingPhoto(DataUtils.context, photoAsset, requestOptions,
      new MediaDataHandlerMovingPhoto()).catch(() => {
      Logger.error(this.tag, `requestMovingPhoto fail!`);
    });
  }

class MediaDataHandlerMovingPhoto implements photoAccessHelper.MediaAssetDataHandler<photoAccessHelper.MovingPhoto> {
  async onDataPrepared(movingPhoto: photoAccessHelper.MovingPhoto): Promise<void> {
    AppStorage.setOrCreate(CommonConstants.KEY_MOVING_DATA, movingPhoto);
  }
}

build() {
  Flex({
    direction: new BreakpointType(
      {
        sm: FlexDirection.Column,
        md: FlexDirection.Column,
        lg: FlexDirection.Row,
      }
    ).getValue(this.currentBreakpoint),
    wrap: FlexWrap.NoWrap,
    justifyContent: FlexAlign.Start,
    alignItems: ItemAlign.Start,
    alignContent: FlexAlign.Start
  }) {
    this.setActions();
    MovingPhotoView({
      movingPhoto: this.src,
      controller: this.controller
    })
      .width($r('app.string.full_screen'))
      .objectFit(ImageFit.Contain)
      .muted(this.isMuted)
      .margin(new BreakpointType(
        {
          sm: { bottom: $r('app.float.margin_190') } as Padding,
          md: { bottom: $r('app.float.margin_190') } as Padding,
          lg: { right: $r('app.float.margin_24') } as Padding,
        }
      ).getValue(this.currentBreakpoint))
  }
  .backgroundColor(Color.Black)
  .width($r('app.string.full_screen'))
  .height($r('app.string.full_screen'))
}

import {
  CollaborationServiceFilter,
  CollaborationServiceStateDialog,
  createCollaborationServiceMenuItems
} from '@kit.ServiceCollaborationKit';
  @Builder
  CollaborationMenu() {
    Menu() {
      createCollaborationServiceMenuItems([CollaborationServiceFilter.ALL]);
    }
  }

@Builder
setCollaborationDialog() {
  CollaborationServiceStateDialog({
    onState: (stateCode: number, bufferType: string, buffer: ArrayBuffer): void => this.doInsertPicture(stateCode,
      bufferType, buffer)
  });
}

private doInsertPicture(stateCode: number, bufferType: string, buffer: ArrayBuffer): void {
  if (stateCode !== 0) {
    Logger.error(this.tag, `doInsertPicture stateCode: ${stateCode}}`);
    return;
  }
  Logger.info(this.tag, `doInsertPicture bufferType: ${bufferType}}`);
  if (bufferType === CommonConstants.BUFFER_TYPE) {
    if (this.imageInfoArr.length === CommonConstants.LIMIT_PICKER_NUM) {
      try {
        this.getUIContext().getPromptAction().showToast({
          message: $r('app.string.toast_picker_limit'),
          duration: DataUtils.fromResToNumber($r('app.float.show_DELAY_TIME')),
        });
      } catch (error) {
        Logger.error(this.tag, `showToast error: ${JSON.stringify(error)}}`);
      }
      return;
    }
    let saveUri: string = FileUtils.saveFile(DataUtils.context, buffer);
    let imageInfo: ImageInfo | undefined = FileUtils.createPixelMap(saveUri);
    if (imageInfo) {
      this.imageInfoArr.unshift(imageInfo);
      this.selectedData.unshiftData(imageInfo.imagePixelMap);
      // copy file to distributedFilesDir
      FileUtils.copyFileToDestination(saveUri, DataUtils.context.distributedFilesDir);
    }
  }
}

"requestPermissions": [
  {
    "name": "ohos.permission.DISTRIBUTED_DATASYNC",
    "reason": "$string:distributed_desc",
    "usedScene": {
      "abilities": [
        "EntryAbility"
      ],
      "when": "always"
    }
  }
  // ...
]

onPageShow(): void {
  DataUtils.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, (result) => {
    Logger.info('setMissionContinueState ACTIVE result: ', `${result.code}`);
  });
}

aboutToDisappear(): void {
  this.title = '';
  this.description = '';
  DataUtils.context.setMissionContinueState(AbilityConstant.ContinueState.INACTIVE, (result) => {
    Logger.info('setMissionContinueState INACTIVE result: ', `${result.code}`);
  });
}

onWindowStageRestore(windowStage: window.WindowStage) {
  windowStage.loadContent('pages/GraphicCreationPage', (err, data) => {
    // ...
  });
}

onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
  DataUtils.context = this.context;
  // set circulation status INACTIVE
  this.context.setMissionContinueState(AbilityConstant.ContinueState.INACTIVE, (result) => {
    Logger.info(`restoreDistributedObject setMissionContinueState code: ${result.code}`);
  });
  this.restoreDistributedObject(want, launchParam);
  Logger.info(this.tag, '%{public}s', 'Ability onCreate');
}

onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
  this.restoreDistributedObject(want, launchParam);
}

private restoreDistributedObject(want: Want, launchParam: AbilityConstant.LaunchParam): void {
  if (launchParam.launchReason !== AbilityConstant.LaunchReason.CONTINUATION) {
    return;
  }
  try {
    // File copying takes a long time, resulting in the page lifecycle aboutToAppear being executed first.
    let imageInfoArr: ImageInfo[] = [];
    AppStorage.setOrCreate(CommonConstants.KEY_IMAGE_INFO, imageInfoArr);
    let contentInfo: ContentInfo = new ContentInfo(undefined, undefined, undefined, undefined);
    // Create a distributed data object.
    this.distributedObject = distributedDataObject.create(this.context, contentInfo);
    // Add a data restored listener.
    this.distributedObject.on('status',
      (_sessionId: string, _networkId: string, status: 'online' | 'offline' | 'restored') => {
        if (status === 'restored') {
          if (!this.distributedObject) {
            return;
          }
          AppStorage.setOrCreate(CommonConstants.KEY_TITLE, this.distributedObject['title']);
          AppStorage.setOrCreate(CommonConstants.KEY_DESCRIPTION, this.distributedObject['description']);
          let attachments = this.distributedObject['attachments'] as commonType.Assets;
          if (attachments) {
            for (const attachment of attachments) {
              let sourceUri: string =
                fileUri.getUriFromPath(`${this.context.distributedFilesDir}/${attachment.name}`);
              let destination: string = this.context.filesDir;
              FileUtils.copyFileToDestination(sourceUri, destination);
              let uri: string = `${this.context.filesDir}/${attachment.name}`;
              let imageInfo = FileUtils.createPixelMap(uri);
              if (imageInfo) {
                imageInfoArr.push(imageInfo);
              }
            }
          }
          AppStorage.set(CommonConstants.KEY_IMAGE_INFO, imageInfoArr);
          AppStorage.setOrCreate(CommonConstants.KEY_RESTORE_IMAGE_INFO, imageInfoArr);
        }
      });
    let sessionId: string = want.parameters?.distributedSessionId as string;
    this.distributedObject.setSessionId(sessionId);
    this.context.restoreWindowStage(new LocalStorage());
  } catch (error) {
    Logger.info(`restoreDistributedObject error: ${JSON.stringify(error)}`);
  }
}

static copyFileToDestination(sourceUri: string, destination: string) {
  try {
    let buf = new ArrayBuffer(CommonConstants.FILE_BUFFER_SIZE);
    let readSize = 0;
    let file = fileIo.openSync(sourceUri, fileIo.OpenMode.READ_ONLY);
    let readLen = fileIo.readSync(file.fd, buf, { offset: readSize });
    let destinationDistribute =
      fileIo.openSync(`${destination}/${file.name}`, fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE);
    while (readLen > 0) {
      readSize += readLen;
      fileIo.writeSync(destinationDistribute.fd, buf);
      readLen = fileIo.readSync(file.fd, buf, { offset: readSize });
    }
    Logger.info(FileUtils.tag, 'copyFileToDestination success');
    fileIo.closeSync(file);
    fileIo.closeSync(destinationDistribute);
  } catch (err) {
    Logger.error(FileUtils.tag, `copyFileToDestination failed. Code: ${err.code}, message: ${err.message}`);
  }
}