/*
* // Copyright 2013 The Flutter Authors. All rights reserved.
*/
import StandardMessageCodec from '@ohos/flutter_ohos/src/main/ets/plugin/common/StandardMessageCodec';
import BasicMessageChannel, { Reply } from '@ohos/flutter_ohos/src/main/ets/plugin/common/BasicMessageChannel';
import { BinaryMessenger } from '@ohos/flutter_ohos/src/main/ets/plugin/common/BinaryMessenger';
import MessageCodec from '@ohos/flutter_ohos/src/main/ets/plugin/common/MessageCodec';
import { ByteBuffer } from '@ohos/flutter_ohos/src/main/ets/util/ByteBuffer';


/** Error class for passing custom error details to Flutter via a thrown PlatformException. */
export class FlutterError implements Error {

  /** The error code. */
  public code: string;

  /** The error name. */
  public name: string;

  /** The error message. */
  public message: string;
  /** The error stack. */
  public stack?: string;

  constructor(code: string, name: string, message: string, stack?: string) {
    this.code = code;
    this.name = name;
    this.message = message;
    this.stack = stack;
  }
}

function wrapError(error: Error): Array<Object | null> {
  let errorList: Array<Object | null> = new Array<Object | null>(3);
  if (error instanceof FlutterError) {
    let err: FlutterError = error as FlutterError;
    errorList[0] = err.code;
    errorList[1] = err.name;
    errorList[2] = err.message;
  } else {
    errorList[0] = error.toString();
    errorList[1] = error.name;
    errorList[2] = "Cause: " + error.message + ", Stacktrace: " + error.stack;
  }
  return errorList;
}

/* Generated class from Pigeon that represents data sent in messages.*/
export class WearDeviceInfo {
  private deviceId?: string;

  public setDeviceId(deviceId: string | undefined): void {
    this.deviceId = deviceId;
  }

  getDeviceId(): string | undefined {
    return this.deviceId;
  }

  private deviceName?: string;

  public setDeviceName(deviceName: string | undefined): void {
    this.deviceName = deviceName;
  }

  getDeviceName(): string | undefined {
    return this.deviceName;
  }

  private isPaired?: boolean;

  public setIsPaired(isPaired: boolean | undefined): void {
    this.isPaired = isPaired;
  }

  getIsPaired(): boolean | undefined {
    return this.isPaired;
  }

  private isReachable?: boolean;

  public setIsReachable(isReachable: boolean | undefined): void {
    this.isReachable = isReachable;
  }

  getIsReachable(): boolean | undefined {
    return this.isReachable;
  }

  private isWatchAppInstalled?: boolean;

  public setIsWatchAppInstalled(isWatchAppInstalled: boolean | undefined): void {
    this.isWatchAppInstalled = isWatchAppInstalled;
  }

  getIsWatchAppInstalled(): boolean | undefined {
    return this.isWatchAppInstalled;
  }

  constructor(deviceId?: string, deviceName?: string, isPaired?: boolean, isReachable?: boolean, isWatchAppInstalled?: boolean) {
    this.deviceId = deviceId;
    this.deviceName = deviceName;
    this.isPaired = isPaired;
    this.isReachable = isReachable;
    this.isWatchAppInstalled = isWatchAppInstalled;
  }

  toList(): Array<Object | null> {
    let arr: Array<Object | null> = new Array<Object | null>();
    if (this.deviceId === undefined || this.deviceId === null) {
      arr.push(null);
    } else {
      arr.push(this.deviceId);
    }
    if (this.deviceName === undefined || this.deviceName === null) {
      arr.push(null);
    } else {
      arr.push(this.deviceName);
    }
    if (this.isPaired === undefined || this.isPaired === null) {
      arr.push(null);
    } else {
      arr.push(this.isPaired);
    }
    if (this.isReachable === undefined || this.isReachable === null) {
      arr.push(null);
    } else {
      arr.push(this.isReachable);
    }
    if (this.isWatchAppInstalled === undefined || this.isWatchAppInstalled === null) {
      arr.push(null);
    } else {
      arr.push(this.isWatchAppInstalled);
    }
    return arr;
  }

  static fromList(arr: Object[]): WearDeviceInfo {
    let deviceId: string | undefined = undefined;
    if (arr[0] !== null && arr[0] !== undefined) {
      let deviceIdObject: Object = arr[0];
      deviceId = deviceIdObject as string | undefined;
    }
    let deviceName: string | undefined = undefined;
    if (arr[1] !== null && arr[1] !== undefined) {
      let deviceNameObject: Object = arr[1];
      deviceName = deviceNameObject as string | undefined;
    }
    let isPaired: boolean | undefined = undefined;
    if (arr[2] !== null && arr[2] !== undefined) {
      let isPairedObject: Object = arr[2];
      isPaired = isPairedObject as boolean | undefined;
    }
    let isReachable: boolean | undefined = undefined;
    if (arr[3] !== null && arr[3] !== undefined) {
      let isReachableObject: Object = arr[3];
      isReachable = isReachableObject as boolean | undefined;
    }
    let isWatchAppInstalled: boolean | undefined = undefined;
    if (arr[4] !== null && arr[4] !== undefined) {
      let isWatchAppInstalledObject: Object = arr[4];
      isWatchAppInstalled = isWatchAppInstalledObject as boolean | undefined;
    }
    return new WearDeviceInfo(deviceId, deviceName, isPaired, isReachable, isWatchAppInstalled);
  }
}

/* Generated class from Pigeon that represents data sent in messages.*/
export class WatchTransformTheme {
  private themeId: number;

  public setThemeId(themeId: number): void {
    this.themeId = themeId;
  }

  getThemeId(): number {
    return this.themeId;
  }

  private themeName: string;

  public setThemeName(themeName: string): void {
    this.themeName = themeName;
  }

  getThemeName(): string {
    return this.themeName;
  }

  private energeticDescription: string;

  public setEnergeticDescription(energeticDescription: string): void {
    this.energeticDescription = energeticDescription;
  }

  getEnergeticDescription(): string {
    return this.energeticDescription;
  }

  private energeticImage?: number[];

  public setEnergeticImage(energeticImage: number[] | undefined): void {
    this.energeticImage = energeticImage;
  }

  getEnergeticImage(): number[] | undefined {
    return this.energeticImage;
  }

  private energeticImageUrl?: string;

  public setEnergeticImageUrl(energeticImageUrl: string | undefined): void {
    this.energeticImageUrl = energeticImageUrl;
  }

  getEnergeticImageUrl(): string | undefined {
    return this.energeticImageUrl;
  }

  private normalDescription: string;

  public setNormalDescription(normalDescription: string): void {
    this.normalDescription = normalDescription;
  }

  getNormalDescription(): string {
    return this.normalDescription;
  }

  private normalImage?: number[];

  public setNormalImage(normalImage: number[] | undefined): void {
    this.normalImage = normalImage;
  }

  getNormalImage(): number[] | undefined {
    return this.normalImage;
  }

  private normalImageUrl?: string;

  public setNormalImageUrl(normalImageUrl: string | undefined): void {
    this.normalImageUrl = normalImageUrl;
  }

  getNormalImageUrl(): string | undefined {
    return this.normalImageUrl;
  }

  private slightStressfulDescription: string;

  public setSlightStressfulDescription(slightStressfulDescription: string): void {
    this.slightStressfulDescription = slightStressfulDescription;
  }

  getSlightStressfulDescription(): string {
    return this.slightStressfulDescription;
  }

  private slightStressfulImage?: number[];

  public setSlightStressfulImage(slightStressfulImage: number[] | undefined): void {
    this.slightStressfulImage = slightStressfulImage;
  }

  getSlightStressfulImage(): number[] | undefined {
    return this.slightStressfulImage;
  }

  private slightStressfulImageUrl?: string;

  public setSlightStressfulImageUrl(slightStressfulImageUrl: string | undefined): void {
    this.slightStressfulImageUrl = slightStressfulImageUrl;
  }

  getSlightStressfulImageUrl(): string | undefined {
    return this.slightStressfulImageUrl;
  }

  private stressfulDescription: string;

  public setStressfulDescription(stressfulDescription: string): void {
    this.stressfulDescription = stressfulDescription;
  }

  getStressfulDescription(): string {
    return this.stressfulDescription;
  }

  private stressfulImage?: number[];

  public setStressfulImage(stressfulImage: number[] | undefined): void {
    this.stressfulImage = stressfulImage;
  }

  getStressfulImage(): number[] | undefined {
    return this.stressfulImage;
  }

  private stressfulImageUrl?: string;

  public setStressfulImageUrl(stressfulImageUrl: string | undefined): void {
    this.stressfulImageUrl = stressfulImageUrl;
  }

  getStressfulImageUrl(): string | undefined {
    return this.stressfulImageUrl;
  }

  constructor(themeId: number, themeName: string, energeticDescription: string, normalDescription: string, slightStressfulDescription: string, stressfulDescription: string, energeticImage?: number[], energeticImageUrl?: string, normalImage?: number[], normalImageUrl?: string, slightStressfulImage?: number[], slightStressfulImageUrl?: string, stressfulImage?: number[], stressfulImageUrl?: string) {
    this.themeId = themeId;
    this.themeName = themeName;
    this.energeticDescription = energeticDescription;
    this.normalDescription = normalDescription;
    this.slightStressfulDescription = slightStressfulDescription;
    this.stressfulDescription = stressfulDescription;
    this.energeticImage = energeticImage;
    this.energeticImageUrl = energeticImageUrl;
    this.normalImage = normalImage;
    this.normalImageUrl = normalImageUrl;
    this.slightStressfulImage = slightStressfulImage;
    this.slightStressfulImageUrl = slightStressfulImageUrl;
    this.stressfulImage = stressfulImage;
    this.stressfulImageUrl = stressfulImageUrl;
  }

  toList(): Array<Object | null> {
    let arr: Array<Object | null> = new Array<Object | null>();
    if (this.themeId === undefined || this.themeId === null) {
      arr.push(null);
    } else {
      arr.push(this.themeId);
    }
    if (this.themeName === undefined || this.themeName === null) {
      arr.push(null);
    } else {
      arr.push(this.themeName);
    }
    if (this.energeticDescription === undefined || this.energeticDescription === null) {
      arr.push(null);
    } else {
      arr.push(this.energeticDescription);
    }
    if (this.energeticImage === undefined || this.energeticImage === null) {
      arr.push(null);
    } else {
      arr.push(this.energeticImage);
    }
    if (this.energeticImageUrl === undefined || this.energeticImageUrl === null) {
      arr.push(null);
    } else {
      arr.push(this.energeticImageUrl);
    }
    if (this.normalDescription === undefined || this.normalDescription === null) {
      arr.push(null);
    } else {
      arr.push(this.normalDescription);
    }
    if (this.normalImage === undefined || this.normalImage === null) {
      arr.push(null);
    } else {
      arr.push(this.normalImage);
    }
    if (this.normalImageUrl === undefined || this.normalImageUrl === null) {
      arr.push(null);
    } else {
      arr.push(this.normalImageUrl);
    }
    if (this.slightStressfulDescription === undefined || this.slightStressfulDescription === null) {
      arr.push(null);
    } else {
      arr.push(this.slightStressfulDescription);
    }
    if (this.slightStressfulImage === undefined || this.slightStressfulImage === null) {
      arr.push(null);
    } else {
      arr.push(this.slightStressfulImage);
    }
    if (this.slightStressfulImageUrl === undefined || this.slightStressfulImageUrl === null) {
      arr.push(null);
    } else {
      arr.push(this.slightStressfulImageUrl);
    }
    if (this.stressfulDescription === undefined || this.stressfulDescription === null) {
      arr.push(null);
    } else {
      arr.push(this.stressfulDescription);
    }
    if (this.stressfulImage === undefined || this.stressfulImage === null) {
      arr.push(null);
    } else {
      arr.push(this.stressfulImage);
    }
    if (this.stressfulImageUrl === undefined || this.stressfulImageUrl === null) {
      arr.push(null);
    } else {
      arr.push(this.stressfulImageUrl);
    }
    return arr;
  }

  static fromList(arr: Object[]): WatchTransformTheme {
    let themeIdObject: Object = arr[0];
    const themeId: number = themeIdObject as number;
    let themeNameObject: Object = arr[1];
    const themeName: string = themeNameObject as string;
    let energeticDescriptionObject: Object = arr[2];
    const energeticDescription: string = energeticDescriptionObject as string;
    let energeticImage: number[] | undefined = undefined;
    if (arr[3] !== null && arr[3] !== undefined) {
      let energeticImageObject: Object = arr[3];
      energeticImage = energeticImageObject as number[] | undefined;
    }
    let energeticImageUrl: string | undefined = undefined;
    if (arr[4] !== null && arr[4] !== undefined) {
      let energeticImageUrlObject: Object = arr[4];
      energeticImageUrl = energeticImageUrlObject as string | undefined;
    }
    let normalDescriptionObject: Object = arr[5];
    const normalDescription: string = normalDescriptionObject as string;
    let normalImage: number[] | undefined = undefined;
    if (arr[6] !== null && arr[6] !== undefined) {
      let normalImageObject: Object = arr[6];
      normalImage = normalImageObject as number[] | undefined;
    }
    let normalImageUrl: string | undefined = undefined;
    if (arr[7] !== null && arr[7] !== undefined) {
      let normalImageUrlObject: Object = arr[7];
      normalImageUrl = normalImageUrlObject as string | undefined;
    }
    let slightStressfulDescriptionObject: Object = arr[8];
    const slightStressfulDescription: string = slightStressfulDescriptionObject as string;
    let slightStressfulImage: number[] | undefined = undefined;
    if (arr[9] !== null && arr[9] !== undefined) {
      let slightStressfulImageObject: Object = arr[9];
      slightStressfulImage = slightStressfulImageObject as number[] | undefined;
    }
    let slightStressfulImageUrl: string | undefined = undefined;
    if (arr[10] !== null && arr[10] !== undefined) {
      let slightStressfulImageUrlObject: Object = arr[10];
      slightStressfulImageUrl = slightStressfulImageUrlObject as string | undefined;
    }
    let stressfulDescriptionObject: Object = arr[11];
    const stressfulDescription: string = stressfulDescriptionObject as string;
    let stressfulImage: number[] | undefined = undefined;
    if (arr[12] !== null && arr[12] !== undefined) {
      let stressfulImageObject: Object = arr[12];
      stressfulImage = stressfulImageObject as number[] | undefined;
    }
    let stressfulImageUrl: string | undefined = undefined;
    if (arr[13] !== null && arr[13] !== undefined) {
      let stressfulImageUrlObject: Object = arr[13];
      stressfulImageUrl = stressfulImageUrlObject as string | undefined;
    }
    return new WatchTransformTheme(themeId, themeName, energeticDescription, normalDescription, slightStressfulDescription, stressfulDescription, energeticImage, energeticImageUrl, normalImage, normalImageUrl, slightStressfulImage, slightStressfulImageUrl, stressfulImage, stressfulImageUrl);
  }
}

export class PigeonCodec extends StandardMessageCodec {
  static readonly INSTANCE: PigeonCodec = new PigeonCodec();

  getByte(n: number): number {
    let byteArray = new Uint8Array(1);
    byteArray[0] = n;
    return byteArray[0] as number;
  }
  private constructor() {
    super();
  }

  readValueOfType(type: number, buffer: ByteBuffer): ESObject {
    switch (type) {
      case this.getByte(129):
        return WearDeviceInfo.fromList(super.readValue(buffer) as Object[]);
      case this.getByte(130):
        return WatchTransformTheme.fromList(super.readValue(buffer) as Object[]);
      default:
        return super.readValueOfType(type, buffer);
    }
  }

  writeValue(stream: ByteBuffer, value: ESObject): ESObject {
    if (value instanceof WearDeviceInfo) {
      stream.writeUint8(this.getByte(129));
      this.writeValue(stream, (value as WearDeviceInfo).toList());
    } else if (value instanceof WatchTransformTheme) {
      stream.writeUint8(this.getByte(130));
      this.writeValue(stream, (value as WatchTransformTheme).toList());
    } else {
      super.writeValue(stream, value);
    }
  }
}


export interface Result<T> {
  success(result: T): void;

  error(error: Error): void;
}
/* Generated abstract class from Pigeon that represents a handler of messages from Flutter.*/
export abstract class WearEngineHostApi {

  abstract hasAvailableDevices(): boolean;

  abstract checkConnectedDevice(result: Result<WearDeviceInfo | undefined>): void;

  abstract registerMessageReceiver(): boolean;

  abstract sendTextMessage(message: string): boolean;
  /* 添加表盘*/
  abstract addWatchSurface(result: Result<boolean>): void;
  /* 添加或者删除主题*/
  abstract syncWatchTheme(theme: WatchTransformTheme | undefined, result: Result<boolean>): void;
  /*
  *  Opens the system photo picker and returns a local PNG file path after
  *  removing the image background on the host platform.
  */
  abstract removeBackground(originImagePath: string, result: Result<string | undefined>): void;
  /* 是否有已安装的表盘*/
  abstract hasInstalledWatchSurface(result: Result<boolean>): void;
  /** The codec used by WearEngineHostApi. */
  static getCodec(): MessageCodec<Object> {
    return PigeonCodec.INSTANCE;
  }
  /*Sets up an instance of `WearEngineHostApi` to handle messages through the `binaryMessenger`.*/
  static setup(binaryMessenger: BinaryMessenger, api: WearEngineHostApi | null, messageChannelSuffix: string = ''): void {
    const separatedMessageChannelSuffix: string = messageChannelSuffix !== '' ? '.' + messageChannelSuffix : '';
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.hasAvailableDevices' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              let res: Array<Object | null> = [];
              try {
                let output: boolean = api!.hasAvailableDevices();
                res.push(output);
              } catch (error) {
                let wrappedError: Array<Object | null> = wrapError(error);
                res = wrappedError;
              }
              reply.reply(res);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.checkConnectedDevice' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              class ResultImp implements Result<WearDeviceInfo | undefined>{
                    success(result: WearDeviceInfo | undefined): void {
                      let res: Array<Object | null> = [];
                      res.push(result);
                      reply.reply(res);
                    }

                    error(error: Error): void {
                      let wrappedError: Array<Object | null> = wrapError(error);
                      reply.reply(wrappedError);
                    }
              }
              let resultCallback: Result<WearDeviceInfo | undefined> = new ResultImp();

              api!.checkConnectedDevice(resultCallback);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.registerMessageReceiver' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              let res: Array<Object | null> = [];
              try {
                let output: boolean = api!.registerMessageReceiver();
                res.push(output);
              } catch (error) {
                let wrappedError: Array<Object | null> = wrapError(error);
                res = wrappedError;
              }
              reply.reply(res);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.sendTextMessage' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              if (!(Array.isArray(message))) {
                  reply.reply(wrapError(new Error('Invalid Pigeon message: expected List.')));
                  return;
              }
              let args: Array<Object> = message as Array<Object>;
              if (args.length < 1) {
                  reply.reply(wrapError(new Error('Invalid Pigeon message: expected at least 1 argument(s).')));
                  return;
              }
              let res: Array<Object | null> = [];
              try {
                let output: boolean = api!.sendTextMessage(args[0] as string);
                res.push(output);
              } catch (error) {
                let wrappedError: Array<Object | null> = wrapError(error);
                res = wrappedError;
              }
              reply.reply(res);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.addWatchSurface' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              class ResultImp implements Result<boolean>{
                    success(result: boolean): void {
                      let res: Array<Object | null> = [];
                      res.push(result);
                      reply.reply(res);
                    }

                    error(error: Error): void {
                      let wrappedError: Array<Object | null> = wrapError(error);
                      reply.reply(wrappedError);
                    }
              }
              let resultCallback: Result<boolean> = new ResultImp();

              api!.addWatchSurface(resultCallback);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.syncWatchTheme' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              if (!(Array.isArray(message))) {
                  reply.reply(wrapError(new Error('Invalid Pigeon message: expected List.')));
                  return;
              }
              let args: Array<Object> = message as Array<Object>;
              if (args.length < 1) {
                  reply.reply(wrapError(new Error('Invalid Pigeon message: expected at least 1 argument(s).')));
                  return;
              }
              class ResultImp implements Result<boolean>{
                    success(result: boolean): void {
                      let res: Array<Object | null> = [];
                      res.push(result);
                      reply.reply(res);
                    }

                    error(error: Error): void {
                      let wrappedError: Array<Object | null> = wrapError(error);
                      reply.reply(wrappedError);
                    }
              }
              let resultCallback: Result<boolean> = new ResultImp();

              api!.syncWatchTheme(args[0] as WatchTransformTheme | undefined, resultCallback);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.removeBackground' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              if (!(Array.isArray(message))) {
                  reply.reply(wrapError(new Error('Invalid Pigeon message: expected List.')));
                  return;
              }
              let args: Array<Object> = message as Array<Object>;
              if (args.length < 1) {
                  reply.reply(wrapError(new Error('Invalid Pigeon message: expected at least 1 argument(s).')));
                  return;
              }
              class ResultImp implements Result<string | undefined>{
                    success(result: string | undefined): void {
                      let res: Array<Object | null> = [];
                      res.push(result);
                      reply.reply(res);
                    }

                    error(error: Error): void {
                      let wrappedError: Array<Object | null> = wrapError(error);
                      reply.reply(wrappedError);
                    }
              }
              let resultCallback: Result<string | undefined> = new ResultImp();

              api!.removeBackground(args[0] as string, resultCallback);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
    {
      let channel: BasicMessageChannel<Object> =
          new BasicMessageChannel(
              binaryMessenger, 'dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.hasInstalledWatchSurface' + separatedMessageChannelSuffix, WearEngineHostApi.getCodec());
      if (api != null) {
        channel.setMessageHandler({
            onMessage(message: Object, reply: Reply<Object>) {
              class ResultImp implements Result<boolean>{
                    success(result: boolean): void {
                      let res: Array<Object | null> = [];
                      res.push(result);
                      reply.reply(res);
                    }

                    error(error: Error): void {
                      let wrappedError: Array<Object | null> = wrapError(error);
                      reply.reply(wrappedError);
                    }
              }
              let resultCallback: Result<boolean> = new ResultImp();

              api!.hasInstalledWatchSurface(resultCallback);
            } });
      } else {
        channel.setMessageHandler(null);
      }
    }
  }
}