@ohos.net.socket (Socket连接)

本模块提供利用Socket进行数据传输的能力，支持TCPSocket、UDPSocket、WebSocket和TLSSocket。

说明：

本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。

导入模块

import socket from '@ohos.net.socket';

socket.constructUDPSocketInstance

constructUDPSocketInstance(): UDPSocket

创建一个UDPSocket对象。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from '@ohos.net.socket';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();

UDPSocket

UDPSocket连接。在调用UDPSocket的方法前，需要先通过socket.constructUDPSocketInstance创建UDPSocket对象。

bind

bind(address: NetAddress, callback: AsyncCallback<void>): void

绑定IP地址和端口，端口可以指定或由系统随机分配。使用callback方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 1234
}
udp.bind(bindAddr, (err: BusinessError) => {
  if (err) {
    console.log('bind fail');
    return;
  }
  console.log('bind success');
});

bind

bind(address: NetAddress): Promise<void>

绑定IP地址和端口，端口可以指定或由系统随机分配。使用Promise方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

返回值：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
udp.bind(bindAddr).then(() => {
  console.log('bind success');
}).catch((err: BusinessError) => {
  console.log('bind fail');
});

send

send(options: UDPSendOptions, callback: AsyncCallback<void>): void

通过UDPSocket连接发送数据。使用callback方式作为异步方法。

发送数据前，需要先调用UDPSocket.bind()绑定IP地址和端口。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();

let sendOptions: socket.UDPSendOptions = {
  data: 'Hello, server!',
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  }
}
udp.send(sendOptions, (err: BusinessError) => {
  if (err) {
    console.log('send fail');
    return;
  }
  console.log('send success');
});

send

send(options: UDPSendOptions): Promise<void>

通过UDPSocket连接发送数据。使用Promise方式作为异步方法。

发送数据前，需要先调用UDPSocket.bind()绑定IP地址和端口。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

返回值：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();

let sendOptions: socket.UDPSendOptions = {
  data: 'Hello, server!',
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  }
}
udp.send(sendOptions).then(() => {
  console.log('send success');
}).catch((err: BusinessError) => {
  console.log('send fail');
});

close

close(callback: AsyncCallback<void>): void

关闭UDPSocket连接。使用callback方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
udp.close((err: BusinessError) => {
  if (err) {
    console.log('close fail');
    return;
  }
  console.log('close success');
})

close

close(): Promise<void>

关闭UDPSocket连接。使用Promise方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
udp.close().then(() => {
  console.log('close success');
}).catch((err: BusinessError) => {
  console.log('close fail');
});

getState

getState(callback: AsyncCallback<SocketStateBase>): void

获取UDPSocket状态。使用callback方式作为异步方法。

说明： bind方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
udp.bind(bindAddr, (err: BusinessError) => {
  if (err) {
    console.log('bind fail');
    return;
  }
  console.log('bind success');
  udp.getState((err: BusinessError, data: socket.SocketStateBase) => {
    if (err) {
      console.log('getState fail');
      return;
    }
    console.log('getState success:' + JSON.stringify(data));
  })
})

getState

getState(): Promise<SocketStateBase>

获取UDPSocket状态。使用Promise方式作为异步方法。

说明： bind方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
udp.bind(bindAddr, (err: BusinessError) => {
  if (err) {
    console.log('bind fail');
    return;
  }
  console.log('bind success');
  udp.getState().then((data: socket.SocketStateBase) => {
    console.log('getState success:' + JSON.stringify(data));
  }).catch((err: BusinessError) => {
    console.log('getState fail' + JSON.stringify(err));
  });
});

setExtraOptions

setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback<void>): void

设置UDPSocket连接的其他属性。使用callback方式作为异步方法。

说明： bind方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();

let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
udp.bind(bindAddr, (err: BusinessError) => {
  if (err) {
    console.log('bind fail');
    return;
  }
  console.log('bind success');
  let udpextraoptions: socket.UDPExtraOptions = {
    receiveBufferSize: 1000,
    sendBufferSize: 1000,
    reuseAddress: false,
    socketTimeout: 6000,
    broadcast: true
  }
  udp.setExtraOptions(udpextraoptions, (err: BusinessError) => {
    if (err) {
      console.log('setExtraOptions fail');
      return;
    }
    console.log('setExtraOptions success');
  })
})

setExtraOptions

setExtraOptions(options: UDPExtraOptions): Promise<void>

设置UDPSocket连接的其他属性。使用Promise方式作为异步方法。

说明： bind方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from '@ohos.net.socket';
import { BusinessError } from '@ohos.base';

let udp: socket.UDPSocket = socket.constructUDPSocketInstance();

let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
udp.bind(bindAddr, (err: BusinessError) => {
  if (err) {
    console.log('bind fail');
    return;
  }
  console.log('bind success');
  let udpextraoptions: socket.UDPExtraOptions = {
    receiveBufferSize: 1000,
    sendBufferSize: 1000,
    reuseAddress: false,
    socketTimeout: 6000,
    broadcast: true
  }
  udp.setExtraOptions(udpextraoptions).then(() => {
    console.log('setExtraOptions success');
  }).catch((err: BusinessError) => {
    console.log('setExtraOptions fail');
  });
})

on('message')

on(type: 'message', callback: Callback<SocketMessageInfo>): void

订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();

let messageView = '';
udp.on('message', (value: socket.SocketMessageInfo) => {
  for (let i: number = 0; i < value.message.byteLength; i++) {
    let uint8Array = new Uint8Array(value.message) 
    let messages = uint8Array[i]
    let message = String.fromCharCode(messages);
    messageView += message;
  }
  console.log('on message message: ' + JSON.stringify(messageView));
  console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo));
});

off('message')

off(type: 'message', callback?: Callback<SocketMessageInfo>): void

取消订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let messageView = '';
let callback = (value: socket.SocketMessageInfo) => {
  for (let i: number = 0; i < value.message.byteLength; i++) {
    let uint8Array = new Uint8Array(value.message) 
    let messages = uint8Array[i]
    let message = String.fromCharCode(messages);
    messageView += message;
  }
  console.log('on message message: ' + JSON.stringify(messageView));
  console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo));
}
udp.on('message', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
udp.off('message', callback);
udp.off('message');

on('listening' | 'close')

on(type: 'listening' | 'close', callback: Callback<void>): void

订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
udp.on('listening', () => {
  console.log("on listening success");
});
udp.on('close', () => {
  console.log("on close success");
});

off('listening' | 'close')

off(type: 'listening' | 'close', callback?: Callback<void>): void

取消订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let callback1 = () => {
  console.log("on listening, success");
}
udp.on('listening', callback1);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
udp.off('listening', callback1);
udp.off('listening');
let callback2 = () => {
  console.log("on close, success");
}
udp.on('close', callback2);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
udp.off('close', callback2);
udp.off('close');

on('error')

on(type: 'error', callback: ErrorCallback): void

订阅UDPSocket连接的error事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
udp.on('error', (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err))
});

off('error')

off(type: 'error', callback?: ErrorCallback): void

取消订阅UDPSocket连接的error事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let udp: socket.UDPSocket = socket.constructUDPSocketInstance();
let callback = (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err));
}
udp.on('error', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
udp.off('error', callback);
udp.off('error');

NetAddress

目标地址信息。

系统能力：SystemCapability.Communication.NetStack

UDPSendOptions

UDPSocket发送参数。

系统能力：SystemCapability.Communication.NetStack

UDPExtraOptions

UDPSocket连接的其他属性。

系统能力：SystemCapability.Communication.NetStack

SocketMessageInfo¹¹⁺

socket连接信息

系统能力：SystemCapability.Communication.NetStack

SocketStateBase

Socket的状态信息。

系统能力：SystemCapability.Communication.NetStack

SocketRemoteInfo

Socket的连接信息。

系统能力：SystemCapability.Communication.NetStack

UDP 错误码说明

UDP 其余错误码映射形式为：2301000 + Linux内核错误码。

错误码的详细介绍参见Socket错误码

socket.constructMulticastSocketInstance¹¹⁺

constructMulticastSocketInstance(): MulticastSocket

创建一个MulticastSocket对象。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();

MulticastSocket¹¹⁺

MulticastSocket连接。在调用MulticastSocket的方法前，需要先通过socket.constructMulticastSocketInstance创建MulticastSocket对象。

addMembership¹¹⁺

addMembership(multicastAddress: NetAddress, callback: AsyncCallback<void>): void;

加入多播组。使用callback方法作为异步方法。

说明： 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 加入多播组后，既可以是发送端，也可以是接收端，相互之间以广播的形式传递数据，不区分客户端或服务端。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let addr: socket.NetAddress = {
  address: '239.255.0.1',
  port: 8080
}
multicast.addMembership(addr, (err: Object) => {
  if (err) {
    console.log('add membership fail, err: ' + JSON.stringify(err));
    return;
  }
  console.log('add membership success');
})

addMembership¹¹⁺

addMembership(multicastAddress: NetAddress): Promise<void>;

加入多播组。使用Promise方法作为异步方法。。

说明： 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 加入多播组后，既可以是发送端，也可以是接收端，相互之间以广播的形式传递数据，不区分客户端或服务端。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let addr: socket.NetAddress = {
  address: '239.255.0.1',
  port: 8080
}
multicast.addMembership(addr).then(() => {
  console.log('addMembership success');
}).catch((err: Object) => {
  console.log('addMembership fail');
});

dropMembership¹¹⁺

dropMembership(multicastAddress: NetAddress, callback: AsyncCallback<void>): void;

退出多播组。使用callback方法作为异步方法。

说明： 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 从已加入的多播组中退出，必须在加入多播组 addMembership 之后退出才有效。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let addr: socket.NetAddress = {
  address: '239.255.0.1',
  port: 8080
}
multicast.dropMembership(addr, (err: Object) => {
  if (err) {
    console.log('drop membership fail, err: ' + JSON.stringify(err));
    return;
  }
  console.log('drop membership success');
})

dropMembership¹¹⁺

dropMembership(multicastAddress: NetAddress): Promise<void>;

退出多播组。使用Promise方法作为异步方法。。

说明： 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 从已加入的多播组中退出，必须在加入多播组 addMembership 之后退出才有效。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let addr: socket.NetAddress = {
  address: '239.255.0.1',
  port: 8080
}
multicast.dropMembership(addr).then(() => {
  console.log('drop membership success');
}).catch((err: Object) => {
  console.log('drop membership fail');
});

setMulticastTTL¹¹⁺

setMulticastTTL(ttl: number, callback: AsyncCallback<void>): void;

设置多播通信时数据包在网络传输过程中路由器最大跳数。使用callback方法作为异步方法。

说明： 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 范围为 0～255，默认值为 1 。 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let ttl = 8
multicast.setMulticastTTL(ttl, (err: Object) => {
  if (err) {
    console.log('set ttl fail, err: ' + JSON.stringify(err));
    return;
  }
  console.log('set ttl success');
})

setMulticastTTL¹¹⁺

setMulticastTTL(ttl: number): Promise<void>;

设置多播通信时数据包在网络传输过程中路由器最大跳数。使用Promise方法作为异步方法。。

说明： 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 范围为 0～255，默认值为 1 。 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.setMulticastTTL(8).then(() => {
  console.log('set ttl success');
}).catch((err: Object) => {
  console.log('set ttl failed');
});

getMulticastTTL¹¹⁺

getMulticastTTL(callback: AsyncCallback<number>): void;

获取数据包在网络传输过程中路由器最大跳数(TTL)的值。使用callback方法作为异步方法。

说明： 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 范围为 0～255，默认值为 1 。 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.getMulticastTTL((err: Object, value: Number) => {
  if (err) {
    console.log('set ttl fail, err: ' + JSON.stringify(err));
    return;
  }
  console.log('set ttl success, value: ' + JSON.stringify(value));
})

getMulticastTTL¹¹⁺

getMulticastTTL(): Promise<number>;

获取数据包在网络传输过程中路由器最大跳数(TTL)的值。使用Promise方法作为异步方法。

说明： 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 范围为 0～255，默认值为 1 。 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.getMulticastTTL().then((value: Number) => {
  console.log('ttl: ', JSON.stringify(value));
}).catch((err: Object) => {
  console.log('set ttl failed');
});

setLoopbackMode¹¹⁺

setLoopbackMode(flag: boolean, callback: AsyncCallback<void>): void;

设置多播通信中的环回模式标志位。使用callback方法作为异步方法。

说明： 用于设置环回模式，开启或关闭两种状态，默认为开启状态。 如果一个多播通信中环回模式设置值为 true，那么它允许主机在本地循环接收自己发送的多播数据包。如果为 false，则主机不会接收到自己发送的多播数据包。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.setLoopbackMode(false, (err: Object) => {
  if (err) {
    console.log('set loopback mode fail, err: ' + JSON.stringify(err));
    return;
  }
  console.log('set loopback mode success');
})

setLoopbackMode¹¹⁺

setLoopbackMode(flag: boolean): Promise<void>;

设置多播通信中的环回模式标志位。使用callback方法作为异步方法。

说明： 用于设置环回模式，开启或关闭两种状态，默认为开启状态。 如果一个多播通信中环回模式设置值为 true，那么它允许主机在本地循环接收自己发送的多播数据包。如果为 false，则主机不会接收到自己发送的多播数据包。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.setLoopbackMode(false).then(() => {
  console.log('set loopback mode success');
}).catch((err: Object) => {
  console.log('set loopback mode failed');
});

getLoopbackMode¹¹⁺

getLoopbackMode(callback: AsyncCallback<boolean>): void;

获取多播通信中的环回模式状态。使用Promise方法作为异步方法。

说明： 用于获取当前环回模式开启或关闭的状态。 如果获取的属性值为 true，表示环回模式是开启的状态，允许主机在本地循环接收自己发送的多播数据包。如果为 false，则表示环回模式是关闭的状态，主机不会接收到自己发送的多播数据包。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.getLoopbackMode((err: Object, value: Boolean) => {
  if (err) {
    console.log('get loopback mode fail, err: ' + JSON.stringify(err));
    return;
  }
  console.log('get loopback mode success, value: ' + JSON.stringify(value));
})

getLoopbackMode¹¹⁺

getLoopbackMode(): Promise<boolean>;

获取多播通信中的环回模式状态。使用Promise方法作为异步方法。

说明： 用于获取当前环回模式开启或关闭的状态。 如果获取的属性值为 true，表示环回模式是开启的状态，允许主机在本地循环接收自己发送的多播数据包。如果为 false，则表示环回模式是关闭的状态，主机不会接收到自己发送的多播数据包。 在调用 addMembership 之后，调用此接口才有效。

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
multicast.getLoopbackMode().then((value: Boolean) => {
  console.log('loopback mode: ', JSON.stringify(value));
}).catch((err: Object) => {
  console.log('get loopback mode failed');
});

send⁷⁺

send(options: UDPSendOptions, callback: AsyncCallback<void>): void

发送数据。使用callback方式作为异步方法。

发送数据前，需要先调用 addMembership 加入多播组。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from '@ohos.net.socket';
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let sendOptions: socket.UDPSendOptions = {
  data: 'Hello, server!',
  address: {
    address: '239.255.0.1',
    port: 8080
  }
}
multicast.send(sendOptions, (err: Object) => {
  if (err) {
    console.log('send fail: ' + JSON.stringify(err));
    return;
  }
  console.log('send success');
});

send⁷⁺

send(options: UDPSendOptions): Promise<void>

发送数据。使用Promise方式作为异步方法。

发送数据前，需要先调用 addMembership 加入多播组。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

返回值：

示例：

import socket from '@ohos.net.socket';
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance();
let sendOptions: socket.UDPSendOptions = {
  data: 'Hello, server!',
  address: {
    address: '239.255.0.1',
    port: 8080
  }
}
multicast.send(sendOptions).then(() => {
  console.log('send success');
}).catch((err: Object) => {
  console.log('send fail, ' + JSON.stringify(err));
});

on('message')⁷⁺

on(type: 'message', callback: Callback<SocketMessageInfo>): void

订阅MulticastSocket接收消息事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket"
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance()

multicast.on('message', (data) => {
  console.info('接收的数据: ' + JSON.stringify(data))
  const uintArray = new Uint8Array(data.message)
  let str = ''
  for (let i = 0; i < uintArray.length; ++i) {
    str += String.fromCharCode(uintArray[i])
  }
  console.info(str)
})

off('message')⁷⁺

off(type: 'message', callback?: Callback<SocketMessageInfo>): void

取消订阅消息事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket"
let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance()
multicast.on('message', (data) => {
  console.info('接收的数据: ' + JSON.stringify(data))
  const uintArray = new Uint8Array(data.message)
  let str = ''
  for (let i = 0; i < uintArray.length; ++i) {
    str += String.fromCharCode(uintArray[i])
  }
  console.info(str)
})
multicast.off('message')

socket.constructTCPSocketInstance⁷⁺

constructTCPSocketInstance(): TCPSocket

创建一个TCPSocket对象。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

TCPSocket

TCPSocket连接。在调用TCPSocket的方法前，需要先通过socket.constructTCPSocketInstance创建TCPSocket对象。

bind

bind(address: NetAddress, callback: AsyncCallback<void>): void

绑定IP地址和端口，端口可以指定为0由系统随机分配或指定为其它非0端口。使用callback方法作为异步方法。

说明： bind方法如果因为端口冲突而执行失败，则会由系统随机分配端口号。 TCP客户端可先调用该接口(tcp.bind)显式绑定IP地址和端口号，再调用tcp.connect完成与服务端的连接；也可直接调用tcp.connect由系统自动绑定IP地址和端口号，完成与服务端的连接。 bind的IP为'localhost'或'127.0.0.1'时，只允许本地回环接口的连接，即服务端和客户端运行在同一台机器上。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
tcp.bind(bindAddr, (err: BusinessError) => {
  if (err) {
    console.log('bind fail');
    return;
  }
  console.log('bind success');
})

bind

bind(address: NetAddress): Promise<void>

绑定IP地址和端口，端口可以指定为0由系统随机分配或指定为其它非0端口。使用Promise方法作为异步方法。

说明： bind方法如果因为端口冲突而执行失败，则会由系统随机分配端口号。 TCP客户端可先调用该接口(tcp.bind)显式绑定IP地址和端口号，再调用tcp.connect完成与服务端的连接；也可直接调用tcp.connect由系统自动绑定IP地址和端口号，完成与服务端的连接。 bind的IP为'localhost'或'127.0.0.1'时，只允许本地回环接口的连接，即服务端和客户端运行在同一台机器上。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '192.168.xx.xxx',
  port: 8080
}
tcp.bind(bindAddr).then(() => {
  console.log('bind success');
}).catch((err: BusinessError) => {
  console.log('bind fail');
});

connect

connect(options: TCPConnectOptions, callback: AsyncCallback<void>): void

连接到指定的IP地址和端口。使用callback方法作为异步方法。

说明： 在没有执行tcp.bind的情况下，也可以直接调用该接口完成与TCP服务端的连接

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, (err: BusinessError) => {
  if (err) {
    console.log('connect fail');
    return;
  }
  console.log('connect success');
})

connect

connect(options: TCPConnectOptions): Promise<void>

连接到指定的IP地址和端口。使用promise方法作为异步方法。

说明： 在没有执行tcp.bind的情况下，也可以直接调用该接口完成与TCP服务端的连接。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions).then(() => {
  console.log('connect success')
}).catch((err: BusinessError) => {
  console.log('connect fail');
});

send

send(options: TCPSendOptions, callback: AsyncCallback<void>): void

通过TCPSocket连接发送数据。使用callback方式作为异步方法。

说明： connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, () => {
  console.log('connect success');
  let tcpSendOptions: socket.TCPSendOptions = {
    data: 'Hello, server!'
  }
  tcp.send(tcpSendOptions, (err: BusinessError) => {
    if (err) {
      console.log('send fail');
      return;
    }
    console.log('send success');
  })
})

send

send(options: TCPSendOptions): Promise<void>

通过TCPSocket连接发送数据。使用Promise方式作为异步方法。

说明： connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, () => {
  console.log('connect success');
  let tcpSendOptions: socket.TCPSendOptions = {
    data: 'Hello, server!'
  }
  tcp.send(tcpSendOptions).then(() => {
    console.log('send success');
  }).catch((err: BusinessError) => {
    console.log('send fail');
  });
})

close

close(callback: AsyncCallback<void>): void

关闭TCPSocket连接。使用callback方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

tcp.close((err: BusinessError) => {
  if (err) {
    console.log('close fail');
    return;
  }
  console.log('close success');
})

close

close(): Promise<void>

关闭TCPSocket连接。使用Promise方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

tcp.close().then(() => {
  console.log('close success');
}).catch((err: BusinessError) => {
  console.log('close fail');
});

getRemoteAddress

getRemoteAddress(callback: AsyncCallback<NetAddress>): void

获取对端Socket地址。使用callback方式作为异步方法。

说明： connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, () => {
  console.log('connect success');
  tcp.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => {
    if (err) {
      console.log('getRemoteAddressfail');
      return;
    }
    console.log('getRemoteAddresssuccess:' + JSON.stringify(data));
  })
});

getRemoteAddress

getRemoteAddress(): Promise<NetAddress>

获取对端Socket地址。使用Promise方式作为异步方法。

说明： connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions).then(() => {
  console.log('connect success');
  tcp.getRemoteAddress().then(() => {
    console.log('getRemoteAddress success');
  }).catch((err: BusinessError) => {
    console.log('getRemoteAddressfail');
  });
}).catch((err: BusinessError) => {
  console.log('connect fail');
});

getState

getState(callback: AsyncCallback<SocketStateBase>): void

获取TCPSocket状态。使用callback方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, () => {
  console.log('connect success');
  tcp.getState((err: BusinessError, data: socket.SocketStateBase) => {
    if (err) {
      console.log('getState fail');
      return;
    }
    console.log('getState success:' + JSON.stringify(data));
  });
});

getState

getState(): Promise<SocketStateBase>

获取TCPSocket状态。使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();

let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions).then(() => {
  console.log('connect success');
  tcp.getState().then(() => {
    console.log('getState success');
  }).catch((err: BusinessError) => {
    console.log('getState fail');
  });
}).catch((err: BusinessError) => {
  console.log('connect fail');
});

getSocketFd¹⁰⁺

getSocketFd(callback: AsyncCallback<number>): void

获取TCPSocket的文件描述符。使用callback方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '0.0.0.0'
}
tcp.bind(bindAddr)
let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions)
tcp.getSocketFd((err: BusinessError, data: number) => {
  console.info("getSocketFd failed: " + err);
  console.info("tunenlfd: " + data);
})

getSocketFd¹⁰⁺

getSocketFd(): Promise<number>

获取TCPSocket的文件描述符。使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let bindAddr: socket.NetAddress = {
  address: '0.0.0.0'
}
tcp.bind(bindAddr)
let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions)
tcp.getSocketFd().then((data: number) => {
  console.info("tunenlfd: " + data);
})

setExtraOptions

setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback<void>): void

设置TCPSocket连接的其他属性。使用callback方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, () => {
  console.log('connect success');
  let tcpExtraOptions: socket.TCPExtraOptions = {
    keepAlive: true,
    OOBInline: true,
    TCPNoDelay: true,
    socketLinger: { on: true, linger: 10 },
    receiveBufferSize: 1000,
    sendBufferSize: 1000,
    reuseAddress: true,
    socketTimeout: 3000
  }
  tcp.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
    if (err) {
      console.log('setExtraOptions fail');
      return;
    }
    console.log('setExtraOptions success');
  });
});

setExtraOptions

setExtraOptions(options: TCPExtraOptions): Promise<void>

设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let tcpconnectoptions: socket.TCPConnectOptions = {
  address: {
    address: '192.168.xx.xxx',
    port: 8080
  },
  timeout: 6000
}
tcp.connect(tcpconnectoptions, () => {
  console.log('connect success');
  let tcpExtraOptions: socket.TCPExtraOptions = {
    keepAlive: true,
    OOBInline: true,
    TCPNoDelay: true,
    socketLinger: { on: true, linger: 10 },
    receiveBufferSize: 1000,
    sendBufferSize: 1000,
    reuseAddress: true,
    socketTimeout: 3000
  }
  tcp.setExtraOptions(tcpExtraOptions).then(() => {
    console.log('setExtraOptions success');
  }).catch((err: BusinessError) => {
    console.log('setExtraOptions fail');
  });
});

on('message')

on(type: 'message', callback: Callback<SocketMessageInfo>): void

订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let messageView = '';
tcp.on('message', (value: socket.SocketMessageInfo) => {
  for (let i: number = 0; i < value.message.byteLength; i++) {
    let uint8Array = new Uint8Array(value.message) 
    let messages = uint8Array[i]
    let message = String.fromCharCode(messages);
    messageView += message;
  }
  console.log('on message message: ' + JSON.stringify(messageView));
  console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo));
});

off('message')

off(type: 'message', callback?: Callback<SocketMessageInfo>): void

取消订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let messageView = '';
let callback = (value: socket.SocketMessageInfo) => {
  for (let i: number = 0; i < value.message.byteLength; i++) {
    let uint8Array = new Uint8Array(value.message) 
    let messages = uint8Array[i]
    let message = String.fromCharCode(messages);
    messageView += message;
  }
  console.log('on message message: ' + JSON.stringify(messageView));
  console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo));
}
tcp.on('message', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcp.off('message', callback);
tcp.off('message');

on('connect' | 'close')

on(type: 'connect' | 'close', callback: Callback<void>): void

订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
tcp.on('connect', () => {
  console.log("on connect success")
});
tcp.on('close', () => {
  console.log("on close success")
});

off('connect' | 'close')

off(type: 'connect' | 'close', callback?: Callback<void>): void

取消订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let callback1 = () => {
  console.log("on connect success");
}
tcp.on('connect', callback1);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcp.off('connect', callback1);
tcp.off('connect');
let callback2 = () => {
  console.log("on close success");
}
tcp.on('close', callback2);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcp.off('close', callback2);
tcp.off('close');

on('error')

on(type: 'error', callback: ErrorCallback): void

订阅TCPSocket连接的error事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
tcp.on('error', (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err))
});

off('error')

off(type: 'error', callback?: ErrorCallback): void

取消订阅TCPSocket连接的error事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
let callback = (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err));
}
tcp.on('error', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcp.off('error', callback);
tcp.off('error');

TCPConnectOptions

TCPSocket连接的参数。

系统能力：SystemCapability.Communication.NetStack

TCPSendOptions

TCPSocket发送请求的参数。

系统能力：SystemCapability.Communication.NetStack

TCPExtraOptions

TCPSocket连接的其他属性。

系统能力：SystemCapability.Communication.NetStack

socket.constructTCPSocketServerInstance¹⁰⁺

constructTCPSocketServerInstance(): TCPSocketServer

创建一个TCPSocketServer对象。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();

TCPSocketServer¹⁰⁺

TCPSocketServer连接。在调用TCPSocketServer的方法前，需要先通过socket.constructTCPSocketServerInstance创建TCPSocketServer对象。

listen¹⁰⁺

listen(address: NetAddress, callback: AsyncCallback<void>): void

绑定IP地址和端口，端口可以指定或由系统随机分配。监听并接受与此套接字建立的TCPSocket连接。该接口使用多线程并发处理客户端的数据。使用callback方法作为异步方法。

说明： 服务端使用该方法完成bind，listen，accept操作，bind方法失败会由系统随机分配端口号。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let listenAddr: socket.NetAddress = {
  address:  '192.168.xx.xxx',
  port: 8080,
  family: 1
}
tcpServer.listen(listenAddr, (err: BusinessError) => {
  if (err) {
    console.log("listen fail");
    return;
  }
  console.log("listen success");
})

listen¹⁰⁺

listen(address: NetAddress): Promise<void>

绑定IP地址和端口，端口可以指定或由系统随机分配。监听并接受与此套接字建立的TCPSocket连接。该接口使用多线程并发处理客户端的数据。使用Promise方法作为异步方法。

说明： 服务端使用该方法完成bind，listen，accept操作，bind方法失败会由系统随机分配端口号。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let listenAddr: socket.NetAddress = {
  address:  '192.168.xx.xxx',
  port: 8080,
  family: 1
}
tcpServer.listen(listenAddr).then(() => {
  console.log('listen success');
}).catch((err: BusinessError) => {
  console.log('listen fail');
});

getState¹⁰⁺

getState(callback: AsyncCallback<SocketStateBase>): void

获取TCPSocketServer状态。使用callback方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let listenAddr: socket.NetAddress = {
  address:  '192.168.xx.xxx',
  port: 8080,
  family: 1
}
tcpServer.listen(listenAddr, (err: BusinessError) => {
  if (err) {
    console.log("listen fail");
    return;
  }
  console.log("listen success");
})
tcpServer.getState((err: BusinessError, data: socket.SocketStateBase) => {
  if (err) {
    console.log('getState fail');
    return;
  }
  console.log('getState success:' + JSON.stringify(data));
})

getState¹⁰⁺

getState(): Promise<SocketStateBase>

获取TCPSocketServer状态。使用Promise方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let listenAddr: socket.NetAddress = {
  address:  '192.168.xx.xxx',
  port: 8080,
  family: 1
}
tcpServer.listen(listenAddr, (err: BusinessError) => {
  if (err) {
    console.log("listen fail");
    return;
  }
  console.log("listen success");
})
tcpServer.getState().then((data: socket.SocketStateBase) => {
  console.log('getState success' + JSON.stringify(data));
}).catch((err: BusinessError) => {
  console.log('getState fail');
});

setExtraOptions¹⁰⁺

setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback<void>): void

设置TCPSocketServer连接的其他属性。使用callback方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let listenAddr: socket.NetAddress = {
  address:  '192.168.xx.xxx',
  port: 8080,
  family: 1
}
tcpServer.listen(listenAddr, (err: BusinessError) => {
  if (err) {
    console.log("listen fail");
    return;
  }
  console.log("listen success");
})

let tcpExtraOptions: socket.TCPExtraOptions = {
  keepAlive: true,
  OOBInline: true,
  TCPNoDelay: true,
  socketLinger: { on: true, linger: 10 },
  receiveBufferSize: 1000,
  sendBufferSize: 1000,
  reuseAddress: true,
  socketTimeout: 3000
}
tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
  if (err) {
    console.log('setExtraOptions fail');
    return;
  }
  console.log('setExtraOptions success');
});

setExtraOptions¹⁰⁺

setExtraOptions(options: TCPExtraOptions): Promise<void>

设置TCPSocketServer连接的其他属性，使用Promise方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let listenAddr: socket.NetAddress = {
  address:  '192.168.xx.xxx',
  port: 8080,
  family: 1
}
tcpServer.listen(listenAddr, (err: BusinessError) => {
  if (err) {
    console.log("listen fail");
    return;
  }
  console.log("listen success");
})

let tcpExtraOptions: socket.TCPExtraOptions = {
  keepAlive: true,
  OOBInline: true,
  TCPNoDelay: true,
  socketLinger: { on: true, linger: 10 },
  receiveBufferSize: 1000,
  sendBufferSize: 1000,
  reuseAddress: true,
  socketTimeout: 3000
}
tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
  console.log('setExtraOptions success');
}).catch((err: BusinessError) => {
  console.log('setExtraOptions fail');
});

on('connect')¹⁰⁺

on(type: 'connect', callback: Callback<TCPSocketConnection>): void

订阅TCPSocketServer的连接事件。使用callback方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (data: socket.TCPSocketConnection) => {
  console.log(JSON.stringify(data))
});

off('connect')¹⁰⁺

off(type: 'connect', callback?: Callback<TCPSocketConnection>): void

取消订阅TCPSocketServer的连接事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let callback = (data: socket.TCPSocketConnection) => {
  console.log('on connect message: ' + JSON.stringify(data));
}
tcpServer.on('connect', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcpServer.off('connect', callback);
tcpServer.off('connect');

on('error')¹⁰⁺

on(type: 'error', callback: ErrorCallback): void

订阅TCPSocketServer连接的error事件。使用callback方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('error', (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err))
});

off('error')¹⁰⁺

off(type: 'error', callback?: ErrorCallback): void

取消订阅TCPSocketServer连接的error事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let callback = (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err));
}
tcpServer.on('error', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcpServer.off('error', callback);
tcpServer.off('error');

TCPSocketConnection¹⁰⁺

TCPSocketConnection连接，即TCPSocket客户端与服务端的连接。在调用TCPSocketConnection的方法前，需要先获取TCPSocketConnection对象。

说明： 客户端与服务端成功建立连接后，才能通过返回的TCPSocketConnection对象调用相应的接口。

系统能力：SystemCapability.Communication.NetStack

属性

send¹⁰⁺

send(options: TCPSendOptions, callback: AsyncCallback<void>): void

通过TCPSocketConnection连接发送数据。使用callback方式作为异步方法。

说明： 与客户端建立连接后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();

tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  let tcpSendOption: socket.TCPSendOptions = {
    data: 'Hello, client!'
  }
  client.send(tcpSendOption, () => {
    console.log('send success');
  });
});

send¹⁰⁺

send(options: TCPSendOptions): Promise<void>

通过TCPSocketConnection连接发送数据。使用Promise方式作为异步方法。

说明： 与客户端建立连接后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();

tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  let tcpSendOption: socket.TCPSendOptions = {
    data: 'Hello, client!'
  }
  client.send(tcpSendOption).then(() => {
    console.log('send success');
  }).catch((err: BusinessError) => {
    console.log('send fail');
  });
});

close¹⁰⁺

close(callback: AsyncCallback<void>): void

关闭一个与TCPSocket建立的连接。使用callback方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();

tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.close((err: BusinessError) => {
    if (err) {
      console.log('close fail');
      return;
    }
    console.log('close success');
  });
});

close¹⁰⁺

close(): Promise<void>

关闭一个与TCPSocket建立的连接。使用Promise方式作为异步方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.close().then(() => {
  	console.log('close success');
  }).catch((err: BusinessError) => {
  	console.log('close fail');
  });
});

getRemoteAddress¹⁰⁺

getRemoteAddress(callback: AsyncCallback<NetAddress>): void

获取对端Socket地址。使用callback方式作为异步方法。

说明： 与客户端建立连接后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => {
    if (err) {
      console.log('getRemoteAddress fail');
      return;
    }
    console.log('getRemoteAddress success:' + JSON.stringify(data));
  });
});

getRemoteAddress¹⁰⁺

getRemoteAddress(): Promise<NetAddress>

获取对端Socket地址。使用Promise方式作为异步方法。

说明： 与客户端建立连接后，才可调用此方法。

需要权限：ohos.permission.INTERNET

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.getRemoteAddress().then(() => {
    console.log('getRemoteAddress success');
  }).catch((err: BusinessError) => {
    console.log('getRemoteAddress fail');
  });
});

on('message')¹⁰⁺

on(type: 'message', callback: Callback<SocketMessageInfo>): void

订阅TCPSocketConnection连接的接收消息事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();

tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.on('message', (value: socket.SocketMessageInfo) => {
    let messageView = '';
    for (let i: number = 0; i < value.message.byteLength; i++) {
      let uint8Array = new Uint8Array(value.message) 
      let messages = uint8Array[i]
      let message = String.fromCharCode(messages);
      messageView += message;
    }
    console.log('on message message: ' + JSON.stringify(messageView));
    console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo));
  });
});

off('message')¹⁰⁺

off(type: 'message', callback?: Callback<SocketMessageInfo>): void

取消订阅TCPSocketConnection连接的接收消息事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let callback = (value: socket.SocketMessageInfo) => {
  let messageView = '';
  for (let i: number = 0; i < value.message.byteLength; i++) {
    let uint8Array = new Uint8Array(value.message) 
    let messages = uint8Array[i]
    let message = String.fromCharCode(messages);
    messageView += message;
  }
  console.log('on message message: ' + JSON.stringify(messageView));
  console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo));
}
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.on('message', callback);
  // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
  client.off('message', callback);
  client.off('message');
});

on('close')¹⁰⁺

on(type: 'close', callback: Callback<void>): void

订阅TCPSocketConnection的关闭事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.on('close', () => {
    console.log("on close success")
  });
});

off('close')¹⁰⁺

off(type: 'close', callback?: Callback<void>): void

取消订阅TCPSocketConnection的关闭事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
let callback = () => {
  console.log("on close success");
}
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.on('close', callback);
  // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
  client.off('close', callback);
  client.off('close');
});

on('error')¹⁰⁺

on(type: 'error', callback: ErrorCallback): void

订阅TCPSocketConnection连接的error事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.on('error', (err: BusinessError) => {
    console.log("on error, err:" + JSON.stringify(err))
  });
});

off('error')¹⁰⁺

off(type: 'error', callback?: ErrorCallback): void

取消订阅TCPSocketConnection连接的error事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";
import { BusinessError } from '@ohos.base';
let callback = (err: BusinessError) => {
  console.log("on error, err:" + JSON.stringify(err));
}
let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
tcpServer.on('connect', (client: socket.TCPSocketConnection) => {
  client.on('error', callback);
  // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
  client.off('error', callback);
  client.off('error');
});

TCP 错误码说明

TCP 其余错误码映射形式为：2301000 + Linux内核错误码。

错误码的详细介绍参见Socket错误码

socket.constructLocalSocketInstance¹¹⁺

constructLocalSocketInstance(): LocalSocket

创建一个LocalSocket对象。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();

LocalSocket¹¹⁺

LocalSocket连接。在调用LocalSocket的方法前，需要先通过socket.constructLocalSocketInstance创建LocalSocket对象。

bind¹¹⁺

bind(address: LocalAddress): Promise<void>;

绑定本地套接字文件的路径。使用promise方法作为异步方法。

说明： bind方法可以使客户端确保有个明确的本地套接字路径，显式的绑定一个本地套接字文件。 bind方法在本地套接字通信中非必须。

系统能力：SystemCapability.Communication.NetStack

参数：

错误码：

示例：

import socket from "@ohos.net.socket";

let client = socket.constructLocalSocketInstance()
let sandboxPath: string = getContext().filesDir + '/testSocket'
let address : socket.LocalAddress = {
  address: sandboxPath
}
client.bind(address).then(() => {
  console.log('bind success')
}).catch((err: Object) => {
  console.error('failed to bind: ' + JSON.stringify(err))
})

connect¹¹⁺

connect(options: LocalConnectOptions): Promise<void>

连接到指定的套接字文件。使用promise方法作为异步方法。

说明： 在没有执行localsocket.bind的情况下，也可以直接调用该接口完成与LocalSocket服务端的连接。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";

let client = socket.constructLocalSocketInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let connectOpt: socket.LocalConnectOptions = {
  address: {
    address: sandboxPath
  },
  timeout: 6000
}
client.connect(connectOpt).then(() => {
  console.log('connect success')
}).catch((err: Object) => {
  console.error('connect fail: ' + JSON.stringify(err));
});

send¹¹⁺

send(options: LocalSendOptions): Promise<void>

通过LocalSocket连接发送数据。使用Promise方式作为异步方法。

说明： connect方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket"

let client: socket.LocalSocket = socket.constructLocalSocketInstance()
let sandboxPath: string = getContext().filesDir + '/testSocket'
let connectOpt: socket.LocalConnectOptions = {
  address: {
    address: sandboxPath
  },
  timeout: 6000
}
client.connect(connectOpt).then(() => {
  console.log('connect success')
}).catch((err: Object) => {
  console.error('connect failed: ' + JSON.stringify(err))
})
let sendOpt: socket.LocalSendOptions = {
  data: 'Hello world!'
}
client.send(sendOpt).then(() => {
  console.log('send success')
}).catch((err: Object) => {
  console.error('send fail: ' + JSON.stringify(err))
})

close¹¹⁺

close(): Promise<void>

关闭LocalSocket连接。使用Promise方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();

client.close().then(() => {
  console.log('close success');
}).catch((err: Object) => {
  console.error('close fail: ' + JSON.stringify(err));
});

getState¹¹⁺

getState(): Promise<SocketStateBase>

获取LocalSocket状态。使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let connectOpt: socket.LocalConnectOptions = {
  address: {
    address: sandboxPath
  },
  timeout: 6000
}
client.connect(connectOpt).then(() => {
  console.log('connect success');
  client.getState().then(() => {
    console.log('getState success');
  }).catch((err: Object) => {
    console.error('getState fail: ' + JSON.stringify(err))
  });
}).catch((err: Object) => {
  console.error('connect fail: ' + JSON.stringify(err));
});

getSocketFd¹¹⁺

getSocketFd(): Promise<number>

获取LocalSocket的文件描述符。使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。 获取由系统内核分配的唯一文件描述符，用于标识当前使用的套接字。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let connectOpt: socket.LocalConnectOptions = {
  address: {
    address: sandboxPath
  },
  timeout: 6000
}
client.connect(connectOpt).then(() => {
  console.log('connect ok')
}).catch((err: Object) => {
  console.error('connect fail: ' + JSON.stringify(err))
})
client.getSocketFd().then((data: number) => {
  console.info("fd: " + data);
}).catch((err: Object) => {
  console.error("getSocketFd faile: " + JSON.stringify(err));
})

setExtraOptions¹¹⁺

setExtraOptions(options: ExtraOptionsBase): Promise<void>

设置LocalSocket的套接字属性，使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let connectOpt: socket.LocalConnectOptions = {
  address: {
    address: sandboxPath
  },
  timeout: 6000
}
client.connect(connectOpt).then(() => {
  console.log('connect success');
  let options: socket.ExtraOptionsBase = {
    receiveBufferSize: 8000,
    sendBufferSize: 8000,
    socketTimeout: 3000
  }
  client.setExtraOptions(options).then(() => {
    console.log('setExtraOptions success');
  }).catch((err: Object) => {
    console.error('setExtraOptions fail: ' + JSON.stringify(err));
  });
}).catch((err: Object) => {
  console.error('connect fail: ' + JSON.stringify(err));
});

getExtraOptions¹¹⁺

getExtraOptions(): Promise<ExtraOptionsBase>;

获取LocalSocket的套接字属性，使用Promise方式作为异步方法。

说明： bind或connect方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let connectOpt: socket.LocalConnectOptions = {
  address: {
    address: sandboxPath
  },
  timeout: 6000
}
client.connect(connectOpt).then(() => {
  console.log('connect success');
  client.getExtraOptions().then((options : socket.ExtraOptionsBase) => {
    console.log('options: ' + JSON.stringify(options));
  }).catch((err: Object) => {
    console.error('setExtraOptions fail: ' + JSON.stringify(err));
  });
}).catch((err: Object) => {
  console.error('connect fail: ' + JSON.stringify(err));
});

on('message')¹¹⁺

on(type: 'message', callback: Callback<LocalSocketMessageInfo>): void

订阅LocalSocket连接的接收消息事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
client.on('message', (value: socket.LocalSocketMessageInfo) => {
  const uintArray = new Uint8Array(value.message)
  let messageView = '';
  for (let i = 0; i < uintArray.length; i++) {
    messageView += String.fromCharCode(uintArray[i]);
  }
  console.log('total: ' + JSON.stringify(value));
  console.log('message infomation: ' + messageView);
});

off('message')¹¹⁺

off(type: 'message', callback?: Callback<LocalSocketMessageInfo>): void

取消订阅LocalSocket连接的接收消息事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let messageView = '';
let callback = (value: socket.LocalSocketMessageInfo) => {
  const uintArray = new Uint8Array(value.message)
  let messageView = '';
  for (let i = 0; i < uintArray.length; i++) {
    messageView += String.fromCharCode(uintArray[i]);
  }
  console.log('total: ' + JSON.stringify(value));
  console.log('message infomation: ' + messageView);
}
client.on('message', callback);
client.off('message');

on('connect')¹¹⁺

on(type: 'connect', callback: Callback<void>): void;

订阅LocalSocket的连接事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
client.on('connect', () => {
  console.log("on connect success")
});

off('connect')¹¹⁺

off(type: 'connect', callback?: Callback<void>): void;

取消订阅LocalSocket的连接事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let callback = () => {
  console.log("on connect success");
}
client.on('connect', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
client.off('connect', callback);
client.off('connect');

on('close')¹¹⁺

on(type: 'close', callback: Callback<void>): void;

订阅LocalSocket的关闭事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let callback = () => {
  console.log("on close success");
}
client.on('close', callback);

off('close')¹¹⁺

off(type: 'close', callback?: Callback<void>): void;

订阅LocalSocket的关闭事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let callback = () => {
  console.log("on close success");
}
client.on('close', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
client.off('close', callback);
client.off('close');

on('error')¹¹⁺

on(type: 'error', callback: ErrorCallback): void

订阅LocalSocket连接的error事件。使用callback方式作为异步方法。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
client.on('error', (err: Object) => {
  console.log("on error, err:" + JSON.stringify(err))
});

off('error')¹¹⁺

off(type: 'error', callback?: ErrorCallback): void;

取消订阅LocalSocket连接的error事件。使用callback方式作为异步方法。

说明： 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。

系统能力：SystemCapability.Communication.NetStack

参数：

示例：

import socket from "@ohos.net.socket";
let client: socket.LocalSocket = socket.constructLocalSocketInstance();
let callback = (err: Object) => {
  console.log("on error, err:" + JSON.stringify(err));
}
client.on('error', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
client.off('error', callback);
client.off('error');

LocalSocketMessageInfo¹¹⁺

LocalSocket客户端与服务端通信时接收的数据。

系统能力：SystemCapability.Communication.NetStack

LocalAddress¹¹⁺

LocalSocket本地套接字文件路径信息，在传入套接字路径进行绑定时，会在此路径下创建套接字文件。

系统能力：SystemCapability.Communication.NetStack

LocalConnectOptions¹¹⁺

LocalSocket客户端在连接服务端时传入的参数信息。

系统能力：SystemCapability.Communication.NetStack

LocalSendOptions¹¹⁺

LocalSocket发送请求的参数。

系统能力：SystemCapability.Communication.NetStack

ExtraOptionsBase⁷⁺

Socket套接字的基础属性。

系统能力：SystemCapability.Communication.NetStack

socket.constructLocalSocketServerInstance¹¹⁺

constructLocalSocketServerInstance(): LocalSocketServer

创建一个LocalSocketServer对象。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance();

LocalSocketServer¹¹⁺

LocalSocketServer类。在调用LocalSocketServer的方法前，需要先通过socket.constructLocalSocketServerInstance创建LocalSocketServer对象。

listen¹¹⁺

listen(address: LocalAddress): Promise<void>

绑定本地套接字文件，监听并接受与此套接字建立的LocalSocket连接。该接口使用多线程并发处理客户端的数据。使用Promise方法作为异步方法。

说明： 服务端使用该方法完成bind，listen，accept操作，传入套接字文件路径，调用此接口后会自动生成本地套接字文件。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let addr: socket.LocalAddress = {
  address: sandboxPath
}
server.listen(addr).then(() => {
  console.log('listen success');
}).catch((err: Object) => {
  console.error('listen fail: ' + JSON.stringify(err));
});

getState¹¹⁺

getState(): Promise<SocketStateBase>

获取LocalSocketServer状态。使用Promise方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

返回值：

示例：

import socket from "@ohos.net.socket";
let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let listenAddr: socket.LocalAddress = {
  address: sandboxPath
}
server.listen(listenAddr).then(() => {
  console.log("listen success");
}).catch((err: Object) => {
  console.error("listen fail: " + JSON.stringify(err));
})
server.getState().then((data: socket.SocketStateBase) => {
  console.log('getState success: ' + JSON.stringify(data));
}).catch((err: Object) => {
  console.error('getState fail: ' + JSON.stringify(err));
});

setExtraOptions¹¹⁺

setExtraOptions(options: ExtraOptionsBase): Promise<void>

设置LocalSocketServer连接的套接字属性，使用Promise方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

参数：

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance();
let sandboxPath: string = getContext().filesDir + '/testSocket'
let listenAddr: socket.NetAddress = {
  address: sandboxPath
}
server.listen(listenAddr).then(() => {
  console.log("listen success");
}).catch((err: Object) => {
  console.error("listen fail: " + JSON.stringify(err));
})

let options: socket.ExtraOptionsBase = {
  receiveBufferSize: 6000,
  sendBufferSize: 6000,
  socketTimeout: 3000
}
server.setExtraOptions(options).then(() => {
  console.log('setExtraOptions success');
}).catch((err: Object) => {
  console.error('setExtraOptions fail: ' + JSON.stringify(err));
});

getExtraOptions¹¹⁺

getExtraOptions(): Promise<ExtraOptionsBase>;

获取LocalSocketServer中连接的套接字的属性，使用Promise方式作为异步方法。

说明： listen方法调用成功后，才可调用此方法。

系统能力：SystemCapability.Communication.NetStack

返回值：

错误码：

示例：

import socket from "@ohos.net.socket";
let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance();
let sandboxPath: string = getContext(this).filesDir + '/testSocket'
let listenAddr: socket.LocalAddress = {
  address: sandboxPath
}
server.listen(listenAddr).then(() => {
  console.log("listen success");
}).catch((err: Object) => {
  console.error("listen fail: " + JSON.stringify(err));
})
server.getExtraOptions().then((options) => {
  console.log('options: ' + JSON.stringify(options));
}).catch((err: Object) => {
  console.error('getExtraOptions fail: ' + JSON.stringify(err));
});