@react-native-ohos/react-native-tcp-socket 6.3.1-rc.1

package/harmony/tcp_socket/src/main/ets/TcpSocketTurboModule.ts

@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+import { TurboModule, RNOHError, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { TM } from "./generated/ts"
+import { TcpEventListener } from "./TcpEventListener"
+import { connection } from '@kit.NetworkKit';
+import { BusinessError } from '@kit.BasicServicesKit';
+import { TcpSocket } from './TcpSocket'
+import Logger from './Logger'
+import { TcpSocketClient } from './TcpSocketClient'
+import { TcpSocketServer } from './TcpSocketServer'
+import { util } from '@kit.ArkTS';
+import { Context } from '@kit.AbilityKit';
+
+export class TcpSocketTurboModule extends TurboModule implements TM.TcpSocketModule.Spec {
+  private socketMap: Map<number, TcpSocket> = new Map<number, TcpSocket>();
+  private pendingTLS: Map<number, Object> = new Map<number, Object>();
+  private mNetworkMap: Map<string, connection.ConnectionProperties> =
+    new Map<string, connection.ConnectionProperties>();
+  private tcpEvtListener?: TcpEventListener;
+  private currentNetwork?: connection.ConnectionProperties;
+  private context: Context;
+
+  constructor(ctx: TurboModuleContext) {
+    super(ctx)
+    this.tcpEvtListener = new TcpEventListener(ctx);
+    this.context = ctx.uiAbilityContext
+  }
+
+  private getTcpClient(cid: number): TcpSocketClient | undefined {
+    let socket: TcpSocket | undefined = this.socketMap.get(cid);
+    if (socket && (socket instanceof TcpSocketClient)) {
+      return socket as TcpSocketClient;
+    }
+    return undefined;
+  }
+
+  private getTcpServer(cid: number): TcpSocketServer | undefined {
+    let socket: TcpSocket | undefined = this.socketMap.get(cid);
+    if (socket && (socket instanceof TcpSocketServer)) {
+      return socket as TcpSocketServer;
+    }
+    return undefined;
+  }
+
+  private async requestNetwork(transportType: number, iotDeviceHost: string): Promise<void> {
+    if (!iotDeviceHost || "localhost" === iotDeviceHost) {
+      this.getDefaultNetInfo();
+    } else {
+      let netHandles = connection.getAllNetsSync();
+      for (const netHandle of netHandles) {
+        let conpro = connection.getNetCapabilitiesSync(netHandle);
+        if (conpro.bearerTypes.includes(transportType)) {
+          await connection.setAppNet(netHandle, (error: BusinessError, data: void) => {
+            if (error) {
+              Logger.error(`setAppNet error. Code:${error.code}, message:${error.message}`);
+              return;
+            }
+            Logger.info("setAppNet Succeeded");
+            this.currentNetwork = connection.getConnectionPropertiesSync(netHandle);
+          });
+        }
+      }
+    }
+  }
+
+  private getDefaultNetInfo() {
+    if (!connection.hasDefaultNetSync()) {
+      Logger.info("has not default net")
+      return;
+    }
+    let netHandle: connection.NetHandle = connection.getDefaultNetSync();
+    this.currentNetwork = connection.getConnectionPropertiesSync(netHandle);
+  }
+
+  private async selectNetwork(ipAddress: string, iface: string, iotDeviceHost: string): Promise<void> {
+    if (!iface) {
+      return;
+    }
+    if (ipAddress) {
+      let cachedNetwork = this.mNetworkMap.get(iface + ipAddress);
+      if (cachedNetwork) {
+        this.currentNetwork = cachedNetwork;
+      }
+    }
+    switch (iface) {
+      case 'wifi':
+        await this.requestNetwork(connection.NetBearType.BEARER_WIFI, iotDeviceHost);
+        break;
+      case 'cellular':
+        await this.requestNetwork(connection.NetBearType.BEARER_CELLULAR, iotDeviceHost);
+        break;
+      case 'ethernet':
+        await this.requestNetwork(connection.NetBearType.BEARER_ETHERNET, iotDeviceHost);
+        break;
+    }
+    if (!this.currentNetwork) {
+      throw new Error("Interface " + iface + " unreachable");
+    } else {
+      this.mNetworkMap.set(iface + ipAddress, this.currentNetwork);
+    }
+  }
+
+  async connect(cId: number, host: string, port: number, options: Object): Promise<void> {
+    if (this.socketMap.get(cId)) {
+      this.tcpEvtListener?.onError(cId, "connect() called twice with the same id.");
+      return;
+    }
+    try {
+      let localAddress: string = options['localAddress'];
+      let iface: string = options['interface'];
+      let iotDeviceHost: string = options['host'];
+      this.selectNetwork(localAddress, iface, iotDeviceHost);
+      let client: TcpSocketClient = new TcpSocketClient(this.tcpEvtListener, cId);
+      this.socketMap.set(cId, client);
+      let tlsOptions = this.pendingTLS.get(cId);
+      await client.connect(host, port, options, tlsOptions);
+      this.tcpEvtListener?.onConnect(cId, client);
+    } catch (err) {
+      this.tcpEvtListener?.onError(cId, err?.message);
+    }
+  }
+
+  startTLS(cId: number, tlsOptions: Object): void {
+    let socketClient: TcpSocketClient = this.socketMap.get(cId) as TcpSocketClient;
+    if (!socketClient) {
+      this.pendingTLS.set(cId, tlsOptions);
+    } else {
+      try {
+        socketClient.startTLS(tlsOptions);
+      } catch (e) {
+        this.tcpEvtListener?.onError(cId, JSON.stringify(e));
+      }
+    }
+  }
+
+  listen(cId: number, options: Object): void {
+    let tcpSocketServer = new TcpSocketServer(this.socketMap, this.tcpEvtListener, cId, options);
+    this.socketMap.set(cId, tcpSocketServer);
+    this.tcpEvtListener.onListen(cId, tcpSocketServer);
+  }
+
+  close(cid: number): void {
+    let socketServer: TcpSocketServer = this.getTcpServer(cid);
+    socketServer?.close();
+    let socketClient: TcpSocketClient = this.getTcpClient(cid);
+    socketClient?.destroy();
+    this.socketMap.delete(cid);
+  }
+
+  destroy(cid: number): void {
+    this.end(cid);
+  }
+
+  end(cid: number): void {
+    let socketClient = this.getTcpClient(cid);
+    socketClient?.destroy();
+    this.socketMap.delete(cid);
+  }
+
+  pause(cid: number): void {
+    let socketClient = this.getTcpClient(cid);
+    socketClient?.pause();
+  }
+
+  resume(cid: number): void {
+    let socketClient = this.getTcpClient(cid);
+    socketClient?.resume();
+  }
+
+  write(cId: number, base64String: string, msgId: number): void {
+    let socketClient = this.getTcpClient(cId);
+    let base64Helper = new util.Base64Helper;
+    let uint8Array = base64Helper.decodeSync(base64String)
+    let buffer = uint8Array.buffer as ArrayBuffer;
+    socketClient?.write(msgId, buffer);
+  }
+
+  setNoDelay(cId: number, noDelay: boolean): void {
+    try {
+      let socketClient = this.getTcpClient(cId);
+      socketClient?.setNoDelay(noDelay);
+    } catch (e) {
+      this.tcpEvtListener?.onError(cId, JSON.stringify(e));
+    }
+  }
+
+  setKeepAlive(cId: number, enable: boolean, initialDelay: number): void {
+    try {
+      let socketClient: TcpSocketClient = this.getTcpClient(cId);
+      socketClient?.setKeepAlive(enable);
+    } catch (e) {
+      this.tcpEvtListener?.onError(cId, JSON.stringify(e));
+    }
+  }
+
+  getPeerCertificate(cId: number): Promise<string> {
+    try {
+      let socketClient = this.getTcpClient(cId);
+      return socketClient?.getPeerCertificate();
+    } catch (e) {
+      this.tcpEvtListener?.onError(cId, JSON.stringify(e));
+      return new Promise<string>(() => {
+        return ""
+      });
+    }
+  }
+
+  getCertificate(cId: number): Promise<string> {
+    try {
+      let socketClient = this.getTcpClient(cId);
+      return socketClient?.getCertificate();
+    } catch (e) {
+      this.tcpEvtListener?.onError(cId, JSON.stringify(e));
+      return new Promise<string>(() => {
+        return ""
+      });
+    }
+  }
+}
+

package/harmony/tcp_socket/src/main/ets/generated/components/ts.ts

@@ -0,0 +1,5 @@
+
+/**
+ */
+
+export {}

package/harmony/tcp_socket/src/main/ets/generated/index.ets

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./ts"

package/harmony/tcp_socket/src/main/ets/generated/ts.ts

@@ -0,0 +1,6 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * as RNC from "./components/ts"
+export * as TM from "./turboModules/ts"

package/harmony/tcp_socket/src/main/ets/generated/turboModules/TcpSocketModule.ts

@@ -0,0 +1,38 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+import { Tag } from "@rnoh/react-native-openharmony/ts"
+
+export namespace TcpSocketModule {
+  export const NAME = 'TcpSocketModule' as const
+
+  export interface Spec {
+    listen(cId: number, options: Object): void;
+  
+    close(cid: number): void;
+  
+    destroy(cid: number): void;
+  
+    end(cid: number): void;
+  
+    pause(cid: number): void;
+  
+    resume(cid: number): void;
+  
+    connect(cId: number, host: string, port: number, options: Object): void;
+  
+    startTLS(cId: number, tlsOptions: Object): void;
+  
+    write(cId: number, base64String: string, msgId: number): void;
+  
+    setNoDelay(cId: number, noDelay: boolean): void;
+  
+    setKeepAlive(cId: number, enable: boolean, initialDelay: number): void;
+  
+    getPeerCertificate(cId: number): Promise<string>;
+  
+    getCertificate(cId: number): Promise<string>;
+  
+  }
+}

package/harmony/tcp_socket/src/main/ets/generated/turboModules/ts.ts

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./TcpSocketModule"

package/harmony/tcp_socket/src/main/module.json5

@@ -0,0 +1,11 @@
+{
+  "module": {
+    "name": "tcp_socket",
+    "type": "har",
+    "deviceTypes": [
+      "default",
+      "tablet",
+      "2in1"
+    ]
+  }
+}

package/harmony/tcp_socket/src/main/resources/base/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/tcp_socket/src/main/resources/en_US/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/tcp_socket/src/main/resources/zh_CN/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/tcp_socket/src/ohosTest/ets/test/Ability.test.ets

@@ -0,0 +1,35 @@
+import { hilog } from '@kit.PerformanceAnalysisKit';
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium';
+
+export default function abilityTest() {
+  describe('ActsAbilityTest', () => {
+    // Defines a test suite. Two parameters are supported: test suite name and test suite function.
+    beforeAll(() => {
+      // Presets an action, which is performed only once before all test cases of the test suite start.
+      // This API supports only one parameter: preset action function.
+    })
+    beforeEach(() => {
+      // Presets an action, which is performed before each unit test case starts.
+      // The number of execution times is the same as the number of test cases defined by **it**.
+      // This API supports only one parameter: preset action function.
+    })
+    afterEach(() => {
+      // Presets a clear action, which is performed after each unit test case ends.
+      // The number of execution times is the same as the number of test cases defined by **it**.
+      // This API supports only one parameter: clear action function.
+    })
+    afterAll(() => {
+      // Presets a clear action, which is performed after all test cases of the test suite end.
+      // This API supports only one parameter: clear action function.
+    })
+    it('assertContain', 0, () => {
+      // Defines a test case. This API supports three parameters: test case name, filter parameter, and test case function.
+      hilog.info(0x0000, 'testTag', '%{public}s', 'it begin');
+      let a = 'abc';
+      let b = 'b';
+      // Defines a variety of assertion methods, which are used to declare expected boolean conditions.
+      expect(a).assertContain(b);
+      expect(a).assertEqual(a);
+    })
+  })
+}

package/harmony/tcp_socket/src/ohosTest/ets/test/List.test.ets

@@ -0,0 +1,5 @@
+import abilityTest from './Ability.test';
+
+export default function testsuite() {
+  abilityTest();
+}

package/harmony/tcp_socket/src/ohosTest/module.json5

@@ -0,0 +1,13 @@
+{
+  "module": {
+    "name": "tcp_socket_test",
+    "type": "feature",
+    "deviceTypes": [
+      "default",
+      "tablet",
+      "2in1"
+    ],
+    "deliveryWithInstall": true,
+    "installationFree": false
+  }
+}

package/harmony/tcp_socket/src/test/List.test.ets

@@ -0,0 +1,5 @@
+import localUnitTest from './LocalUnit.test';
+
+export default function testsuite() {
+  localUnitTest();
+}

package/harmony/tcp_socket/src/test/LocalUnit.test.ets

@@ -0,0 +1,33 @@
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium';
+
+export default function localUnitTest() {
+  describe('localUnitTest', () => {
+    // Defines a test suite. Two parameters are supported: test suite name and test suite function.
+    beforeAll(() => {
+      // Presets an action, which is performed only once before all test cases of the test suite start.
+      // This API supports only one parameter: preset action function.
+    });
+    beforeEach(() => {
+      // Presets an action, which is performed before each unit test case starts.
+      // The number of execution times is the same as the number of test cases defined by **it**.
+      // This API supports only one parameter: preset action function.
+    });
+    afterEach(() => {
+      // Presets a clear action, which is performed after each unit test case ends.
+      // The number of execution times is the same as the number of test cases defined by **it**.
+      // This API supports only one parameter: clear action function.
+    });
+    afterAll(() => {
+      // Presets a clear action, which is performed after all test cases of the test suite end.
+      // This API supports only one parameter: clear action function.
+    });
+    it('assertContain', 0, () => {
+      // Defines a test case. This API supports three parameters: test case name, filter parameter, and test case function.
+      let a = 'abc';
+      let b = 'b';
+      // Defines a variety of assertion methods, which are used to declare expected boolean conditions.
+      expect(a).assertContain(b);
+      expect(a).assertEqual(a);
+    });
+  });
+}

package/harmony/tcp_socket/ts.ts

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+export * from "./src/main/ets/TcpSocketPackage";
+export * from "./src/main/ets/TcpSocketTurboModule";

package/lib/types/Globals.d.ts

@@ -0,0 +1,2 @@
+export const nativeEventEmitter: import("react-native").DeviceEventEmitter;
+export function getNextId(): number;

package/lib/types/Server.d.ts

@@ -0,0 +1,138 @@
+/**
+ * @typedef {object} ServerOptions
+ * @property {boolean} [noDelay]
+ * @property {boolean} [keepAlive]
+ * @property {number} [keepAliveInitialDelay]
+ * @property {boolean} [allowHalfOpen]
+ * @property {boolean} [pauseOnConnect]
+ *
+ * @typedef {import('./TLSSocket').default} TLSSocket
+ *
+ * @typedef {object} ServerEvents
+ * @property {() => void} close
+ * @property {(socket: Socket) => void} connection
+ * @property {() => void} listening
+ * @property {(err: Error) => void} error
+ * @property {(tlsSocket: TLSSocket) => void} secureConnection
+ *
+ * @extends {EventEmitter<ServerEvents, any>}
+ */
+export default class Server extends EventEmitter<ServerEvents, any> {
+    /**
+     * @param {ServerOptions | ((socket: Socket) => void)} [options] Server options or connection listener
+     * @param {(socket: Socket) => void} [connectionCallback] Automatically set as a listener for the `'connection'` event.
+     */
+    constructor(options?: ServerOptions | ((socket: Socket) => void) | undefined, connectionCallback?: ((socket: Socket) => void) | undefined);
+    /** @protected @readonly */
+    protected readonly _id: number;
+    /** @protected @readonly */
+    protected readonly _eventEmitter: import("react-native").EventEmitter;
+    /** @private @type {Set<Socket>} */
+    private _connections;
+    /** @private */
+    private _localAddress;
+    /** @private */
+    private _localPort;
+    /** @private */
+    private _localFamily;
+    /** @private @type {ServerOptions} */
+    private _serverOptions;
+    listening: boolean;
+    /**
+     * Start a server listening for connections.
+     *
+     * This function is asynchronous. When the server starts listening, the `'listening'` event will be emitted.
+     * The last parameter `callback` will be added as a listener for the `'listening'` event.
+     *
+     * The `server.listen()` method can be called again if and only if there was an error during the first
+     * `server.listen()` call or `server.close()` has been called. Otherwise, an `ERR_SERVER_ALREADY_LISTEN`
+     * error will be thrown.
+     *
+     * @param {{ port: number; host?: string; reuseAddress?: boolean} | number} options Options or port
+     * @param {string | (() => void)} [callback_or_host] Callback or host string
+     * @param {() => void} [callback] Callback function
+     * @returns {Server}
+     */
+    listen(options: {
+        port: number;
+        host?: string;
+        reuseAddress?: boolean;
+    } | number, callback_or_host?: string | (() => void) | undefined, callback?: (() => void) | undefined): Server;
+    /**
+     * Asynchronously get the number of concurrent connections on the server.
+     *
+     * Callback should take two arguments `err` and `count`.
+     *
+     * @param {(err: Error | null, count: number) => void} callback
+     * @returns {Server}
+     */
+    getConnections(callback: (err: Error | null, count: number) => void): Server;
+    /**
+     * Stops the server from accepting new connections and keeps existing connections.
+     * This function is asynchronous, the server is finally closed when all connections are ended and the server emits a `'close'` event.
+     * The optional callback will be called once the `'close'` event occurs. Unlike that event, it will be called with an `Error` as its
+     * only argument if the server was not open when it was closed.
+     *
+     * @param {(err?: Error) => void} [callback] Called when the server is closed.
+     * @returns {Server}
+     */
+    close(callback?: ((err?: Error | undefined) => void) | undefined): Server;
+    /**
+     * Returns the bound `address`, the address `family` name, and `port` of the server as reported by the operating system if listening
+     * on an IP socket (useful to find which port was assigned when getting an OS-assigned address):
+     * `{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`.
+     *
+     * @returns {import('./Socket').AddressInfo | null}
+     */
+    address(): import('./Socket').AddressInfo | null;
+    ref(): Server;
+    unref(): Server;
+    /**
+     * @private
+     */
+    private _registerEvents;
+    _listeningListener: import("react-native").EmitterSubscription | undefined;
+    _errorListener: import("react-native").EmitterSubscription | undefined;
+    _connectionsListener: import("react-native").EmitterSubscription | undefined;
+    /**
+     * @private
+     */
+    private _setDisconnected;
+    /**
+     * @protected
+     * @param {Socket} socket
+     */
+    protected _addConnection(socket: Socket): void;
+    /**
+     * @protected
+     * @param {{ id: number; connection: import('./Socket').NativeConnectionInfo; }} info
+     * @returns {Socket}
+     */
+    protected _buildSocket(info: {
+        id: number;
+        connection: import('./Socket').NativeConnectionInfo;
+    }): Socket;
+    /**
+     * Apply server socket options to a newly connected socket
+     * @param {Socket} socket
+     * @private
+     */
+    private _applySocketOptions;
+}
+export type ServerOptions = {
+    noDelay?: boolean | undefined;
+    keepAlive?: boolean | undefined;
+    keepAliveInitialDelay?: number | undefined;
+    allowHalfOpen?: boolean | undefined;
+    pauseOnConnect?: boolean | undefined;
+};
+export type TLSSocket = import("./TLSSocket").default;
+export type ServerEvents = {
+    close: () => void;
+    connection: (socket: Socket) => void;
+    listening: () => void;
+    error: (err: Error) => void;
+    secureConnection: (tlsSocket: TLSSocket) => void;
+};
+import EventEmitter from "eventemitter3";
+import Socket from "./Socket";