HarmonyOS 鸿蒙Next 自动截屏

截图保存demo如下，

保存相册用到的api （phAccessHelper.showAssetsCreationDialog）需要授权允许保存，没有用到ACL权限，该权限一般也不让申请。：

// main.dart
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Channel Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const Scaffold(
        body: PluginPage(),
      ),
    );
  }
}

class PluginPage extends StatefulWidget {
  const PluginPage({super.key});

  @override
  State<PluginPage> createState() => _PluginPageState();
}

class _PluginPageState extends State<PluginPage> {
  final _platform = const MethodChannel('samples.flutter.dev/screenSave');
  int count = 0;

  @override
  void initState() {
    super.initState();
    _initListener();
  }

  _initListener() {
  }

  Future<void> _screenSave() async {
    
    try {
      // 调用需要在平台中实现的方法
     await _platform.invokeMethod<int>('screenSave');
     
    } on PlatformException catch (e) {
     
    }

    setState(() {
      
    });
  }

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Text('test'),
          ElevatedButton(
            onPressed: () => _screenSave(),
            child: const Text("screenSave"),
          ),
        ],
      ),
    );
  }
}

// index.ets

import common from '@ohos.app.ability.common';
import { FlutterPage } from '@ohos/flutter_ohos'

let storage = LocalStorage.getShared()
const EVENT_BACK_PRESS = 'EVENT_BACK_PRESS'

@Entry(storage)
@Component
struct Index {
  private context = getContext(this) as common.UIAbilityContext
  @LocalStorageLink('viewId') viewId: string = "";

  build() {
    Column() {
      FlutterPage({ viewId: this.viewId })
    }
  }

  onBackPress(): boolean {
    this.context.eventHub.emit(EVENT_BACK_PRESS)
    return true
  }
}
// EntryAbility.ets
import { FlutterAbility, FlutterEngine } from '@ohos/flutter_ohos';
import { GeneratedPluginRegistrant } from '../plugins/GeneratedPluginRegistrant';
import ScreenSavePlugin from '../plugins/ScreenSavePlugin';

export default class EntryAbility extends FlutterAbility {
  configureFlutterEngine(flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    GeneratedPluginRegistrant.registerWith(flutterEngine)
    this.addPlugin(new ScreenSavePlugin());
  }
}

// ets/plugins/ScreenSavePlugin.ets

import {
  FlutterPlugin,
  Log,
  MethodCall,
  MethodChannel,
} from '@ohos/flutter_ohos';
import { FlutterPluginBinding } from '@ohos/flutter_ohos/src/main/ets/embedding/engine/plugins/FlutterPlugin';
import { BusinessError } from '[@kit](/user/kit).BasicServicesKit';
import { MethodResult } from '@ohos/flutter_ohos/src/main/ets/plugin/common/MethodChannel';
import { window } from '[@kit](/user/kit).ArkUI';
import { image } from '[@kit](/user/kit).ImageKit';
import { PixelMapUtil } from '../util/PixelMapUtil';

const TAG = "ScreenSavePluginTag";

export default class ScreenSavePlugin implements FlutterPlugin {
  private channel?: MethodChannel;
  private api = new ScreenSaveApi();

  onAttachedToEngine(binding: FlutterPluginBinding): void {
    this.channel = new MethodChannel(binding.getBinaryMessenger(), "samples.flutter.dev/screenSave");
    let that = this;
    this.channel.setMethodCallHandler({
      onMethodCall(call: MethodCall, result: MethodResult) {
        switch (call.method) {
          case "screenSave":
            that.api.screenSave(result)
            break;
          default:
            result.notImplemented();
            break;
        }
      }
    })
  }

  onDetachedFromEngine(binding: FlutterPluginBinding): void {
    Log.i(TAG, "onDetachedFromEngine");
    this.channel?.setMethodCallHandler(null);
  }
  getUniqueClassName(): string {
    return "ScreenSavePlugin";
  }
}
class ScreenSaveApi {
  screenSave(result: MethodResult) {
    let fileName: string = new Date().getMilliseconds().toString()
    let windowClass: window.Window | undefined = undefined

    //获取当前应用内最上层的子窗口，若无应用子窗口，则返回应用主窗口
    let mainWindow = window.getLastWindow(getContext(this))
    mainWindow.then((data) => {
      windowClass = data

      //屏幕截图
      let snapshot = windowClass.snapshot();
      snapshot.then(async (pickInfo: image.PixelMap) => {
        //把PixelMap保存到相册
        const imagePackerApi = image.createImagePacker()
        const IMAGE_QUALITY = 100
        const packOpts: image.PackingOption = { format: "image/jpeg", quality: IMAGE_QUALITY }
        let compressedImageData: ArrayBuffer = await imagePackerApi.packing(pickInfo, packOpts)

        // 调用保存图片工具类方法
        PixelMapUtil.savePicToAlbum(compressedImageData, fileName)
        // PixelMap使用完后及时释放内存
        pickInfo.release()

      }).catch((err: BusinessError) => {
      })
    }).catch((err: BusinessError) => {
      console.error(TAG, `Failed to obtain the top window. Cause code: ${err.code}, message: ${err.message}`);
    })

    result.success(null);
  }
}

// ets/util/PixelMapUtil.ets

import { common } from "[@kit](/user/kit).AbilityKit"
import { fileIo as fs, fileUri, ReadOptions, WriteOptions } from '[@kit](/user/kit).CoreFileKit';
import { photoAccessHelper } from "[@kit](/user/kit).MediaLibraryKit";
import { promptAction } from "[@kit](/user/kit).ArkUI";

const TAG = 'PixelMapUtil'

export class PixelMapUtil {
  //图片保存到相册
  static async savePicToAlbum(base64: ArrayBuffer, fileName: string) {
    PixelMapUtil.writeFileDataToSandBox(base64, fileName + '.jpg').then((path) => {
      PixelMapUtil.savePic(path, fileName)
    })
  }

  public static writeFileDataToSandBox(fileData: ArrayBuffer, fileName: string): Promise<string> {
    return new Promise((resolve, reject) => {
      let context = getContext(PixelMapUtil) as common.UIAbilityContext
      let cacheDir = context.filesDir
      let filePath = cacheDir + "/textDir";
      if (!fs.accessSync(filePath)) {
        fs.mkdirSync(filePath)
      }

      let cachePath = filePath + '/' + fileName
      let file = fs.openSync(cachePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE)
      console.info(TAG, "file fd: " + file.fd)
      let writeLen = fs.writeSync(file.fd, fileData)
      console.info(TAG, "write data to file succeed and size is:" + writeLen)
      fs.closeSync(file)
      resolve(cachePath)
    })
  }


  static async savePic(filePath: string, fileName: string) {
    console.info(TAG, 'ShowAssetsCreationDialogDemo.');
    let context = getContext(PixelMapUtil) as common.UIAbilityContext
    let phAccessHelper = photoAccessHelper.getPhotoAccessHelper(context);
    try {
      let srcFileUri: Array<string> = [fileUri.getUriFromPath(filePath)]
      console.debug(TAG, `图片 uri is : ${JSON.stringify(srcFileUri)}`)

      let photoCreationConfigs: Array<photoAccessHelper.PhotoCreationConfig> = [
        {
          title: fileName, // 可选
          fileNameExtension: 'jpg',
          photoType: photoAccessHelper.PhotoType.IMAGE,
          subtype: photoAccessHelper.PhotoSubtype.DEFAULT, // 可选
        }
      ];
      console.log(TAG, "syncToSysAlarm fileUri:" + JSON.stringify(srcFileUri) + ",config:" +
      JSON.stringify(photoCreationConfigs))
      let desFileUris: Array<string> = await phAccessHelper.showAssetsCreationDialog(srcFileUri, photoCreationConfigs);
      console.debug(TAG, `目标图片 uri is : ${JSON.stringify(desFileUris)}`)


      if (desFileUris.length > 0) {
        for (let index = 0; index < desFileUris.length; index++) {
          PixelMapUtil.copyFileContentTo(srcFileUri[index], desFileUris[index])
        }
      }

    } catch (err) {
      console.error(TAG, 'showAssetsCreationDialog failed, errCode is ' + err.code + ', errMsg is ' + err.message);
    }
  }


  /**
   * 复制文件内容到目标文件
   * [@param](/user/param) srcFilePath 源文件路径
   * [@param](/user/param) destFilePath 目标文件路径
   */
  static copyFileContentTo(srcFilePath: string, destFilePath: string) {
    let srcFile = fs.openSync(srcFilePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE)
    let destFile = fs.openSync(destFilePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE)

    // 读取源文件内容并写入至目的文件
    let bufSize = 4096;
    let readSize = 0;
    let buf = new ArrayBuffer(bufSize);
    let readOptions: ReadOptions = {
      offset: readSize,
      length: bufSize
    };
    let readLen = fs.readSync(srcFile.fd, buf, readOptions);
    while (readLen > 0) {
      readSize += readLen;
      let writeOptions: WriteOptions = {
        length: readLen
      };
      fs.writeSync(destFile.fd, buf, writeOptions);
      readOptions.offset = readSize;
      readLen = fs.readSync(srcFile.fd, buf, readOptions);
    }
    // 关闭文件
    promptAction.showToast({
      message: '保存成功',
      duration: 1000
    });
    fs.closeSync(srcFile);
    fs.closeSync(destFile);
  }
}
// oh-package.json5
  "dependencies": {
    "@ohos/flutter_ohos": "file:./har/flutter.har"
  },