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

package/lib/types/Socket.d.ts

@@ -0,0 +1,272 @@
+/**
+ * @typedef {"ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex"} BufferEncoding
+ *
+ * @typedef {import('react-native').NativeEventEmitter} NativeEventEmitter
+ *
+ * @typedef {{address: string, family: string, port: number}} AddressInfo
+ *
+ * @typedef {{localAddress: string, localPort: number, remoteAddress: string, remotePort: number, remoteFamily: string}} NativeConnectionInfo
+ *
+ * @typedef {{
+ * port: number;
+ * host?: string;
+ * localAddress?: string,
+ * localPort?: number,
+ * interface?: 'wifi' | 'cellular' | 'ethernet',
+ * reuseAddress?: boolean,
+ * tls?: boolean,
+ * tlsCheckValidity?: boolean,
+ * tlsCert?: any,
+ * }} ConnectionOptions
+ *
+ * @typedef {object} ReadableEvents
+ * @property {() => void} pause
+ * @property {() => void} resume
+ *
+ * @typedef {object} SocketEvents
+ * @property {(had_error: boolean) => void} close
+ * @property {() => void} connect
+ * @property {(data: Buffer | string) => void} data
+ * @property {() => void} drain
+ * @property {(err: Error) => void} error
+ * @property {() => void} timeout
+ * @property {() => void} secureConnect
+ *
+ * @extends {EventEmitter<SocketEvents & ReadableEvents, any>}
+ */
+export default class Socket extends EventEmitter<SocketEvents & ReadableEvents, any> {
+    /** @package */
+    _id: number;
+    /** @private */
+    private _eventEmitter;
+    /** @type {EventEmitter<'written', any>} @private */
+    private _msgEvtEmitter;
+    /** @type {number} @private */
+    private _timeoutMsecs;
+    /** @type {number | undefined} @private */
+    private _timeout;
+    /** @private */
+    private _encoding;
+    /** @private */
+    private _msgId;
+    /** @private */
+    private _lastRcvMsgId;
+    /** @private */
+    private _lastSentMsgId;
+    /** @private */
+    private _paused;
+    /** @private */
+    private _resuming;
+    /** @private */
+    private _writeBufferSize;
+    /** @private */
+    private _bytesRead;
+    /** @private */
+    private _bytesWritten;
+    /** @private */
+    private _connecting;
+    /** @private */
+    private _pending;
+    /** @private */
+    private _destroyed;
+    /** @type {'opening' | 'open' | 'readOnly' | 'writeOnly'} @private */
+    private _readyState;
+    /** @type {{ id: number; data: string; }[]} @private */
+    private _pausedDataEvents;
+    readableHighWaterMark: number;
+    writableHighWaterMark: number;
+    writableNeedDrain: boolean;
+    localAddress: string | undefined;
+    localPort: number | undefined;
+    remoteAddress: string | undefined;
+    remotePort: number | undefined;
+    remoteFamily: string | undefined;
+    get readyState(): "opening" | "open" | "readOnly" | "writeOnly";
+    get destroyed(): boolean;
+    get pending(): boolean;
+    get connecting(): boolean;
+    get bytesWritten(): number;
+    get bytesRead(): number;
+    get timeout(): number | undefined;
+    /**
+     * @package
+     * @param {number} id
+     */
+    _setId(id: number): void;
+    /**
+     * @package
+     * @param {NativeConnectionInfo} connectionInfo
+     */
+    _setConnected(connectionInfo: NativeConnectionInfo): void;
+    /**
+     * @param {ConnectionOptions} options
+     * @param {() => void} [callback]
+     */
+    connect(options: ConnectionOptions, callback?: (() => void) | undefined): Socket;
+    /**
+     * Sets the socket to timeout after `timeout` milliseconds of inactivity on the socket. By default `TcpSocket` do not have a timeout.
+     *
+     * When an idle timeout is triggered the socket will receive a `'timeout'` event but the connection will not be severed.
+     * The user must manually call `socket.end()` or `socket.destroy()` to end the connection.
+     *
+     * If `timeout` is 0, then the existing idle timeout is disabled.
+     *
+     * The optional `callback` parameter will be added as a one-time listener for the `'timeout'` event.
+     *
+     * @param {number} timeout
+     * @param {() => void} [callback]
+     */
+    setTimeout(timeout: number, callback?: (() => void) | undefined): Socket;
+    /**
+     * @private
+     * @param {number} [timeout]
+     */
+    private _activateTimer;
+    /**
+     * @private
+     */
+    private _clearTimeout;
+    /**
+     * Set the encoding for the socket as a Readable Stream. By default, no encoding is assigned and stream data will be returned as `Buffer` objects.
+     * Setting an encoding causes the stream data to be returned as strings of the specified encoding rather than as Buffer objects.
+     *
+     * For instance, calling `socket.setEncoding('utf8')` will cause the output data to be interpreted as UTF-8 data, and passed as strings.
+     * Calling `socket.setEncoding('hex')` will cause the data to be encoded in hexadecimal string format.
+     *
+     * @param {BufferEncoding} [encoding]
+     */
+    setEncoding(encoding?: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex" | undefined): Socket;
+    /**
+     * Enable/disable the use of Nagle's algorithm. When a TCP connection is created, it will have Nagle's algorithm enabled.
+     *
+     * Nagle's algorithm delays data before it is sent via the network. It attempts to optimize throughput at the expense of latency.
+     *
+     * Passing `true` for `noDelay` or not passing an argument will disable Nagle's algorithm for the socket. Passing false for noDelay will enable Nagle's algorithm.
+     *
+     * @param {boolean} noDelay Default: `true`
+     */
+    setNoDelay(noDelay?: boolean): Socket;
+    /**
+     * Enable/disable keep-alive functionality, and optionally set the initial delay before the first keepalive probe is sent on an idle socket.
+     *
+     * `initialDelay` is ignored.
+     *
+     * @param {boolean} enable Default: `false`
+     * @param {number} initialDelay ***IGNORED**. Default: `0`
+     */
+    setKeepAlive(enable?: boolean, initialDelay?: number): Socket;
+    /**
+     * Returns the bound `address`, the address `family` name and `port` of the socket as reported
+     * by the operating system: `{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`.
+     *
+     * @returns {AddressInfo | {}}
+     */
+    address(): AddressInfo | {};
+    /**
+     * Half-closes the socket. i.e., it sends a FIN packet. It is possible the server will still send some data.
+     *
+     * @param {string | Buffer | Uint8Array} [data]
+     * @param {BufferEncoding} [encoding]
+     */
+    end(data?: string | Buffer | Uint8Array | undefined, encoding?: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex" | undefined): Socket;
+    /**
+     * Ensures that no more I/O activity happens on this socket. Destroys the stream and closes the connection.
+     */
+    destroy(): Socket;
+    /**
+     * Sends data on the socket. The second parameter specifies the encoding in the case of a string — it defaults to UTF8 encoding.
+     *
+     * Returns `true` if the entire data was flushed successfully to the kernel buffer. Returns `false` if all or part of the data
+     * was queued in user memory. `'drain'` will be emitted when the buffer is again free.
+     *
+     * The optional callback parameter will be executed when the data is finally written out, which may not be immediately.
+     *
+     * @param {string | Buffer | Uint8Array} buffer
+     * @param {BufferEncoding} [encoding]
+     * @param {(err?: Error) => void} [cb]
+     *
+     * @return {boolean}
+     */
+    write(buffer: string | Buffer | Uint8Array, encoding?: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex" | undefined, cb?: ((err?: Error | undefined) => void) | undefined): boolean;
+    /**
+     * Pauses the reading of data. That is, `'data'` events will not be emitted. Useful to throttle back an upload.
+     */
+    pause(): void;
+    /**
+     * Resumes reading after a call to `socket.pause()`.
+     */
+    resume(): void;
+    ref(): void;
+    unref(): void;
+    /**
+     * @private
+     */
+    private _recoverDataEventsAfterPause;
+    /**
+     * @private
+     */
+    private _onDeviceDataEvt;
+    /**
+     * @private
+     */
+    private _registerEvents;
+    _dataListener: import("react-native").EmitterSubscription | undefined;
+    _errorListener: import("react-native").EmitterSubscription | undefined;
+    _closeListener: import("react-native").EmitterSubscription | undefined;
+    _connectListener: import("react-native").EmitterSubscription | undefined;
+    _writtenListener: import("react-native").EmitterSubscription | undefined;
+    /**
+     * @package
+     */
+    _unregisterEvents(): void;
+    /**
+     * @private
+     * @param {string | Buffer | Uint8Array} buffer
+     * @param {BufferEncoding} [encoding]
+     */
+    private _generateSendBuffer;
+    /**
+     * @private
+     */
+    private _setDisconnected;
+}
+export type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
+export type NativeEventEmitter = import("react-native").NativeEventEmitter;
+export type AddressInfo = {
+    address: string;
+    family: string;
+    port: number;
+};
+export type NativeConnectionInfo = {
+    localAddress: string;
+    localPort: number;
+    remoteAddress: string;
+    remotePort: number;
+    remoteFamily: string;
+};
+export type ConnectionOptions = {
+    port: number;
+    host?: string | undefined;
+    localAddress?: string | undefined;
+    localPort?: number | undefined;
+    interface?: "wifi" | "cellular" | "ethernet" | undefined;
+    reuseAddress?: boolean | undefined;
+    tls?: boolean | undefined;
+    tlsCheckValidity?: boolean | undefined;
+    tlsCert?: any;
+};
+export type ReadableEvents = {
+    pause: () => void;
+    resume: () => void;
+};
+export type SocketEvents = {
+    close: (had_error: boolean) => void;
+    connect: () => void;
+    data: (data: Buffer | string) => void;
+    drain: () => void;
+    error: (err: Error) => void;
+    timeout: () => void;
+    secureConnect: () => void;
+};
+import EventEmitter from "eventemitter3";
+import { Buffer } from "buffer";

package/lib/types/TLSServer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @typedef {object} TLSServerOptions
+ * @property {any} keystore
+ *
+ * @extends {Server}
+ */
+export default class TLSServer extends Server {
+    /**
+     * @param {(socket: TLSSocket) => void} [secureConnectionListener] Automatically set as a listener for the `'secureConnection'` event.
+     */
+    constructor(secureConnectionListener?: ((socket: TLSSocket) => void) | undefined);
+    /**
+     * @param {TLSServerOptions} options TLS server options
+     */
+    setSecureContext(options: TLSServerOptions): void;
+    /** @private */
+    private _options;
+    /**
+     * @private
+     */
+    private _registerTLSEvents;
+    _secureConnectionListener: import("react-native").EmitterSubscription | undefined;
+}
+export type TLSServerOptions = {
+    keystore: any;
+};
+import Server from "./Server";
+import TLSSocket from "./TLSSocket";

package/lib/types/TLSSocket.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @typedef {object} TLSSocketOptions
+ * @property {any} [ca]
+ * @property {any} [key]
+ * @property {any} [cert]
+ * @property {string} [androidKeyStore]
+ * @property {string} [certAlias]
+ * @property {string} [keyAlias]
+ * @property {string[]} [resolvedKeys]
+ *
+ * @extends {Socket}
+ */
+export default class TLSSocket extends Socket {
+    /**
+     * @private
+     * Resolves the asset source if necessary and registers the resolved key.
+     * @param {TLSSocketOptions} options The options object containing the source to be resolved.
+     * @param {'ca' | 'key' | 'cert'} key The key name being resolved.
+     */
+    private static resolveAssetIfNeeded;
+    /**
+     * @param {Socket} socket Any instance of `Socket`.
+     * @param {TLSSocketOptions} [options] Options for the TLS socket.
+     */
+    constructor(socket: Socket, options?: TLSSocketOptions | undefined);
+    /** @private */
+    private _options;
+    /** @private */
+    private _socket;
+    /**
+     * @private
+     */
+    private _initialize;
+    /**
+     * @private
+     */
+    private _startTLS;
+    getCertificate(): any;
+    getPeerCertificate(): any;
+}
+export type TLSSocketOptions = {
+    ca?: any;
+    key?: any;
+    cert?: any;
+    androidKeyStore?: string | undefined;
+    certAlias?: string | undefined;
+    keyAlias?: string | undefined;
+    resolvedKeys?: string[] | undefined;
+};
+import Socket from "./Socket";

package/lib/types/index.d.ts

@@ -0,0 +1,62 @@
+declare namespace _default {
+    export { createConnection as connect };
+    export { createServer };
+    export { createConnection };
+    export { createTLSServer };
+    export { connectTLS };
+    export { isIP };
+    export { isIPv4 };
+    export { isIPv6 };
+    export { Server };
+    export { Socket };
+    export { TLSServer };
+    export { TLSSocket };
+}
+export default _default;
+/**
+ * @param {import('./Socket').ConnectionOptions} options
+ * @param {() => void} callback
+ * @returns {Socket}
+ */
+declare function createConnection(options: import('./Socket').ConnectionOptions, callback: () => void): Socket;
+/**
+ * @param {(socket: Socket) => void} connectionListener
+ * @returns {Server}
+ */
+declare function createServer(connectionListener: (socket: Socket) => void): Server;
+/**
+ * @param {import('./TLSServer').TLSServerOptions} options
+ * @param {(socket: TLSSocket) => void} connectionListener
+ * @returns {TLSServer}
+ */
+declare function createTLSServer(options: import('./TLSServer').TLSServerOptions, connectionListener: (socket: TLSSocket) => void): TLSServer;
+/**
+ * The `callback` function, if specified, will be added as a listener for the `'secureConnect'` event.
+ *
+ * @param {import('./TLSSocket').TLSSocketOptions & import('./Socket').ConnectionOptions} options
+ * @param {() => void} [callback]
+ * @returns {TLSSocket}
+ */
+declare function connectTLS(options: import('./TLSSocket').TLSSocketOptions & import('./Socket').ConnectionOptions, callback?: (() => void) | undefined): TLSSocket;
+/**
+ * Tests if input is an IP address. Returns `0` for invalid strings, returns `4` for IP version 4 addresses, and returns `6` for IP version 6 addresses.
+ *
+ * @param {string} input
+ */
+declare function isIP(input: string): 0 | 4 | 6;
+/**
+ * Returns `true` if input is a version 4 IP address, otherwise returns `false`.
+ *
+ * @param {string} input
+ */
+declare function isIPv4(input: string): boolean;
+/**
+ * Returns `true` if input is a version 6 IP address, otherwise returns `false`.
+ *
+ * @param {string} input
+ */
+declare function isIPv6(input: string): boolean;
+import Server from "./Server";
+import Socket from "./Socket";
+import TLSServer from "./TLSServer";
+import TLSSocket from "./TLSSocket";

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@react-native-ohos/react-native-tcp-socket",
+  "title": "React Native Tcp Socket",
+  "version": "6.2.1-rc.1",
+  "description": "React Native TCP socket API for HarmonyOS with SSL/TLS support",
+  "main": "src/index.js",
+  "types": "lib/types/index.d.ts",
+  "scripts": {
+    "ci": "yarn install --frozen-lockfile && yarn lint && yarn declaration:build && yarn checkjs && yarn test",
+    "lint": "eslint .",
+    "checkjs": "tsc && tsc -p ./__tests__/tsconfig.json",
+    "test": "jest ./__tests__",
+    "declaration:build": "tsc -p ./declaration.tsconfig.json",
+    "prepublishOnly": "yarn declaration:build && yarn checkjs",
+    "codegen-lib": "react-native codegen-lib-harmony --no-safety-check --npm-package-name react-native-tcp-socket --cpp-output-path ./harmony/tcp_socket/src/main/cpp/generated --ets-output-path ./harmony/tcp_socket/src/main/ets/generated --turbo-modules-spec-paths ./src --arkts-components-spec-paths ./src"
+  },
+  "files": [
+    "/src",
+    "/lib",
+    "/harmony"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitcode.com/openharmony-sig/rntpc_react-native-tcp-socket.git",
+    "baseUrl": "https://gitcode.com/openharmony-sig/rntpc_react-native-tcp-socket"
+  },
+  "keywords": [
+    "react-native",
+    "harmony",
+    "tcp-socket",
+    "tls",
+    "ssl",
+    "tcp-server",
+    "tcp-client",
+    "tcp",
+    "react-native-library"
+  ],
+  "harmony": {
+    "alias": "react-native-tcp-socket",
+    "autolinking": {
+      "etsPackageClassName":"TcpSocketPackage",
+      "cppPackageClassName":"TcpSocketPackage",
+      "cmakeLibraryTargetName": "rnoh_tcp_socket",
+      "ohPackageName": "@react-native-ohos/react-native-tcp-socket"
+    }
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/sponsors/Rapsssito"
+  },
+  "author": {
+    "name": "Rapsssito",
+    "email": "contact@rodrigomartin.dev"
+  },
+  "license": "MIT",
+  "licenseFilename": "LICENSE",
+  "readmeFilename": "README.md",
+  "peerDependencies": {
+    "react-native": ">=0.60.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.7.7",
+    "@semantic-release/changelog": "^5.0.0",
+    "@semantic-release/git": "^9.0.0",
+    "@semantic-release/github": "^7.0.0",
+    "@semantic-release/npm": "^7.0.0",
+    "@types/eventemitter3": "^2.0.2",
+    "@types/jest": "^25.1.3",
+    "@types/react-native": "^0.61.17",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^24.9.0",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.5.0",
+    "eslint-plugin-jest": "^23.6.0",
+    "eslint-plugin-jsdoc": "^21.0.0",
+    "eslint-plugin-prettier": "^3.1.1",
+    "jest": "^26.6.3",
+    "metro-react-native-babel-preset": "^0.58.0",
+    "prettier": "^1.18.2",
+    "react": "16.9.0",
+    "react-native": "0.60.5",
+    "semantic-release": "^17.0.1",
+    "typescript": "^4.1.3"
+  },
+  "dependencies": {
+    "buffer": "^5.4.3",
+    "eventemitter3": "^4.0.7",
+    "react-native-tcp-socket": "6.2.0"
+  }
+}

package/src/Globals.js

@@ -0,0 +1,12 @@
+import { DeviceEventEmitter } from 'react-native';
+
+
+let instanceNumber = 0;
+
+function getNextId() {
+    return instanceNumber++;
+}
+
+const nativeEventEmitter = DeviceEventEmitter;
+
+export { nativeEventEmitter, getNextId };