实现wakelock鸿蒙化

Signed-off-by: hezhengyi <ssyzesb@qq.com>

+import { BasicMessageChannel, BinaryMessenger, ByteBuffer, Log, MessageCodec } from '@ohos/flutter_ohos';
+import { Reply } from '@ohos/flutter_ohos/src/main/ets/plugin/common/BasicMessageChannel';
+import StandardMessageCodec from '@ohos/flutter_ohos/src/main/ets/plugin/common/StandardMessageCodec';
+import ArrayList from '@ohos.util.ArrayList';
+import { WakelockApi } from './Wakelock';
+
+const TAG = "wakelock.Messages";
+
+export class ToggleMessage {
+  enable: Boolean = false;
+
+  toMap(): Map<String, ESObject> {
+    let toMapResult: Map<String, ESObject> = new Map<String, ESObject>();
+    toMapResult.set("enable", this.enable);
+    return toMapResult;
+  }
+
+  static fromMap(map: Map<String, ESObject>): ToggleMessage {
+    let fromMapResult = new ToggleMessage();
+    let enable: Boolean = map.get("enable") ?? false;
+    fromMapResult.enable = enable;
+    return fromMapResult;
+  }
+}
+
+export class IsEnabledMessage {
+  enabled: Boolean = false;
+
+  toMap(): Map<String, ESObject> {
+    let toMapResult: Map<String, ESObject> = new Map<String, ESObject>();
+    toMapResult.set("enabled", this.enabled);
+    return toMapResult;
+  }
+
+  static fromMap(map: Map<String, ESObject>): IsEnabledMessage {
+    let fromMapResult = new IsEnabledMessage();
+    let enabled: Boolean = map.get("enabled") ?? false;
+    fromMapResult.enabled = enabled;
+    return fromMapResult;
+  }
+}
+
+class WakelockApiCodec extends StandardMessageCodec {
+  static INSTANCE: WakelockApiCodec = new WakelockApiCodec();
+
+  private constructor() {
+    super();
+  }
+
+  readValueOfType(type: number, buffer: ByteBuffer): ESObject {
+    // Log.i(TAG, "readValueOfType type=" + type + ", buffer=" + buffer);
+    switch (type) {
+      case 128:
+        return IsEnabledMessage.fromMap(this.readValue(buffer) as Map<String, ESObject>);
+
+      case 129:
+        return ToggleMessage.fromMap(this.readValue(buffer) as Map<String, ESObject>);
+
+      default:
+        return super.readValueOfType(type, buffer);
+    }
+  }
+
+  writeValue(stream: ByteBuffer, value: ESObject): ESObject {
+    if (value instanceof IsEnabledMessage) {
+      stream.writeUint8(128);
+      this.writeValue(stream, value.toMap());
+    } else if (value instanceof ToggleMessage) {
+      stream.writeUint8(129);
+      this.writeValue(stream, value.toMap());
+    } else {
+      super.writeValue(stream, value);
+    }
+  }
+}
+
+export class Messages {
+  static getCodec(): MessageCodec<ESObject> {
+    return WakelockApiCodec.INSTANCE;
+  }
+
+  static setup(binaryMessenger: BinaryMessenger, api: WakelockApi): void {
+    {
+      const channel: BasicMessageChannel<ESObject> = new BasicMessageChannel<ESObject>(
+        binaryMessenger, "dev.flutter.pigeon.WakelockApi.toggle", Messages.getCodec());
+      if (api != null) {
+        channel.setMessageHandler({
+          onMessage(message: ESObject, reply: Reply<ESObject>): void {
+            // Log.d(TAG, 'onMessage reply:' + reply)
+            let wrapped: Map<String, ESObject> = new Map<String, ESObject>();
+            try {
+              let args: ArrayList<ESObject> = message as ArrayList<ESObject>;
+              let msgArg: ToggleMessage = args[0] as ToggleMessage;
+
+              Log.i(TAG, "received msgArg=" + JSON.stringify(msgArg));
+              if (msgArg == null) {
+                throw new Error("msgArg unexpectedly null.");
+              }
+              api.toggle(msgArg).then(()=> {
+                Log.i(TAG, "toggle success");
+                wrapped.set("result", null);
+                reply.reply(wrapped);
+              }).catch((err: ESObject) => {
+                Log.i(TAG, "toggle failed: " + JSON.stringify(err));
+                wrapped.set("error", Messages.wrapError(err));
+                reply.reply(wrapped);
+              });
+            } catch (err) {
+              Log.i(TAG, "toggle catch err: " + JSON.stringify(err));
+              wrapped.set("error", Messages.wrapError(err));
+              reply.reply(wrapped);
+            }
+          }
+        });
+      } else {
+        channel.setMessageHandler(null);
+      }
+    }
+    {
+      const channel: BasicMessageChannel<ESObject> = new BasicMessageChannel<ESObject>(
+        binaryMessenger, "dev.flutter.pigeon.WakelockApi.isEnabled", Messages.getCodec());
+      if (api != null) {
+        channel.setMessageHandler({
+          onMessage(message: ESObject, reply: Reply<ESObject>): void {
+            // Log.d(TAG, 'onMessage reply:' + reply)
+            let wrapped: Map<String, ESObject> = new Map<String, ESObject>();
+            try {
+              let output: IsEnabledMessage = api.isEnabled();
+              wrapped.set("result", output);
+            } catch (err) {
+              wrapped.set("error", Messages.wrapError(err))
+            }
+            reply.reply(wrapped)
+          }
+        });
+      } else {
+        channel.setMessageHandler(null);
+      }
+    }
+  }
+
+  static wrapError(error: Error): Map<String, ESObject> {
+    let errorMap: Map<String, ESObject> = new Map();
+    errorMap.set("message", error.message);
+    errorMap.set("code", error.name);
+    errorMap.set("details", null);
+    return errorMap;
+  }
+}

+import { Log } from '@ohos/flutter_ohos';
+import { IsEnabledMessage, ToggleMessage } from './Messages';
+import common from '@ohos.app.ability.common';
+import window from '@ohos.window';
+
+const TAG = "Wakelock.ohos";
+
+export interface WakelockApi {
+  toggle(msg: ToggleMessage): Promise<void>;
+
+  isEnabled(): IsEnabledMessage;
+}
+
+export class Wakelock implements WakelockApi {
+  private enabled: boolean = false;
+  context?: common.UIAbilityContext;
+
+  constructor(context: common.UIAbilityContext) {
+    this.context = context;
+  }
+
+  toggle(message: ToggleMessage): Promise<void> {
+    if (!this.context) {
+      throw new NoAbilityError();
+    }
+    return new Promise<void>((resolve, reject) => {
+      window.getLastWindow(this.context).then((data) => {
+        return Promise.resolve(data);
+      }).then((windowClass: window.Window) => {
+        let isKeepScreenOn: boolean = message.enable as boolean;
+        Log.i(TAG, "message=" + message.enable);
+        Log.i(TAG, "this.enabled=" + this.enabled);
+        Log.i(TAG, "isKeepScreenOn=" + isKeepScreenOn);
+        windowClass.setWindowKeepScreenOn(isKeepScreenOn).then(() => {
+          Log.i(TAG, "setWindowKeepScreenOn success");
+          this.enabled = isKeepScreenOn;
+          resolve();
+        }).catch((err: ESObject) => {
+          this.enabled = false;
+          reject(err);
+          Log.e(TAG, "setWindowKeepScreenOn error: " + JSON.stringify(err));
+        })
+      }).catch((err: ESObject) => {
+        this.enabled = false;
+        reject(err);
+        Log.i(TAG, "setWindowKeepScreenOn other error: " + JSON.stringify(err));
+      })
+    })
+  }
+
+  isEnabled(): IsEnabledMessage {
+    if (this.context == null) {
+      throw new NoAbilityError()
+    }
+    let msg = new IsEnabledMessage();
+    msg.enabled = this.enabled;
+    return msg;
+  }
+}
+
+export class NoAbilityError extends Error {
+  constructor() {
+    super("wakelock requires a foreground Ability.")
+  }
+}

+/*
+* Copyright (c) 2023 Hunan OpenValley Digital Industry Development 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 AbilityAware from '@ohos/flutter_ohos/src/main/ets/embedding/engine/plugins/ability/AbilityAware';
+import { AbilityPluginBinding } from '@ohos/flutter_ohos/src/main/ets/embedding/engine/plugins/ability/AbilityPluginBinding';
+import {
+  FlutterPlugin,
+  FlutterPluginBinding
+} from '@ohos/flutter_ohos/src/main/ets/embedding/engine/plugins/FlutterPlugin';
+import { Messages } from './Messages';
+import { Wakelock } from './Wakelock';
+
+const TAG = "WakelockPlugin"
+
+export class WakelockPlugin implements FlutterPlugin, AbilityAware {
+  private pluginBinding : FlutterPluginBinding | null = null;
+  private wakelock : Wakelock | null = null;
+
+  getUniqueClassName(): string {
+    return "WakelockPlugin"
+  }
+
+  onAttachedToAbility(binding: AbilityPluginBinding): void {
+    this.wakelock = new Wakelock(binding.getAbility().context);
+    if (this.pluginBinding != null) {
+      Messages.setup(this.pluginBinding.getBinaryMessenger(), this.wakelock);
+    }
+  }
+
+  onDetachedFromAbility(): void {
+    this.wakelock = null;
+  }
+
+  onAttachedToEngine(binding: FlutterPluginBinding): void {
+    this.pluginBinding = binding;
+  }
+
+  onDetachedFromEngine(binding: FlutterPluginBinding): void {
+    this.pluginBinding = null;
+  }
+}