Skip to content

D
Docs

OpenHarmony / Docs
大约 2 年 前同步成功

通知 161
Star 293
Fork 28
D
Docs
未验证 提交 75afe266 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!17222 Net Docs Update 

Merge pull request !17222 from Yangys/master
上级 5ce0584d eea0b17d
隐藏空白更改
内联 并排
Showing with 1596 addition and 1504 deletion
zh-cn/application-dev/connectivity/http-request.md
浏览文件 @ 75afe266
...@@ -49,44 +49,43 @@ let httpRequest = http.createHttp(); ...@@ -49,44 +49,43 @@ let httpRequest = http.createHttp();
// 用于订阅HTTP响应头，此接口会比request请求先返回。可以根据业务需要订阅此消息 // 用于订阅HTTP响应头，此接口会比request请求先返回。可以根据业务需要订阅此消息
// 从API 8开始，使用on('headersReceive', Callback)替代on('headerReceive', AsyncCallback)。 8+ // 从API 8开始，使用on('headersReceive', Callback)替代on('headerReceive', AsyncCallback)。 8+
httpRequest.on('headersReceive', (header) => { httpRequest.on('headersReceive', (header) => {
console.info('header: ' + JSON.stringify(header)); console.info('header: ' + JSON.stringify(header));
}); });
httpRequest.request( httpRequest.request(
// 填写HTTP请求的URL地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定 // 填写HTTP请求的URL地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定"EXAMPLE_URL",
"EXAMPLE_URL", {
{ method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET
method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET // 开发者根据自身业务需要添加header字段
// 开发者根据自身业务需要添加header字段 header: {
header: { 'Content-Type': 'application/json'
'Content-Type': 'application/json' },
}, // 当使用POST请求时此字段用于传递内容
// 当使用POST请求时此字段用于传递内容 extraData: {
extraData: { "data": "data to send",
"data": "data to send", },
}, expectDataType: http.HttpDataType.STRING, // 可选，指定返回数据的类型
expectDataType: http.HttpDataType.STRING, // 可选，指定返回数据的类型 usingCache: true, // 可选，默认为true
usingCache: true, // 可选，默认为true priority: 1, // 可选，默认为1
priority: 1, // 可选，默认为1 connectTimeout: 60000, // 可选，默认为60000ms
connectTimeout: 60000, // 可选，默认为60000ms readTimeout: 60000, // 可选，默认为60000ms
readTimeout: 60000, // 可选，默认为60000ms usingProtocol: http.HttpProtocol.HTTP1_1, // 可选，协议类型默认值由系统自动指定
usingProtocol: http.HttpProtocol.HTTP1_1, // 可选，协议类型默认值由系统自动指定 usingProxy: false, //可选，默认不使用网络代理，自API 10开始支持该属性
usingProxy: false, //可选，默认不使用网络代理，自API 10开始支持该属性 }, (err, data) => {
}, (err, data) => { if (!err) {
if (!err) { // data.result为HTTP响应内容，可根据业务需要进行解析
// data.result为HTTP响应内容，可根据业务需要进行解析 console.info('Result:' + JSON.stringify(data.result));
console.info('Result:' + JSON.stringify(data.result)); console.info('code:' + JSON.stringify(data.responseCode));
console.info('code:' + JSON.stringify(data.responseCode)); // data.header为HTTP响应头，可根据业务需要进行解析
// data.header为HTTP响应头，可根据业务需要进行解析 console.info('header:' + JSON.stringify(data.header));
console.info('header:' + JSON.stringify(data.header)); console.info('cookies:' + JSON.stringify(data.cookies)); // 8+
console.info('cookies:' + JSON.stringify(data.cookies)); // 8+ } else {
} else { console.info('error:' + JSON.stringify(err));
console.info('error:' + JSON.stringify(err)); // 取消订阅HTTP响应头事件
// 取消订阅HTTP响应头事件 httpRequest.off('headersReceive');
httpRequest.off('headersReceive'); // 当该请求使用完毕时，调用destroy方法主动销毁
// 当该请求使用完毕时，调用destroy方法主动销毁 httpRequest.destroy();
httpRequest.destroy();
}
} }
}
); );
``` ```
...@@ -108,61 +107,63 @@ import http from '@ohos.net.http' ...@@ -108,61 +107,63 @@ import http from '@ohos.net.http'
let httpRequest = http.createHttp(); let httpRequest = http.createHttp();
// 用于订阅HTTP响应头事件 // 用于订阅HTTP响应头事件
httpRequest.on('headersReceive', (header) => { httpRequest.on('headersReceive', (header) => {
console.info('header: ' + JSON.stringify(header)); console.info('header: ' + JSON.stringify(header));
}); });
// 用于订阅HTTP流式响应数据接收事件 // 用于订阅HTTP流式响应数据接收事件
let res = ''; let res = '';
httpRequest.on('dataReceive', (data) => { httpRequest.on('dataReceive', (data) => {
res += data; res += data;
console.info('res: ' + res); console.info('res: ' + res);
}); });
// 用于订阅HTTP流式响应数据接收完毕事件 // 用于订阅HTTP流式响应数据接收完毕事件
httpRequest.on('dataEnd', () => { httpRequest.on('dataEnd', () => {
console.info('No more data in response, data receive end'); console.info('No more data in response, data receive end');
}); });
// 用于订阅HTTP流式响应数据接收进度事件 // 用于订阅HTTP流式响应数据接收进度事件
httpRequest.on('dataProgress', (data) => { httpRequest.on('dataProgress', (data) => {
console.log("dataProgress receiveSize:" + data.receiveSize+ ", totalSize:" + data.totalSize); console.log("dataProgress receiveSize:" + data.receiveSize + ", totalSize:" + data.totalSize);
}); });
httpRequest.request2( httpRequest.request2(
// 填写HTTP请求的URL地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定 // 填写HTTP请求的URL地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定
"EXAMPLE_URL", "EXAMPLE_URL",
{ {
method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET
// 开发者根据自身业务需要添加header字段 // 开发者根据自身业务需要添加header字段
header: { header: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
// 当使用POST请求时此字段用于传递内容 // 当使用POST请求时此字段用于传递内容
extraData: { extraData: {
"data": "data to send", "data": "data to send",
}, },
expectDataType: http.HttpDataType.STRING, // 可选，指定返回数据的类型 expectDataType: http.HttpDataType.STRING, // 可选，指定返回数据的类型
usingCache: true, // 可选，默认为true usingCache: true, // 可选，默认为true
priority: 1, // 可选，默认为1 priority: 1, // 可选，默认为1
connectTimeout: 60000, // 可选，默认为60000ms connectTimeout: 60000, // 可选，默认为60000ms
readTimeout: 60000, // 可选，默认为60000ms。若传输的数据较大，需要较长的时间，建议增大该参数以保证数据传输正常终止 readTimeout: 60000, // 可选，默认为60000ms。若传输的数据较大，需要较长的时间，建议增大该参数以保证数据传输正常终止
usingProtocol: http.HttpProtocol.HTTP1_1, // 可选，协议类型默认值由系统自动指定 usingProtocol: http.HttpProtocol.HTTP1_1, // 可选，协议类型默认值由系统自动指定
}, (err, data) => { }, (err, data) => {
console.info('error:' + JSON.stringify(err)); console.info('error:' + JSON.stringify(err));
console.info('ResponseCode :' + JSON.stringify(data)); console.info('ResponseCode :' + JSON.stringify(data));
// 取消订阅HTTP响应头事件 // 取消订阅HTTP响应头事件
httpRequest.off('headersReceive'); httpRequest.off('headersReceive');
// 取消订阅HTTP流式响应数据接收事件 // 取消订阅HTTP流式响应数据接收事件
httpRequest.off('dataReceive'); httpRequest.off('dataReceive');
// 取消订阅HTTP流式响应数据接收进度事件 // 取消订阅HTTP流式响应数据接收进度事件
httpRequest.off('dataProgress'); httpRequest.off('dataProgress');
// 取消订阅HTTP流式响应数据接收完毕事件 // 取消订阅HTTP流式响应数据接收完毕事件
httpRequest.off('dataEnd'); httpRequest.off('dataEnd');
// 当该请求使用完毕时，调用destroy方法主动销毁 // 当该请求使用完毕时，调用destroy方法主动销毁
httpRequest.destroy(); httpRequest.destroy();
} }
); );
``` ```
## 相关实例 ## 相关实例
针对HTTP数据请求，有以下相关实例可供参考： 针对HTTP数据请求，有以下相关实例可供参考：
- [`Http:`数据请求（ArkTS）（API9））](https://gitee.com/openharmony/applications_app_samples/tree/master/code/BasicFeature/Connectivity/Http) - [`Http:`数据请求（ArkTS）（API9））](https://gitee.com/openharmony/applications_app_samples/tree/master/code/BasicFeature/Connectivity/Http)
- [使用HTTP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/SmartChatEtsOH) - [使用HTTP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/SmartChatEtsOH)
\ No newline at end of file
zh-cn/application-dev/connectivity/net-connection-manager.md
浏览文件 @ 75afe266
# 网络连接管理 # 网络连接管理
## 简介 ## 简介
网络连接管理提供管理网络一些基础能力，包括WiFi/蜂窝/Ethernet等多网络连接优先级管理、网络质量评估、订阅默认/指定网络连接状态变化、查询网络连接信息、DNS解析等功能。 网络连接管理提供管理网络一些基础能力，包括WiFi/蜂窝/Ethernet等多网络连接优先级管理、网络质量评估、订阅默认/指定网络连接状态变化、查询网络连接信息、DNS解析等功能。
> **说明：** > **说明：**
> 为了保证应用的运行效率，大部分API调用都是异步的，对于异步调用的API均提供了callback和Promise两种方式，以下示例均采用callback函数，更多方式可以查阅[API参考](../reference/apis/js-apis-net-connection.md)。 > 为了保证应用的运行效率，大部分API调用都是异步的，对于异步调用的API均提供了callback和Promise两种方式，以下示例均采用callback函数，更多方式可以查阅[API参考](../reference/apis/js-apis-net-connection.md)。
## 基本概念 ## 基本概念
- 网络生产者：数据网络的提供方，比如WiFi、蜂窝、Ethernet等。
- 网络消费者：数据网络的使用方，比如应用或系统服务。 - 网络生产者：数据网络的提供方，比如WiFi、蜂窝、Ethernet等。
- 网络探测：检测网络有效性，避免将网络从可用网络切换到不可用网络。内容包括绑定网络探测、DNS探测、HTTP探测及HTTPS探测。 - 网络消费者：数据网络的使用方，比如应用或系统服务。
- 网络优选：处理多网络共存时选择最优网络。在网络状态、网络信息及评分发生变化时被触发。 - 网络探测：检测网络有效性，避免将网络从可用网络切换到不可用网络。内容包括绑定网络探测、DNS探测、HTTP探测及HTTPS探测。
- 网络优选：处理多网络共存时选择最优网络。在网络状态、网络信息及评分发生变化时被触发。
## 约束 ## 约束
- 开发语言：C++ JS
- 系统：linux内核 - 开发语言：C++ JS
- 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 - 系统：linux内核
- 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
## 场景介绍 ## 场景介绍
网络连接管理的典型场景有： 网络连接管理的典型场景有：
- 接收指定网络的状态变化通知
- 获取所有注册的网络 - 接收指定网络的状态变化通知
- 根据数据网络查询网络的连接信息 - 获取所有注册的网络
- 使用对应网络解析域名，获取所有IP - 根据数据网络查询网络的连接信息
- 使用对应网络解析域名，获取所有IP
以下分别介绍具体开发方式。 以下分别介绍具体开发方式。
## 接口说明 ## 接口说明
完整的JS API说明以及实例代码请参考：[网络连接管理](../reference/apis/js-apis-net-connection.md)。 完整的JS API说明以及实例代码请参考：[网络连接管理](../reference/apis/js-apis-net-connection.md)。
| 类型 | 接口 | 功能说明 | | 类型 | 接口 | 功能说明 |
...@@ -75,44 +82,46 @@ ...@@ -75,44 +82,46 @@
```js ```js
// 引入包名 // 引入包名
import connection from '@ohos.net.connection' import connection from '@ohos.net.connection'
let netCap = { let netCap = {
// 假设当前默认网络是WiFi，需要创建蜂窝网络连接，可指定网络类型为蜂窝网 // 假设当前默认网络是WiFi，需要创建蜂窝网络连接，可指定网络类型为蜂窝网
bearerTypes: [connection.NetBearType.BEARER_CELLULAR], bearerTypes: [connection.NetBearType.BEARER_CELLULAR],
// 指定网络能力为Internet // 指定网络能力为Internet
networkCap: [connection.NetCap.NET_CAPABILITY_INTERNET], networkCap: [connection.NetCap.NET_CAPABILITY_INTERNET],
}; };
let netSpec = { let netSpec = {
netCapabilities: netCap, netCapabilities: netCap,
}; };
// 指定超时时间为10s(默认值为0) // 指定超时时间为10s(默认值为0)
let timeout = 10 * 1000; let timeout = 10 * 1000;
// 创建NetConnection对象 // 创建NetConnection对象
let conn = connection.createNetConnection(netSpec, timeout); let conn = connection.createNetConnection(netSpec, timeout);
// 订阅事件，如果当前指定网络可用，通过on_netAvailable通知用户 // 订阅事件，如果当前指定网络可用，通过on_netAvailable通知用户
conn.on('netAvailable', (data=> { conn.on('netAvailable', (data => {
console.log("net is available, netId is " + data.netId); console.log("net is available, netId is " + data.netId);
})); }));
// 订阅事件，如果当前指定网络不可用，通过on_netUnavailable通知用户 // 订阅事件，如果当前指定网络不可用，通过on_netUnavailable通知用户
conn.on('netUnavailable', (data=> { conn.on('netUnavailable', (data => {
console.log("net is unavailable, netId is " + data.netId); console.log("net is unavailable, netId is " + data.netId);
})); }));
// 订阅指定网络状态变化的通知 // 订阅指定网络状态变化的通知
conn.register((err, data) => {}); conn.register((err, data) => {
});
// 当不使用该网络时，可以调用该对象的unregister()方法，取消订阅
conn.unregister((err, data) => {}); // 当不使用该网络时，可以调用该对象的unregister()方法，取消订阅
conn.unregister((err, data) => {
});
``` ```
## 获取所有注册的网络 ## 获取所有注册的网络
### 开发步骤 ### 开发步骤
1. 从@ohos.net.connection.d.ts中导入connection命名空间。 1. 从@ohos.net.connection.d.ts中导入connection命名空间。
...@@ -120,21 +129,21 @@ ...@@ -120,21 +129,21 @@
```js ```js
// 引入包名 // 引入包名
import connection from '@ohos.net.connection' import connection from '@ohos.net.connection'
// 获取所有处于连接状态的网络列表 // 获取所有处于连接状态的网络列表
connection.getAllNets((err, data) => { connection.getAllNets((err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
if (data) { if (data) {
this.netList = data; this.netList = data;
} }
}) })
``` ```
## 根据数据网络查询网络的能力信息及连接信息 ## 根据数据网络查询网络的能力信息及连接信息
### 开发步骤 ### 开发步骤
1. 从@ohos.net.connection.d.ts中导入connection命名空间。 1. 从@ohos.net.connection.d.ts中导入connection命名空间。
...@@ -146,89 +155,89 @@ ...@@ -146,89 +155,89 @@
```js ```js
// 引入包名 // 引入包名
import connection from '@ohos.net.connection' import connection from '@ohos.net.connection'
// 调用getDefaultNet方法，获取默认的数据网络(NetHandle) // 调用getDefaultNet方法，获取默认的数据网络(NetHandle)
connection.getDefaultNet((err, data) => { connection.getDefaultNet((err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
if (data) { if (data) {
this.netHandle = data; this.netHandle = data;
} }
}) })
// 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息 // 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息
connection.getNetCapabilities(this.netHandle, (err, data) => { connection.getNetCapabilities(this.netHandle, (err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
// 获取网络类型(bearerTypes) // 获取网络类型(bearerTypes)
for (let item of data.bearerTypes) { for (let item of data.bearerTypes) {
if (item == 0) { if (item == 0) {
// 蜂窝网 // 蜂窝网
console.log(JSON.stringify("BEARER_CELLULAR")); console.log(JSON.stringify("BEARER_CELLULAR"));
} else if (item == 1) { } else if (item == 1) {
// Wi-Fi网络 // Wi-Fi网络
console.log(JSON.stringify("BEARER_WIFI")); console.log(JSON.stringify("BEARER_WIFI"));
} else if (item == 3) { } else if (item == 3) {
// 以太网网络 // 以太网网络
console.log(JSON.stringify("BEARER_ETHERNET")); console.log(JSON.stringify("BEARER_ETHERNET"));
} }
} }
// 获取网络具体能力(networkCap) // 获取网络具体能力(networkCap)
for (let item of data.networkCap) { for (let item of data.networkCap) {
if (item == 0) { if (item == 0) {
// 表示网络可以访问运营商的MMSC（Multimedia Message Service，多媒体短信服务）发送和接收彩信 // 表示网络可以访问运营商的MMSC（Multimedia Message Service，多媒体短信服务）发送和接收彩信
console.log(JSON.stringify("NET_CAPABILITY_MMS")); console.log(JSON.stringify("NET_CAPABILITY_MMS"));
} else if (item == 11) { } else if (item == 11) {
// 表示网络流量未被计费 // 表示网络流量未被计费
console.log(JSON.stringify("NET_CAPABILITY_NOT_METERED")); console.log(JSON.stringify("NET_CAPABILITY_NOT_METERED"));
} else if (item == 12) { } else if (item == 12) {
// 表示该网络应具有访问Internet的能力，该能力由网络提供者设置 // 表示该网络应具有访问Internet的能力，该能力由网络提供者设置
console.log(JSON.stringify("NET_CAPABILITY_INTERNET")); console.log(JSON.stringify("NET_CAPABILITY_INTERNET"));
} else if (item == 15) { } else if (item == 15) {
// 表示网络不使用VPN（Virtual Private Network，虚拟专用网络） // 表示网络不使用VPN（Virtual Private Network，虚拟专用网络）
console.log(JSON.stringify("NET_CAPABILITY_NOT_VPN")); console.log(JSON.stringify("NET_CAPABILITY_NOT_VPN"));
} else if (item == 16) { } else if (item == 16) {
// 表示该网络访问Internet的能力被网络管理成功验证，该能力由网络管理模块设置 // 表示该网络访问Internet的能力被网络管理成功验证，该能力由网络管理模块设置
console.log(JSON.stringify("NET_CAPABILITY_VALIDATED")); console.log(JSON.stringify("NET_CAPABILITY_VALIDATED"));
} }
} }
}) })
// 获取netHandle对应网络的连接信息。连接信息包含了链路信息、路由信息等 // 获取netHandle对应网络的连接信息。连接信息包含了链路信息、路由信息等
connection.getConnectionProperties(this.netHandle, (err, data) => { connection.getConnectionProperties(this.netHandle, (err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}) })
// 调用getAllNets,获取所有处于连接状态的网络列表(Array<NetHandle>) // 调用getAllNets,获取所有处于连接状态的网络列表(Array<NetHandle>)
connection.getAllNets((err, data) => { connection.getAllNets((err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
if (data) { if (data) {
this.netList = data; this.netList = data;
} }
}) })
for (let item of this.netList) { for (let item of this.netList) {
// 循环获取网络列表每个netHandle对应网络的能力信息 // 循环获取网络列表每个netHandle对应网络的能力信息
connection.getNetCapabilities(item, (err, data) => { connection.getNetCapabilities(item, (err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}) })
// 循环获取网络列表每个netHandle对应的网络的连接信息 // 循环获取网络列表每个netHandle对应的网络的连接信息
connection.getConnectionProperties(item, (err, data) => { connection.getConnectionProperties(item, (err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}) })
} }
``` ```
## 使用对应网络解析域名，获取所有IP ## 使用对应网络解析域名，获取所有IP
### 开发步骤 ### 开发步骤
1. 从@ohos.net.connection.d.ts中导入connection命名空间。 1. 从@ohos.net.connection.d.ts中导入connection命名空间。
...@@ -236,11 +245,11 @@ ...@@ -236,11 +245,11 @@
```js ```js
// 引入包名 // 引入包名
import connection from '@ohos.net.connection' import connection from '@ohos.net.connection'
// 使用默认网络解析主机名以获取所有IP地址 // 使用默认网络解析主机名以获取所有IP地址
connection.getAddressesByName(this.host, (err, data) => { connection.getAddressesByName(this.host, (err, data) => {
console.log(JSON.stringify(err)); console.log(JSON.stringify(err));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}) })
``` ```
zh-cn/application-dev/connectivity/net-ethernet.md
浏览文件 @ 75afe266
# 以太网连接 # 以太网连接
## 简介 ## 简介
以太网连接的功能是提供支持设备通过硬件接口，以插入网线的形式访问互联网的能力。
设备接入网线后，可以获取动态分配的IP地址，子网掩码，Gateway，DNS等一系列网络属性；通过静态模式，手动配置与获取设备的网络属性。 以太网连接的功能是提供支持设备通过硬件接口，以插入网线的形式访问互联网的能力。 设备接入网线后，可以获取动态分配的IP地址，子网掩码，Gateway，DNS等一系列网络属性；通过静态模式，手动配置与获取设备的网络属性。
> **说明：** > **说明：**
> 为了保证应用的运行效率，大部分API调用都是异步的，对于异步调用的API均提供了callback和Promise两种方式，以下示例均采用callback函数，更多方式可以查阅[API参考](../reference/apis/js-apis-net-ethernet.md)。 > 为了保证应用的运行效率，大部分API调用都是异步的，对于异步调用的API均提供了callback和Promise两种方式，以下示例均采用callback函数，更多方式可以查阅[API参考](../reference/apis/js-apis-net-ethernet.md)。
## 约束 ## 约束
- 开发语言：C++ JS
- 系统：linux内核 - 开发语言：C++ JS
- 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 - 系统：linux内核
- 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
## 场景介绍 ## 场景介绍
以太网连接的典型场景有： 以太网连接的典型场景有：
- DHCP模式，通过动态分配IP地址，子网掩码，Gateway，DNS等一系列网络属性，使能访问网络。
- 静态模式，通过静态配置IP地址，子网掩码，Gateway，DNS等一系列网络属性，使能访问网络。 - DHCP模式，通过动态分配IP地址，子网掩码，Gateway，DNS等一系列网络属性，使能访问网络。
- 静态模式，通过静态配置IP地址，子网掩码，Gateway，DNS等一系列网络属性，使能访问网络。
以下分别介绍具体开发方式。 以下分别介绍具体开发方式。
## 接口说明 ## 接口说明
完整的JS API说明以及实例代码请参考：[以太网连接](../reference/apis/js-apis-net-ethernet.md)。 完整的JS API说明以及实例代码请参考：[以太网连接](../reference/apis/js-apis-net-ethernet.md)。
| 类型 | 接口 | 功能说明 | | 类型 | 接口 | 功能说明 |
...@@ -28,6 +32,8 @@ ...@@ -28,6 +32,8 @@
| ohos.net.ethernet | function getIfaceConfig(iface: string, callback: AsyncCallback\<InterfaceConfiguration>): void | 获取指定以太网的网络属性，iface为网口名称，调用callback | | ohos.net.ethernet | function getIfaceConfig(iface: string, callback: AsyncCallback\<InterfaceConfiguration>): void | 获取指定以太网的网络属性，iface为网口名称，调用callback |
| ohos.net.ethernet | function isIfaceActive(iface: string, callback: AsyncCallback\<number>): void | 判断指定网口是否已激活，iface为网卡名称（无参为是否有激活网口），调用callback | | ohos.net.ethernet | function isIfaceActive(iface: string, callback: AsyncCallback\<number>): void | 判断指定网口是否已激活，iface为网卡名称（无参为是否有激活网口），调用callback |
| ohos.net.ethernet | function getAllActiveIfaces(callback: AsyncCallback\<Array\<string>>): void; | 获取所有活动的网络接口，调用callback | | ohos.net.ethernet | function getAllActiveIfaces(callback: AsyncCallback\<Array\<string>>): void; | 获取所有活动的网络接口，调用callback |
| ohos.net.ethernet | function on(type: 'interfaceStateChange', callback: Callback\<{ iface: string, active: boolean }\>): void; | 注册网络接口监听函数 |
| ohos.net.ethernet | function off(type: 'interfaceStateChange', callback?: Callback\<{ iface: string, active: boolean }\>): void; | 解除注册网络接口监听函数 |
## 以太网连接-DHCP模式 ## 以太网连接-DHCP模式
...@@ -39,44 +45,45 @@ ...@@ -39,44 +45,45 @@
```js ```js
// 从@ohos.net.ethernet中导入ethernet命名空间 // 从@ohos.net.ethernet中导入ethernet命名空间
import ethernet from '@ohos.net.ethernet' import ethernet from '@ohos.net.ethernet'
// getAllActiveIfaces获取所有活动的网络设备名称 // getAllActiveIfaces获取所有活动的网络设备名称
ethernet.getAllActiveIfaces((error, data) => { ethernet.getAllActiveIfaces((error, data) => {
if (error) { if (error) {
console.log("getAllActiveIfaces callback error = " + error); console.log("getAllActiveIfaces callback error = " + error);
} else { } else {
console.log("getAllActiveIfaces callback data.length = " + data.length); console.log("getAllActiveIfaces callback data.length = " + data.length);
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
console.log("getAllActiveIfaces callback = " + data[i]); console.log("getAllActiveIfaces callback = " + data[i]);
} }
} }
}); });
// isIfaceActive判断指定网口是否已激活 // isIfaceActive判断指定网口是否已激活
ethernet.isIfaceActive("eth0", (error, data) => { ethernet.isIfaceActive("eth0", (error, data) => {
if (error) { if (error) {
console.log("isIfaceActive callback error = " + error); console.log("isIfaceActive callback error = " + error);
} else { } else {
console.log("isIfaceActive callback = " + data); console.log("isIfaceActive callback = " + data);
} }
}); });
// getIfaceConfig获取指定以太网的网络属性 // getIfaceConfig获取指定以太网的网络属性
ethernet.getIfaceConfig("eth0", (error, data) => { ethernet.getIfaceConfig("eth0", (error, data) => {
if (error) { if (error) {
console.log("getIfaceConfig callback error = " + error); console.log("getIfaceConfig callback error = " + error);
} else { } else {
console.log("getIfaceConfig callback mode = " + data.mode); console.log("getIfaceConfig callback mode = " + data.mode);
console.log("getIfaceConfig callback ipAddr = " + data.ipAddr); console.log("getIfaceConfig callback ipAddr = " + data.ipAddr);
console.log("getIfaceConfig callback routeAddr = " + data.routeAddr); console.log("getIfaceConfig callback routeAddr = " + data.routeAddr);
console.log("getIfaceConfig callback gateAddr = " + data.gateAddr); console.log("getIfaceConfig callback gateAddr = " + data.gateAddr);
console.log("getIfaceConfig callback maskAddr = " + data.maskAddr); console.log("getIfaceConfig callback maskAddr = " + data.maskAddr);
console.log("getIfaceConfig callback dns0Addr = " + data.dns0Addr); console.log("getIfaceConfig callback dns0Addr = " + data.dns0Addr);
console.log("getIfaceConfig callback dns1Addr = " + data.dns1Addr); console.log("getIfaceConfig callback dns1Addr = " + data.dns1Addr);
} }
}); });
``` ```
## 以太网连接-静态模式 ## 以太网连接-静态模式
### 开发步骤 ### 开发步骤
...@@ -90,51 +97,75 @@ ...@@ -90,51 +97,75 @@
```js ```js
// 从@ohos.net.ethernet中导入ethernet命名空间 // 从@ohos.net.ethernet中导入ethernet命名空间
import ethernet from '@ohos.net.ethernet' import ethernet from '@ohos.net.ethernet'
// getAllActiveIfaces获取所有活动的网络设备名称 // getAllActiveIfaces获取所有活动的网络设备名称
ethernet.getAllActiveIfaces((error, data) => { ethernet.getAllActiveIfaces((error, data) => {
if (error) { if (error) {
console.log("getAllActiveIfaces callback error = " + error); console.log("getAllActiveIfaces callback error = " + error);
} else { } else {
console.log("getAllActiveIfaces callback data.length = " + data.length); console.log("getAllActiveIfaces callback data.length = " + data.length);
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
console.log("getAllActiveIfaces callback = " + data[i]); console.log("getAllActiveIfaces callback = " + data[i]);
} }
} }
}); });
// isIfaceActive判断指定网口是否已激活 // isIfaceActive判断指定网口是否已激活
ethernet.isIfaceActive("eth0", (error, data) => { ethernet.isIfaceActive("eth0", (error, data) => {
if (error) { if (error) {
console.log("isIfaceActive callback error = " + error); console.log("isIfaceActive callback error = " + error);
} else { } else {
console.log("isIfaceActive callback = " + data); console.log("isIfaceActive callback = " + data);
} }
}); });
// setIfaceConfig配置指定以太网的网络属性 // setIfaceConfig配置指定以太网的网络属性
ethernet.setIfaceConfig("eth0", {mode:ethernet.STATIC,ipAddr:"192.168.xx.xx", routeAddr:"192.168.xx.xx", ethernet.setIfaceConfig("eth0", {
gateAddr:"192.168.xx.xx", maskAddr:"255.255.xx.xx", dnsAddr0:"1.1.xx.xx", dnsAddr1:"2.2.xx.xx"},(error) => { mode: ethernet.STATIC, ipAddr: "192.168.xx.xx", routeAddr: "192.168.xx.xx",
if (error) { gateAddr: "192.168.xx.xx", maskAddr: "255.255.xx.xx", dnsAddr0: "1.1.xx.xx", dnsAddr1: "2.2.xx.xx"
console.log("setIfaceConfig callback error = " + error); }, (error) => {
} else { if (error) {
console.log("setIfaceConfig callback ok "); console.log("setIfaceConfig callback error = " + error);
} } else {
}); console.log("setIfaceConfig callback ok ");
}
// getIfaceConfig获取指定以太网的网络属性 });
ethernet.getIfaceConfig("eth0", (error, data) => {
if (error) { // getIfaceConfig获取指定以太网的网络属性
console.log("getIfaceConfig callback error = " + error); ethernet.getIfaceConfig("eth0", (error, data) => {
} else { if (error) {
console.log("getIfaceConfig callback mode = " + data.mode); console.log("getIfaceConfig callback error = " + error);
console.log("getIfaceConfig callback ipAddr = " + data.ipAddr); } else {
console.log("getIfaceConfig callback routeAddr = " + data.routeAddr); console.log("getIfaceConfig callback mode = " + data.mode);
console.log("getIfaceConfig callback gateAddr = " + data.gateAddr); console.log("getIfaceConfig callback ipAddr = " + data.ipAddr);
console.log("getIfaceConfig callback maskAddr = " + data.maskAddr); console.log("getIfaceConfig callback routeAddr = " + data.routeAddr);
console.log("getIfaceConfig callback dns0Addr = " + data.dns0Addr); console.log("getIfaceConfig callback gateAddr = " + data.gateAddr);
console.log("getIfaceConfig callback dns1Addr = " + data.dns1Addr); console.log("getIfaceConfig callback maskAddr = " + data.maskAddr);
} console.log("getIfaceConfig callback dns0Addr = " + data.dns0Addr);
}); console.log("getIfaceConfig callback dns1Addr = " + data.dns1Addr);
}
});
``` ```
## 监听网络设备接口状态变化
### 开发步骤
1. 从@ohos.net.ethernet中导入ethernet命名空间。
2. 调用该对象的on()方法，订阅interfaceStateChange事件。可以根据业务需要订阅此消息。
3. 订阅interfaceStateChange事件后，回调函数会在网卡设备的接口状态发生变化时触发。
4. 调用该对象的off()方法，取消订阅interfaceStateChange事件。
```js
// 从@ohos.net.ethernet中导入ethernet命名空间
import ethernet from '@ohos.net.ethernet'
// 订阅interfaceStateChange事件
ethernet.on('interfaceStateChange', ((data) => {
console.log(JSON.stringify(data));
}));
// 取消事件订阅
ethernet.off('interfaceStateChange');
```
\ No newline at end of file
zh-cn/application-dev/connectivity/net-sharing.md
浏览文件 @ 75afe266
# 网络共享 # 网络共享
## 简介 ## 简介
网络共享管理分享设备已有网络给其他连接设备，支持Wi-Fi热点共享、蓝牙共享和USB共享，同时提供网络共享状态、共享流量查询功能。 网络共享管理分享设备已有网络给其他连接设备，支持Wi-Fi热点共享、蓝牙共享和USB共享，同时提供网络共享状态、共享流量查询功能。
> **说明：** > **说明：**
> 为了保证应用的运行效率，大部分API调用都是异步的，对于异步调用的API均提供了callback和Promise两种方式，以下示例均采用callback函数，更多方式可以查阅[API参考](../reference/apis/js-apis-net-sharing.md)。 > 为了保证应用的运行效率，大部分API调用都是异步的，对于异步调用的API均提供了callback和Promise两种方式，以下示例均采用callback函数，更多方式可以查阅[API参考](../reference/apis/js-apis-net-sharing.md)。
## 基本概念 ## 基本概念
- WIFI共享：通过WIFI热点共享网络。
- 蓝牙共享：通过蓝牙共享网络。 - WIFI共享：通过WIFI热点共享网络。
- USB共享：通过USB共享网络。 - 蓝牙共享：通过蓝牙共享网络。
- USB共享：通过USB共享网络。
## 约束 ## 约束
- 开发语言：C++ JS
- 系统：linux内核 - 开发语言：C++ JS
- 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 - 系统：linux内核
- 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
## 场景介绍 ## 场景介绍
网络共享的典型场景有： 网络共享的典型场景有：
- 开启网络共享
- 停止网络共享 - 开启网络共享
- 获取共享网络的数据流量 - 停止网络共享
- 获取共享网络的数据流量
以下分别介绍具体开发方式。 以下分别介绍具体开发方式。
## 接口说明 ## 接口说明
完整的JS API说明以及实例代码请参考：[网络共享](../reference/apis/js-apis-net-sharing.md)。 完整的JS API说明以及实例代码请参考：[网络共享](../reference/apis/js-apis-net-sharing.md)。
| 类型 | 接口 | 功能说明 | | 类型 | 接口 | 功能说明 |
...@@ -54,18 +61,18 @@ ...@@ -54,18 +61,18 @@
```js ```js
// 从@ohos.net.sharing中导入sharing命名空间 // 从@ohos.net.sharing中导入sharing命名空间
import sharing from '@ohos.net.sharing' import sharing from '@ohos.net.sharing'
// 注册监听共享状态的改变 // 注册监听共享状态的改变
sharing.on('sharingStateChange', (error, data) => { sharing.on('sharingStateChange', (error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
// 调用startSharing方法，来开启指定类型共享 // 调用startSharing方法，来开启指定类型共享
sharing.startSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => { sharing.startSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
## 停止网络共享 ## 停止网络共享
...@@ -79,18 +86,18 @@ ...@@ -79,18 +86,18 @@
```js ```js
// 从@ohos.net.sharing中导入sharing命名空间 // 从@ohos.net.sharing中导入sharing命名空间
import sharing from '@ohos.net.sharing' import sharing from '@ohos.net.sharing'
// 注册监听共享状态的改变 // 注册监听共享状态的改变
sharing.on('sharingStateChange', (error, data) => { sharing.on('sharingStateChange', (error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
// 调用stopSharing方法，来停止指定类型共享 // 调用stopSharing方法，来停止指定类型共享
sharing.stopSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => { sharing.stopSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
## 获取共享网络的数据流量 ## 获取共享网络的数据流量
...@@ -104,27 +111,27 @@ ...@@ -104,27 +111,27 @@
```js ```js
// 从@ohos.net.sharing中导入sharing命名空间 // 从@ohos.net.sharing中导入sharing命名空间
import sharing from '@ohos.net.sharing' import sharing from '@ohos.net.sharing'
// 调用startSharing方法，来开启指定类型共享 // 调用startSharing方法，来开启指定类型共享
sharing.startSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => { sharing.startSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
// 调用getStatsTotalBytes方法，来获取共享网络数据量 // 调用getStatsTotalBytes方法，来获取共享网络数据量
sharing.getStatsTotalBytes((error, data) => { sharing.getStatsTotalBytes((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
// 调用stopSharing方法，来停止指定类型共享，共享网络数据量清零 // 调用stopSharing方法，来停止指定类型共享，共享网络数据量清零
sharing.stopSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => { sharing.stopSharing(sharing.SharingIfaceType.SHARING_WIFI, (error) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
// 再次调用getStatsTotalBytes方法，共享网络数据量已清零 // 再次调用getStatsTotalBytes方法，共享网络数据量已清零
sharing.getStatsTotalBytes((error, data) => { sharing.getStatsTotalBytes((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
zh-cn/application-dev/connectivity/socket-connection.md
浏览文件 @ 75afe266
...@@ -186,143 +186,144 @@ UDP与TCP流程大体类似，下面以TCP为例： ...@@ -186,143 +186,144 @@ UDP与TCP流程大体类似，下面以TCP为例：
```js ```js
import socket from '@ohos.net.socket' import socket from '@ohos.net.socket'
// 创建一个（双向认证）TLS Socket连接，返回一个TLS Socket对象。 // 创建一个（双向认证）TLS Socket连接，返回一个TLS Socket对象。
let tlsTwoWay = socket.constructTLSSocketInstance(); let tlsTwoWay = socket.constructTLSSocketInstance();
// 订阅TLS Socket相关的订阅事件 // 订阅TLS Socket相关的订阅事件
tlsTwoWay.on('message', value => { tlsTwoWay.on('message', value => {
console.log("on message") console.log("on message")
let buffer = value.message let buffer = value.message
let dataView = new DataView(buffer) let dataView = new DataView(buffer)
let str = "" let str = ""
for (let i = 0; i < dataView.byteLength; ++i) { for (let i = 0; i < dataView.byteLength; ++i) {
str += String.fromCharCode(dataView.getUint8(i)) str += String.fromCharCode(dataView.getUint8(i))
} }
console.log("on connect received:" + str) console.log("on connect received:" + str)
}); });
tlsTwoWay.on('connect', () => { tlsTwoWay.on('connect', () => {
console.log("on connect") console.log("on connect")
}); });
tlsTwoWay.on('close', () => { tlsTwoWay.on('close', () => {
console.log("on close") console.log("on close")
}); });
// 绑定本地IP地址和端口。 // 绑定本地IP地址和端口。
tlsTwoWay.bind({address: '192.168.xxx.xxx', port: xxxx, family: 1}, err => { tlsTwoWay.bind({address: '192.168.xxx.xxx', port: xxxx, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
}); });
// 设置通信过程中使用参数 // 设置通信过程中使用参数
let options = { let options = {
ALPNProtocols: ["spdy/1", "http/1.1"], ALPNProtocols: ["spdy/1", "http/1.1"],
// 连接到指定的IP地址和端口。 // 连接到指定的IP地址和端口。
address: { address: {
address: "192.168.xx.xxx", address: "192.168.xx.xxx",
port: xxxx, // 端口 port: xxxx, // 端口
family: 1, family: 1,
}, },
// 设置用于通信过程中完成校验的参数。 // 设置用于通信过程中完成校验的参数。
secureOptions: { secureOptions: {
key: "xxxx", // 密钥 key: "xxxx", // 密钥
cert: "xxxx", // 数字证书 cert: "xxxx", // 数字证书
ca: ["xxxx"], // CA证书 ca: ["xxxx"], // CA证书
passwd: "xxxx", // 生成密钥时的密码 passwd: "xxxx", // 生成密钥时的密码
protocols: [socket.Protocol.TLSv12], // 通信协议 protocols: [socket.Protocol.TLSv12], // 通信协议
useRemoteCipherPrefer: true, // 是否优先使用对端密码套件 useRemoteCipherPrefer: true, // 是否优先使用对端密码套件
signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", // 签名算法 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", // 签名算法
cipherSuite: "AES256-SHA256", // 密码套件 cipherSuite: "AES256-SHA256", // 密码套件
}, },
}; };
// 建立连接 // 建立连接
tlsTwoWay.connect(options, (err, data) => { tlsTwoWay.connect(options, (err, data) => {
console.error(err); console.error(err);
console.log(data); console.log(data);
}); });
// 连接使用完毕后，主动关闭。取消相关事件的订阅。 // 连接使用完毕后，主动关闭。取消相关事件的订阅。
tlsTwoWay.close((err) => { tlsTwoWay.close((err) => {
if (err) { if (err) {
console.log("close callback error = " + err); console.log("close callback error = " + err);
} else { } else {
console.log("close success"); console.log("close success");
} }
tlsTwoWay.off('message'); tlsTwoWay.off('message');
tlsTwoWay.off('connect'); tlsTwoWay.off('connect');
tlsTwoWay.off('close'); tlsTwoWay.off('close');
}); });
// 创建一个（单向认证）TLS Socket连接，返回一个TLS Socket对象。 // 创建一个（单向认证）TLS Socket连接，返回一个TLS Socket对象。
let tlsOneWay = socket.constructTLSSocketInstance(); // One way authentication let tlsOneWay = socket.constructTLSSocketInstance(); // One way authentication
// 订阅TLS Socket相关的订阅事件 // 订阅TLS Socket相关的订阅事件
tlsTwoWay.on('message', value => { tlsTwoWay.on('message', value => {
console.log("on message") console.log("on message")
let buffer = value.message let buffer = value.message
let dataView = new DataView(buffer) let dataView = new DataView(buffer)
let str = "" let str = ""
for (let i = 0;i < dataView.byteLength; ++i) { for (let i = 0; i < dataView.byteLength; ++i) {
str += String.fromCharCode(dataView.getUint8(i)) str += String.fromCharCode(dataView.getUint8(i))
} }
console.log("on connect received:" + str) console.log("on connect received:" + str)
}); });
tlsTwoWay.on('connect', () => { tlsTwoWay.on('connect', () => {
console.log("on connect") console.log("on connect")
}); });
tlsTwoWay.on('close', () => { tlsTwoWay.on('close', () => {
console.log("on close") console.log("on close")
}); });
// 绑定本地IP地址和端口。 // 绑定本地IP地址和端口。
tlsOneWay.bind({address: '192.168.xxx.xxx', port: xxxx, family: 1}, err => { tlsOneWay.bind({address: '192.168.xxx.xxx', port: xxxx, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
}); });
// 设置通信过程中使用参数 // 设置通信过程中使用参数
let oneWayOptions = { let oneWayOptions = {
address: { address: {
address: "192.168.xxx.xxx", address: "192.168.xxx.xxx",
port: xxxx, port: xxxx,
family: 1, family: 1,
}, },
secureOptions: { secureOptions: {
ca: ["xxxx","xxxx"], // CA证书 ca: ["xxxx", "xxxx"], // CA证书
cipherSuite: "AES256-SHA256", // 密码套件 cipherSuite: "AES256-SHA256", // 密码套件
}, },
}; };
// 建立连接 // 建立连接
tlsOneWay.connect(oneWayOptions, (err, data) => { tlsOneWay.connect(oneWayOptions, (err, data) => {
console.error(err); console.error(err);
console.log(data); console.log(data);
}); });
// 连接使用完毕后，主动关闭。取消相关事件的订阅。 // 连接使用完毕后，主动关闭。取消相关事件的订阅。
tlsTwoWay.close((err) => { tlsTwoWay.close((err) => {
if (err) { if (err) {
console.log("close callback error = " + err); console.log("close callback error = " + err);
} else { } else {
console.log("close success"); console.log("close success");
} }
tlsTwoWay.off('message'); tlsTwoWay.off('message');
tlsTwoWay.off('connect'); tlsTwoWay.off('connect');
tlsTwoWay.off('close'); tlsTwoWay.off('close');
}); });
``` ```
## 相关实例 ## 相关实例
针对Socket连接开发，有以下相关实例可供参考： 针对Socket连接开发，有以下相关实例可供参考：
- [`Socket`：Socket 连接（ArkTS）（API9）](https://gitee.com/openharmony/applications_app_samples/tree/master/Network/Socket) - [`Socket`：Socket 连接（ArkTS）（API9）](https://gitee.com/openharmony/applications_app_samples/tree/master/Network/Socket)
- [使用UDP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/UdpDemoOH) - [使用UDP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/UdpDemoOH)
- [使用TCP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/TcpSocketDemo) - [使用TCP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/TcpSocketDemo)
zh-cn/application-dev/connectivity/websocket-connection.md
浏览文件 @ 75afe266
# WebSocket连接 # WebSocket连接
## 场景介绍 ## 场景介绍
使用WebSocket建立服务器与客户端的双向连接，需要先通过createWebSocket()方法创建WebSocket对象，然后通过connect()方法连接到服务器。当连接成功后，客户端会收到open事件的回调，之后客户端就可以通过send()方法与服务器进行通信。当服务器发信息给客户端时，客户端会收到message事件的回调。当客户端不要此连接时，可以通过调用close()方法主动断开连接，之后客户端会收到close事件的回调。 使用WebSocket建立服务器与客户端的双向连接，需要先通过createWebSocket()方法创建WebSocket对象，然后通过connect()方法连接到服务器。当连接成功后，客户端会收到open事件的回调，之后客户端就可以通过send()方法与服务器进行通信。当服务器发信息给客户端时，客户端会收到message事件的回调。当客户端不要此连接时，可以通过调用close()方法主动断开连接，之后客户端会收到close事件的回调。
若在上述任一过程中发生错误，客户端会收到error事件的回调。 若在上述任一过程中发生错误，客户端会收到error事件的回调。
## 接口说明 ## 接口说明
WebSocket连接功能主要由webSocket模块提供。使用该功能需要申请ohos.permission.INTERNET权限。具体接口说明如下表。 WebSocket连接功能主要由webSocket模块提供。使用该功能需要申请ohos.permission.INTERNET权限。具体接口说明如下表。
...@@ -27,7 +25,6 @@ WebSocket连接功能主要由webSocket模块提供。使用该功能需要申 ...@@ -27,7 +25,6 @@ WebSocket连接功能主要由webSocket模块提供。使用该功能需要申
| on(type: 'error') | 订阅WebSocket的Error事件。 | | on(type: 'error') | 订阅WebSocket的Error事件。 |
| off(type: 'error') | 取消订阅WebSocket的Error事件。 | | off(type: 'error') | 取消订阅WebSocket的Error事件。 |
## 开发步骤 ## 开发步骤
1. 导入需要的webSocket模块。 1. 导入需要的webSocket模块。
...@@ -39,7 +36,7 @@ WebSocket连接功能主要由webSocket模块提供。使用该功能需要申 ...@@ -39,7 +36,7 @@ WebSocket连接功能主要由webSocket模块提供。使用该功能需要申
4. 根据URL地址，发起WebSocket连接。 4. 根据URL地址，发起WebSocket连接。
5. 使用完WebSocket连接之后，主动断开连接。 5. 使用完WebSocket连接之后，主动断开连接。
```js ```js
import webSocket from '@ohos.net.webSocket'; import webSocket from '@ohos.net.webSocket';
...@@ -87,4 +84,5 @@ WebSocket连接功能主要由webSocket模块提供。使用该功能需要申 ...@@ -87,4 +84,5 @@ WebSocket连接功能主要由webSocket模块提供。使用该功能需要申
## 相关实例 ## 相关实例
针对WebSocket连接的开发，有以下相关实例可供参考： 针对WebSocket连接的开发，有以下相关实例可供参考：
- [`WebSocket`：WebSocket（ArkTS）（API9）](https://gitee.com/openharmony/applications_app_samples/tree/master/Network/WebSocket) - [`WebSocket`：WebSocket（ArkTS）（API9）](https://gitee.com/openharmony/applications_app_samples/tree/master/Network/WebSocket)
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-http.md
浏览文件 @ 75afe266
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
本模块提供HTTP数据请求能力。应用可以通过HTTP发起一个数据请求，支持常见的GET、POST、OPTIONS、HEAD、PUT、DELETE、TRACE、CONNECT方法。 本模块提供HTTP数据请求能力。应用可以通过HTTP发起一个数据请求，支持常见的GET、POST、OPTIONS、HEAD、PUT、DELETE、TRACE、CONNECT方法。
>**说明：** > **说明：**
> >
>本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 >本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
> >
...@@ -24,44 +24,44 @@ let httpRequest = http.createHttp(); ...@@ -24,44 +24,44 @@ let httpRequest = http.createHttp();
// 用于订阅HTTP响应头，此接口会比request请求先返回。可以根据业务需要订阅此消息 // 用于订阅HTTP响应头，此接口会比request请求先返回。可以根据业务需要订阅此消息
// 从API 8开始，使用on('headersReceive', Callback)替代on('headerReceive', AsyncCallback)。 8+ // 从API 8开始，使用on('headersReceive', Callback)替代on('headerReceive', AsyncCallback)。 8+
httpRequest.on('headersReceive', (header) => { httpRequest.on('headersReceive', (header) => {
console.info('header: ' + JSON.stringify(header)); console.info('header: ' + JSON.stringify(header));
}); });
httpRequest.request( httpRequest.request(
// 填写HTTP请求的URL地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定 // 填写HTTP请求的URL地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定
"EXAMPLE_URL", "EXAMPLE_URL",
{ {
method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET
// 开发者根据自身业务需要添加header字段 // 开发者根据自身业务需要添加header字段
header: { header: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
// 当使用POST请求时此字段用于传递内容 // 当使用POST请求时此字段用于传递内容
extraData: { extraData: {
"data": "data to send", "data": "data to send",
}, },
expectDataType: http.HttpDataType.STRING, // 可选，指定返回数据的类型 expectDataType: http.HttpDataType.STRING, // 可选，指定返回数据的类型
usingCache: true, // 可选，默认为true usingCache: true, // 可选，默认为true
priority: 1, // 可选，默认为1 priority: 1, // 可选，默认为1
connectTimeout: 60000, // 可选，默认为60000ms connectTimeout: 60000, // 可选，默认为60000ms
readTimeout: 60000, // 可选，默认为60000ms readTimeout: 60000, // 可选，默认为60000ms
usingProtocol: http.HttpProtocol.HTTP1_1, // 可选，协议类型默认值由系统自动指定 usingProtocol: http.HttpProtocol.HTTP1_1, // 可选，协议类型默认值由系统自动指定
usingProxy: false, //可选，默认不使用网络代理，自API 10开始支持该属性 usingProxy: false, //可选，默认不使用网络代理，自API 10开始支持该属性
}, (err, data) => { }, (err, data) => {
if (!err) { if (!err) {
// data.result为HTTP响应内容，可根据业务需要进行解析 // data.result为HTTP响应内容，可根据业务需要进行解析
console.info('Result:' + JSON.stringify(data.result)); console.info('Result:' + JSON.stringify(data.result));
console.info('code:' + JSON.stringify(data.responseCode)); console.info('code:' + JSON.stringify(data.responseCode));
// data.header为HTTP响应头，可根据业务需要进行解析 // data.header为HTTP响应头，可根据业务需要进行解析
console.info('header:' + JSON.stringify(data.header)); console.info('header:' + JSON.stringify(data.header));
console.info('cookies:' + JSON.stringify(data.cookies)); // 8+ console.info('cookies:' + JSON.stringify(data.cookies)); // 8+
} else { } else {
console.info('error:' + JSON.stringify(err)); console.info('error:' + JSON.stringify(err));
// 取消订阅HTTP响应头事件 // 取消订阅HTTP响应头事件
httpRequest.off('headersReceive'); httpRequest.off('headersReceive');
// 当该请求使用完毕时，调用destroy方法主动销毁。 // 当该请求使用完毕时，调用destroy方法主动销毁。
httpRequest.destroy(); httpRequest.destroy();
}
} }
}
); );
``` ```
...@@ -83,6 +83,7 @@ createHttp(): HttpRequest ...@@ -83,6 +83,7 @@ createHttp(): HttpRequest
```js ```js
import http from '@ohos.net.http'; import http from '@ohos.net.http';
let httpRequest = http.createHttp(); let httpRequest = http.createHttp();
``` ```
...@@ -96,8 +97,8 @@ request(url: string, callback: AsyncCallback\<HttpResponse\>):void ...@@ -96,8 +97,8 @@ request(url: string, callback: AsyncCallback\<HttpResponse\>):void
根据URL地址，发起HTTP网络请求，使用callback方式作为异步方法。 根据URL地址，发起HTTP网络请求，使用callback方式作为异步方法。
>**说明：** > **说明：**
>此接口仅支持数据大小为5M以内的数据传输。 > 此接口仅支持数据大小为5M以内的数据传输。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -122,7 +123,7 @@ request(url: string, callback: AsyncCallback\<HttpResponse\>):void ...@@ -122,7 +123,7 @@ request(url: string, callback: AsyncCallback\<HttpResponse\>):void
| 2300052 | Server returned nothing (no headers, no data). | | 2300052 | Server returned nothing (no headers, no data). |
| 2300999 | Unknown Other Error. | | 2300999 | Unknown Other Error. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。 > 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。
> HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html) > HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html)
...@@ -130,14 +131,14 @@ request(url: string, callback: AsyncCallback\<HttpResponse\>):void ...@@ -130,14 +131,14 @@ request(url: string, callback: AsyncCallback\<HttpResponse\>):void
```js ```js
httpRequest.request("EXAMPLE_URL", (err, data) => { httpRequest.request("EXAMPLE_URL", (err, data) => {
if (!err) { if (!err) {
console.info('Result:' + data.result); console.info('Result:' + data.result);
console.info('code:' + data.responseCode); console.info('code:' + data.responseCode);
console.info('header:' + JSON.stringify(data.header)); console.info('header:' + JSON.stringify(data.header));
console.info('cookies:' + data.cookies); // 8+ console.info('cookies:' + data.cookies); // 8+
} else { } else {
console.info('error:' + JSON.stringify(err)); console.info('error:' + JSON.stringify(err));
} }
}); });
``` ```
...@@ -147,8 +148,8 @@ request(url: string, options: HttpRequestOptions, callback: AsyncCallback\<HttpR ...@@ -147,8 +148,8 @@ request(url: string, options: HttpRequestOptions, callback: AsyncCallback\<HttpR
根据URL地址和相关配置项，发起HTTP网络请求，使用callback方式作为异步方法。 根据URL地址和相关配置项，发起HTTP网络请求，使用callback方式作为异步方法。
>**说明：** > **说明：**
>此接口仅支持数据大小为5M以内的数据传输。 > 此接口仅支持数据大小为5M以内的数据传输。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -198,7 +199,7 @@ request(url: string, options: HttpRequestOptions, callback: AsyncCallback\<HttpR ...@@ -198,7 +199,7 @@ request(url: string, options: HttpRequestOptions, callback: AsyncCallback\<HttpR
| 2300094 | An authentication function returned an error. | | 2300094 | An authentication function returned an error. |
| 2300999 | Unknown Other Error. | | 2300999 | Unknown Other Error. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。 > 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。
> HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html) > HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html)
...@@ -206,25 +207,25 @@ request(url: string, options: HttpRequestOptions, callback: AsyncCallback\<HttpR ...@@ -206,25 +207,25 @@ request(url: string, options: HttpRequestOptions, callback: AsyncCallback\<HttpR
```js ```js
httpRequest.request("EXAMPLE_URL", httpRequest.request("EXAMPLE_URL",
{ {
method: http.RequestMethod.GET, method: http.RequestMethod.GET,
header: { header: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
readTimeout: 60000, readTimeout: 60000,
connectTimeout: 60000 connectTimeout: 60000
}, (err, data) => { }, (err, data) => {
if (!err) { if (!err) {
console.info('Result:' + data.result); console.info('Result:' + data.result);
console.info('code:' + data.responseCode); console.info('code:' + data.responseCode);
console.info('header:' + JSON.stringify(data.header)); console.info('header:' + JSON.stringify(data.header));
console.info('cookies:' + data.cookies); // 8+ console.info('cookies:' + data.cookies); // 8+
console.info('header.Content-Type:' + data.header['Content-Type']); console.info('header.Content-Type:' + data.header['Content-Type']);
console.info('header.Status-Line:' + data.header['Status-Line']); console.info('header.Status-Line:' + data.header['Status-Line']);
} else { } else {
console.info('error:' + JSON.stringify(err)); console.info('error:' + JSON.stringify(err));
} }
}); });
``` ```
### request ### request
...@@ -233,8 +234,8 @@ request(url: string, options? : HttpRequestOptions): Promise\<HttpResponse\> ...@@ -233,8 +234,8 @@ request(url: string, options? : HttpRequestOptions): Promise\<HttpResponse\>
根据URL地址，发起HTTP网络请求，使用Promise方式作为异步方法。 根据URL地址，发起HTTP网络请求，使用Promise方式作为异步方法。
>**说明：** > **说明：**
>此接口仅支持数据大小为5M以内的数据传输。 > 此接口仅支持数据大小为5M以内的数据传输。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -289,30 +290,30 @@ request(url: string, options? : HttpRequestOptions): Promise\<HttpResponse\> ...@@ -289,30 +290,30 @@ request(url: string, options? : HttpRequestOptions): Promise\<HttpResponse\>
| 2300094 | An authentication function returned an error. | | 2300094 | An authentication function returned an error. |
| 2300999 | Unknown Other Error. | | 2300999 | Unknown Other Error. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。 > 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。
> HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html) > HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html)
**示例：** **示例：**
```js ```js
let promise = httpRequest.request("EXAMPLE_URL", { let promise = httpRequest.request("EXAMPLE_URL", {
method: http.RequestMethod.GET, method: http.RequestMethod.GET,
connectTimeout: 60000, connectTimeout: 60000,
readTimeout: 60000, readTimeout: 60000,
header: { header: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
} }
}); });
promise.then((data) => { promise.then((data) => {
console.info('Result:' + data.result); console.info('Result:' + data.result);
console.info('code:' + data.responseCode); console.info('code:' + data.responseCode);
console.info('header:' + JSON.stringify(data.header)); console.info('header:' + JSON.stringify(data.header));
console.info('cookies:' + data.cookies); // 8+ console.info('cookies:' + data.cookies); // 8+
console.info('header.Content-Type:' + data.header['Content-Type']); console.info('header.Content-Type:' + data.header['Content-Type']);
console.info('header.Status-Line:' + data.header['Status-Line']); console.info('header.Status-Line:' + data.header['Status-Line']);
}).catch((err) => { }).catch((err) => {
console.info('error:' + JSON.stringify(err)); console.info('error:' + JSON.stringify(err));
}); });
``` ```
...@@ -334,7 +335,7 @@ httpRequest.destroy(); ...@@ -334,7 +335,7 @@ httpRequest.destroy();
request2(url: string, callback: AsyncCallback\<number\>): void request2(url: string, callback: AsyncCallback\<number\>): void
根据URL地址和相关配置项，发起HTTP网络请求并返回流式响应，使用callback方式作为异步方法。 根据URL地址，发起HTTP网络请求并返回流式响应，使用callback方式作为异步方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -359,7 +360,7 @@ request2(url: string, callback: AsyncCallback\<number\>): void ...@@ -359,7 +360,7 @@ request2(url: string, callback: AsyncCallback\<number\>): void
| 2300052 | Server returned nothing (no headers, no data). | | 2300052 | Server returned nothing (no headers, no data). |
| 2300999 | Unknown Other Error. | | 2300999 | Unknown Other Error. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。 > 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。
> HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html) > HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html)
...@@ -367,11 +368,11 @@ request2(url: string, callback: AsyncCallback\<number\>): void ...@@ -367,11 +368,11 @@ request2(url: string, callback: AsyncCallback\<number\>): void
```js ```js
httpRequest.request2("EXAMPLE_URL", (err, data) => { httpRequest.request2("EXAMPLE_URL", (err, data) => {
if (!err) { if (!err) {
console.info("request2 OK! ResponseCode is " + JSON.stringify(data)); console.info("request2 OK! ResponseCode is " + JSON.stringify(data));
} else { } else {
console.info("request2 ERROR : err = " + JSON.stringify(err)); console.info("request2 ERROR : err = " + JSON.stringify(err));
} }
}) })
``` ```
...@@ -429,7 +430,7 @@ request2(url: string, options: HttpRequestOptions, callback: AsyncCallback\<numb ...@@ -429,7 +430,7 @@ request2(url: string, options: HttpRequestOptions, callback: AsyncCallback\<numb
| 2300094 | An authentication function returned an error. | | 2300094 | An authentication function returned an error. |
| 2300999 | Unknown Other Error. | | 2300999 | Unknown Other Error. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。 > 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。
> HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html) > HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：[curl错误码](https://curl.se/libcurl/c/libcurl-errors.html)
...@@ -437,21 +438,22 @@ request2(url: string, options: HttpRequestOptions, callback: AsyncCallback\<numb ...@@ -437,21 +438,22 @@ request2(url: string, options: HttpRequestOptions, callback: AsyncCallback\<numb
```js ```js
httpRequest.request2("EXAMPLE_URL", httpRequest.request2("EXAMPLE_URL",
{ {
method: http.RequestMethod.GET, method: http.RequestMethod.GET,
header: { header: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
readTimeout: 60000, readTimeout: 60000,
connectTimeout: 60000 connectTimeout: 60000
}, (err, data) => { }, (err, data) => {
if (!err) { if (!err) {
console.info("request2 OK! ResponseCode is " + JSON.stringify(data)); console.info("request2 OK! ResponseCode is " + JSON.stringify(data));
} else { } else {
console.info("request2 ERROR : err = " + JSON.stringify(err)); console.info("request2 ERROR : err = " + JSON.stringify(err));
} }
}) })
``` ```
### request2<sup>10+</sup> ### request2<sup>10+</sup>
request2(url: string, options? : HttpRequestOptions): Promise\<number\> request2(url: string, options? : HttpRequestOptions): Promise\<number\>
...@@ -511,25 +513,25 @@ request2(url: string, options? : HttpRequestOptions): Promise\<number\> ...@@ -511,25 +513,25 @@ request2(url: string, options? : HttpRequestOptions): Promise\<number\>
| 2300094 | An authentication function returned an error. | | 2300094 | An authentication function returned an error. |
| 2300999 | Unknown Other Error. | | 2300999 | Unknown Other Error. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。 > 以上错误码的详细介绍参见[HTTP错误码](../errorcodes/errorcode-net-http.md)。
> HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考： > HTTP 错误码映射关系：2300000 + curl错误码。更多常用错误码，可参考：
**示例：** **示例：**
```js ```js
let promise = httpRequest.request("EXAMPLE_URL", { let promise = httpRequest.request2("EXAMPLE_URL", {
method: http.RequestMethod.GET, method: http.RequestMethod.GET,
connectTimeout: 60000, connectTimeout: 60000,
readTimeout: 60000, readTimeout: 60000,
header: { header: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
} }
}); });
promise.then((data) => { promise.then((data) => {
console.info("request2 OK!" + JSON.stringify(data)); console.info("request2 OK!" + JSON.stringify(data));
}).catch((err) => { }).catch((err) => {
console.info("request2 ERROR : err = " + JSON.stringify(err)); console.info("request2 ERROR : err = " + JSON.stringify(err));
}); });
``` ```
...@@ -539,8 +541,8 @@ on(type: 'headerReceive', callback: AsyncCallback\<Object\>): void ...@@ -539,8 +541,8 @@ on(type: 'headerReceive', callback: AsyncCallback\<Object\>): void
订阅HTTP Response Header 事件。 订阅HTTP Response Header 事件。
>**说明：** > **说明：**
>此接口已废弃，建议使用[on('headersReceive')<sup>8+</sup>](#onheadersreceive8)替代。 > 此接口已废弃，建议使用[on('headersReceive')<sup>8+</sup>](#onheadersreceive8)替代。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -555,7 +557,7 @@ on(type: 'headerReceive', callback: AsyncCallback\<Object\>): void ...@@ -555,7 +557,7 @@ on(type: 'headerReceive', callback: AsyncCallback\<Object\>): void
```js ```js
httpRequest.on('headerReceive', (data) => { httpRequest.on('headerReceive', (data) => {
console.info('error:' + JSON.stringify(data)); console.info('error:' + JSON.stringify(data));
}); });
``` ```
...@@ -565,7 +567,7 @@ off(type: 'headerReceive', callback?: AsyncCallback\<Object\>): void ...@@ -565,7 +567,7 @@ off(type: 'headerReceive', callback?: AsyncCallback\<Object\>): void
取消订阅HTTP Response Header 事件。 取消订阅HTTP Response Header 事件。
>**说明：** > **说明：**
> >
>1. 此接口已废弃，建议使用[off('headersReceive')<sup>8+</sup>](#offheadersreceive8)替代。 >1. 此接口已废弃，建议使用[off('headersReceive')<sup>8+</sup>](#offheadersreceive8)替代。
> >
...@@ -605,7 +607,7 @@ on(type: 'headersReceive', callback: Callback\<Object\>): void ...@@ -605,7 +607,7 @@ on(type: 'headersReceive', callback: Callback\<Object\>): void
```js ```js
httpRequest.on('headersReceive', (header) => { httpRequest.on('headersReceive', (header) => {
console.info('header: ' + JSON.stringify(header)); console.info('header: ' + JSON.stringify(header));
}); });
``` ```
...@@ -615,8 +617,8 @@ off(type: 'headersReceive', callback?: Callback\<Object\>): void ...@@ -615,8 +617,8 @@ off(type: 'headersReceive', callback?: Callback\<Object\>): void
取消订阅HTTP Response Header 事件。 取消订阅HTTP Response Header 事件。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -652,9 +654,10 @@ once(type: 'headersReceive', callback: Callback\<Object\>): void ...@@ -652,9 +654,10 @@ once(type: 'headersReceive', callback: Callback\<Object\>): void
```js ```js
httpRequest.once('headersReceive', (header) => { httpRequest.once('headersReceive', (header) => {
console.info('header: ' + JSON.stringify(header)); console.info('header: ' + JSON.stringify(header));
}); });
``` ```
### on('dataReceive')<sup>10+</sup> ### on('dataReceive')<sup>10+</sup>
on(type: 'dataReceive', callback: Callback\<ArrayBuffer\>): void on(type: 'dataReceive', callback: Callback\<ArrayBuffer\>): void
...@@ -674,7 +677,7 @@ on(type: 'dataReceive', callback: Callback\<ArrayBuffer\>): void ...@@ -674,7 +677,7 @@ on(type: 'dataReceive', callback: Callback\<ArrayBuffer\>): void
```js ```js
httpRequest.on('dataReceive', (data) => { httpRequest.on('dataReceive', (data) => {
console.info('dataReceive length: ' + JSON.stringify(data.byteLength)); console.info('dataReceive length: ' + JSON.stringify(data.byteLength));
}); });
``` ```
...@@ -684,8 +687,8 @@ off(type: 'dataReceive', callback?: Callback\<ArrayBuffer\>): void ...@@ -684,8 +687,8 @@ off(type: 'dataReceive', callback?: Callback\<ArrayBuffer\>): void
取消订阅HTTP流式响应数据接收事件。 取消订阅HTTP流式响应数据接收事件。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -720,8 +723,8 @@ on(type: 'dataEnd', callback: Callback\<void\>): void ...@@ -720,8 +723,8 @@ on(type: 'dataEnd', callback: Callback\<void\>): void
**示例：** **示例：**
```js ```js
httpRequest.on('dataReceive', () => { httpRequest.on('dataEnd', () => {
console.info('Receive dataEnd！'); console.info('Receive dataEnd !');
}); });
``` ```
...@@ -731,8 +734,8 @@ off(type: 'dataEnd', callback?: Callback\<void\>): void ...@@ -731,8 +734,8 @@ off(type: 'dataEnd', callback?: Callback\<void\>): void
取消订阅HTTP流式响应数据接收完毕事件。 取消订阅HTTP流式响应数据接收完毕事件。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -751,7 +754,7 @@ httpRequest.off('dataEnd'); ...@@ -751,7 +754,7 @@ httpRequest.off('dataEnd');
### on('dataProgress')<sup>10+</sup> ### on('dataProgress')<sup>10+</sup>
on(type: 'dataProgress', callback: Callback\<{ receiveSize: number, totalSize: number }\>): void on(type: 'dataProgress', callback: AsyncCallback\<{ receiveSize: number, totalSize: number }\>): void
订阅HTTP流式响应数据接收进度事件。 订阅HTTP流式响应数据接收进度事件。
...@@ -768,7 +771,7 @@ httpRequest.off('dataEnd'); ...@@ -768,7 +771,7 @@ httpRequest.off('dataEnd');
```js ```js
httpRequest.on('dataProgress', (data) => { httpRequest.on('dataProgress', (data) => {
console.info('dataProgress:' + JSON.stringify(data)); console.info('dataProgress:' + JSON.stringify(data));
}); });
``` ```
...@@ -778,8 +781,8 @@ off(type: 'dataProgress', callback?: Callback\<{ receiveSize: number, totalSize: ...@@ -778,8 +781,8 @@ off(type: 'dataProgress', callback?: Callback\<{ receiveSize: number, totalSize:
取消订阅HTTP流式响应数据接收进度事件。 取消订阅HTTP流式响应数据接收进度事件。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -795,6 +798,7 @@ off(type: 'dataProgress', callback?: Callback\<{ receiveSize: number, totalSize: ...@@ -795,6 +798,7 @@ off(type: 'dataProgress', callback?: Callback\<{ receiveSize: number, totalSize:
```js ```js
httpRequest.off('dataProgress'); httpRequest.off('dataProgress');
``` ```
## HttpRequestOptions ## HttpRequestOptions
发起请求可选参数的类型和取值范围。 发起请求可选参数的类型和取值范围。
...@@ -803,11 +807,11 @@ httpRequest.off('dataProgress'); ...@@ -803,11 +807,11 @@ httpRequest.off('dataProgress');
| 名称 | 类型 | 必填 | 说明 | | 名称 | 类型 | 必填 | 说明 |
| -------------- | --------------------------------------------- | ---- | ------------------------------------------------------------ | | -------------- | --------------------------------------------- | ---- | ------------------------------------------------------------ |
| method | [RequestMethod](#requestmethod) | 否 | 请求方式。 | | method | [RequestMethod](#requestmethod) | 否 | 请求方式，默认为GET。 |
| extraData | string \| Object \| ArrayBuffer<sup>6+</sup> | 否 | 发送请求的额外数据。<br />- 当HTTP请求为POST、PUT等方法时，此字段为HTTP请求的content。<br />- 当HTTP请求为GET、OPTIONS、DELETE、TRACE、CONNECT等方法时，此字段为HTTP请求的参数补充，参数内容会拼接到URL中进行发送。<sup>6+</sup><br />- 开发者传入string对象，开发者需要自行编码，将编码后的string传入。<sup>6+</sup> | | extraData | string \| Object \| ArrayBuffer<sup>6+</sup> | 否 | 发送请求的额外数据，默认无此字段。<br />- 当HTTP请求为POST、PUT等方法时，此字段为HTTP请求的content，以UTF-8编码形式作为请求体。<sup>6+</sup><br />- 当HTTP请求为GET、OPTIONS、DELETE、TRACE、CONNECT等方法时，此字段为HTTP请求参数的补充。开发者需传入Encode编码后的string类型参数，Object类型的参数无需预编码，参数内容会拼接到URL中进行发送；ArrayBuffer类型的参数不会做拼接处理。<sup>6+</sup> |
| expectDataType<sup>9+</sup> | [HttpDataType](#httpdatatype9) | 否 | 指定返回数据的类型。如果设置了此参数，系统将优先返回指定的类型。 | | expectDataType<sup>9+</sup> | [HttpDataType](#httpdatatype9) | 否 | 指定返回数据的类型，默认无此字段。如果设置了此参数，系统将优先返回指定的类型。 |
| usingCache<sup>9+</sup> | boolean | 否 | 是否使用缓存，默认为true。 | | usingCache<sup>9+</sup> | boolean | 否 | 是否使用缓存，默认为true。 |
| priority<sup>9+</sup> | number | 否 | 优先级，范围\[1,1000]，默认是1。 | | priority<sup>9+</sup> | number | 否 | 优先级，范围\[0,1000]，默认是0。 |
| header | Object | 否 | HTTP请求头字段。默认{'Content-Type': 'application/json'}。 | | header | Object | 否 | HTTP请求头字段。默认{'Content-Type': 'application/json'}。 |
| readTimeout | number | 否 | 读取超时时间。单位为毫秒（ms），默认为60000ms。 | | readTimeout | number | 否 | 读取超时时间。单位为毫秒（ms），默认为60000ms。 |
| connectTimeout | number | 否 | 连接超时时间。单位为毫秒（ms），默认为60000ms。 | | connectTimeout | number | 否 | 连接超时时间。单位为毫秒（ms），默认为60000ms。 |
...@@ -886,7 +890,7 @@ request方法回调函数的返回值类型。 ...@@ -886,7 +890,7 @@ request方法回调函数的返回值类型。
| result | string \| Object \| ArrayBuffer<sup>6+</sup> | 是 | HTTP请求根据响应头中Content-type类型返回对应的响应格式内容：<br />- application/json：返回JSON格式的字符串，如需HTTP响应具体内容，需开发者自行解析<br />- application/octet-stream：ArrayBuffer<br />- 其他：string | | result | string \| Object \| ArrayBuffer<sup>6+</sup> | 是 | HTTP请求根据响应头中Content-type类型返回对应的响应格式内容：<br />- application/json：返回JSON格式的字符串，如需HTTP响应具体内容，需开发者自行解析<br />- application/octet-stream：ArrayBuffer<br />- 其他：string |
| resultType<sup>9+</sup> | [HttpDataType](#httpdatatype9) | 是 | 返回值类型。 | | resultType<sup>9+</sup> | [HttpDataType](#httpdatatype9) | 是 | 返回值类型。 |
| responseCode | [ResponseCode](#responsecode) \| number | 是 | 回调函数执行成功时，此字段为[ResponseCode](#responsecode)。若执行失败，错误码将会从AsyncCallback中的err字段返回。 | | responseCode | [ResponseCode](#responsecode) \| number | 是 | 回调函数执行成功时，此字段为[ResponseCode](#responsecode)。若执行失败，错误码将会从AsyncCallback中的err字段返回。 |
| header | Object | 是 | 发起HTTP请求返回来的响应头。当前返回的是JSON格式字符串，如需具体字段内容，需开发者自行解析。常见字段及解析方式如下：<br/>- Content-Type：header['Content-Type']；<br />- Status-Line：header['Status-Line']；<br />- Date：header.Date/header['Date']；<br />- Server：header.Server/header['Server']； | | header | Object | 是 | 发起HTTP请求返回来的响应头。当前返回的是JSON格式字符串，如需具体字段内容，需开发者自行解析。常见字段及解析方式如下：<br/>- content-type：header['content-type']；<br />- status-line：header['status-line']；<br />- date：header.date/header['date']；<br />- server：header.server/header['server']； |
| cookies<sup>8+</sup> | string | 是 | 服务器返回的 cookies。 | | cookies<sup>8+</sup> | string | 是 | 服务器返回的 cookies。 |
## http.createHttpResponseCache<sup>9+</sup> ## http.createHttpResponseCache<sup>9+</sup>
...@@ -913,6 +917,7 @@ createHttpResponseCache(cacheSize?: number): HttpResponseCache ...@@ -913,6 +917,7 @@ createHttpResponseCache(cacheSize?: number): HttpResponseCache
```js ```js
import http from '@ohos.net.http'; import http from '@ohos.net.http';
let httpResponseCache = http.createHttpResponseCache(); let httpResponseCache = http.createHttpResponseCache();
``` ```
...@@ -995,6 +1000,7 @@ httpResponseCache.delete(err => { ...@@ -995,6 +1000,7 @@ httpResponseCache.delete(err => {
console.info('delete success'); console.info('delete success');
}); });
``` ```
### delete<sup>9+</sup> ### delete<sup>9+</sup>
delete(): Promise\<void\> delete(): Promise\<void\>
......
zh-cn/application-dev/reference/apis/js-apis-net-connection.md
浏览文件 @ 75afe266
...@@ -10,6 +10,7 @@ ...@@ -10,6 +10,7 @@
```js ```js
import connection from '@ohos.net.connection' import connection from '@ohos.net.connection'
``` ```
## connection.createNetConnection ## connection.createNetConnection
createNetConnection(netSpecifier?: NetSpecifier, timeout?: number): NetConnection createNetConnection(netSpecifier?: NetSpecifier, timeout?: number): NetConnection
...@@ -34,14 +35,14 @@ createNetConnection(netSpecifier?: NetSpecifier, timeout?: number): NetConnectio ...@@ -34,14 +35,14 @@ createNetConnection(netSpecifier?: NetSpecifier, timeout?: number): NetConnectio
**示例：** **示例：**
```js ```js
// 关注默认网络 // 关注默认网络, 不需要传参
let netConnection = connection.createNetConnection() let netConnection = connection.createNetConnection()
// 关注蜂窝网络 // 关注蜂窝网络，需要传入相关网络特征，timeout参数未传入说明未使用超时时间，此时timeout为0
let netConnectionCellular = connection.createNetConnection({ let netConnectionCellular = connection.createNetConnection({
netCapabilities: { netCapabilities: {
bearerTypes: [connection.NetBearType.BEARER_CELLULAR] bearerTypes: [connection.NetBearType.BEARER_CELLULAR]
} }
}) })
``` ```
...@@ -73,8 +74,8 @@ getDefaultNet(callback: AsyncCallback\<NetHandle>): void ...@@ -73,8 +74,8 @@ getDefaultNet(callback: AsyncCallback\<NetHandle>): void
```js ```js
connection.getDefaultNet(function (error, data) { connection.getDefaultNet(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -106,7 +107,7 @@ getDefaultNet(): Promise\<NetHandle> ...@@ -106,7 +107,7 @@ getDefaultNet(): Promise\<NetHandle>
```js ```js
connection.getDefaultNet().then(function (data) { connection.getDefaultNet().then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -166,9 +167,9 @@ getGlobalHttpProxy(callback: AsyncCallback\<HttpProxy>): void ...@@ -166,9 +167,9 @@ getGlobalHttpProxy(callback: AsyncCallback\<HttpProxy>): void
**示例：** **示例：**
```js ```js
connection.getGlobalHttpProxy((error,data) => { connection.getGlobalHttpProxy((error, data) => {
console.info(JSON.stringify(error)); console.info(JSON.stringify(error));
console.info(JSON.stringify(data)); console.info(JSON.stringify(data));
}) })
``` ```
...@@ -199,9 +200,9 @@ getGlobalHttpProxy(): Promise\<HttpProxy>; ...@@ -199,9 +200,9 @@ getGlobalHttpProxy(): Promise\<HttpProxy>;
```js ```js
connection.getGlobalHttpProxy().then((data) => { connection.getGlobalHttpProxy().then((data) => {
console.info(JSON.stringify(data)); console.info(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.info(JSON.stringify(error)); console.info(JSON.stringify(error));
}) })
``` ```
...@@ -237,16 +238,15 @@ setGlobalHttpProxy(httpProxy: HttpProxy, callback: AsyncCallback\<void>): void ...@@ -237,16 +238,15 @@ setGlobalHttpProxy(httpProxy: HttpProxy, callback: AsyncCallback\<void>): void
**示例：** **示例：**
```js ```js
let exclusionStr="192.168,baidu.com" let exclusionStr = "192.168,baidu.com"
let exclusionArray = exclusionStr.split(','); let exclusionArray = exclusionStr.split(',');
let httpProxy = { let httpProxy = {
host: "192.168.xx.xxx", host: "192.168.xx.xxx",
port: 8080, port: 8080,
exclusionList: exclusionArray exclusionList: exclusionArray
} }
connection.setGlobalHttpProxy(httpProxy, (error, data) => { connection.setGlobalHttpProxy(httpProxy, (error) => {
console.info(JSON.stringify(error)); console.info(JSON.stringify(error));
console.info(JSON.stringify(data));
}); });
``` ```
...@@ -287,17 +287,17 @@ setGlobalHttpProxy(httpProxy: HttpProxy): Promise\<void>; ...@@ -287,17 +287,17 @@ setGlobalHttpProxy(httpProxy: HttpProxy): Promise\<void>;
**示例：** **示例：**
```js ```js
let exclusionStr="192.168,baidu.com" let exclusionStr = "192.168,baidu.com"
let exclusionArray = exclusionStr.split(','); let exclusionArray = exclusionStr.split(',');
let httpProxy = { let httpProxy = {
host: "192.168.xx.xxx", host: "192.168.xx.xxx",
port: 8080, port: 8080,
exclusionList: exclusionArray exclusionList: exclusionArray
} }
connection.setGlobalHttpProxy(httpProxy).then(() => { connection.setGlobalHttpProxy(httpProxy).then(() => {
console.info("success"); console.info("success");
}).catch(error=>{ }).catch(error => {
console.info(JSON.stringify(error)); console.info(JSON.stringify(error));
}) })
``` ```
...@@ -325,9 +325,9 @@ getAppNet(callback: AsyncCallback\<NetHandle>): void ...@@ -325,9 +325,9 @@ getAppNet(callback: AsyncCallback\<NetHandle>): void
**示例：** **示例：**
```js ```js
connection.getAppNet(function(error, data) { connection.getAppNet(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -356,9 +356,9 @@ getAppNet(): Promise\<NetHandle>; ...@@ -356,9 +356,9 @@ getAppNet(): Promise\<NetHandle>;
```js ```js
connection.getAppNet().then((data) => { connection.getAppNet().then((data) => {
console.info(JSON.stringify(data)); console.info(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.info(JSON.stringify(error)); console.info(JSON.stringify(error));
}) })
``` ```
...@@ -393,10 +393,10 @@ setAppNet(netHandle: NetHandle, callback: AsyncCallback\<void>): void ...@@ -393,10 +393,10 @@ setAppNet(netHandle: NetHandle, callback: AsyncCallback\<void>): void
```js ```js
connection.getDefaultNet(function (error, netHandle) { connection.getDefaultNet(function (error, netHandle) {
connection.setAppNet(netHandle, (error, data) => { connection.setAppNet(netHandle, (error, data) => {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
}) })
``` ```
...@@ -436,11 +436,11 @@ setAppNet(netHandle: NetHandle): Promise\<void>; ...@@ -436,11 +436,11 @@ setAppNet(netHandle: NetHandle): Promise\<void>;
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.setAppNet(netHandle).then(() => { connection.setAppNet(netHandle).then(() => {
console.log("success") console.log("success")
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
}) })
``` ```
...@@ -472,8 +472,8 @@ getAllNets(callback: AsyncCallback&lt;Array&lt;NetHandle&gt;&gt;): void ...@@ -472,8 +472,8 @@ getAllNets(callback: AsyncCallback&lt;Array&lt;NetHandle&gt;&gt;): void
```js ```js
connection.getAllNets(function (error, data) { connection.getAllNets(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -505,7 +505,7 @@ getAllNets(): Promise&lt;Array&lt;NetHandle&gt;&gt; ...@@ -505,7 +505,7 @@ getAllNets(): Promise&lt;Array&lt;NetHandle&gt;&gt;
```js ```js
connection.getAllNets().then(function (data) { connection.getAllNets().then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -540,10 +540,10 @@ getConnectionProperties(netHandle: NetHandle, callback: AsyncCallback\<Connectio ...@@ -540,10 +540,10 @@ getConnectionProperties(netHandle: NetHandle, callback: AsyncCallback\<Connectio
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.getConnectionProperties(netHandle, function (error, data) { connection.getConnectionProperties(netHandle, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -583,9 +583,9 @@ getConnectionProperties(netHandle: NetHandle): Promise\<ConnectionProperties> ...@@ -583,9 +583,9 @@ getConnectionProperties(netHandle: NetHandle): Promise\<ConnectionProperties>
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.getConnectionProperties(netHandle).then(function (data) { connection.getConnectionProperties(netHandle).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -620,10 +620,10 @@ getNetCapabilities(netHandle: NetHandle, callback: AsyncCallback\<NetCapabilitie ...@@ -620,10 +620,10 @@ getNetCapabilities(netHandle: NetHandle, callback: AsyncCallback\<NetCapabilitie
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.getNetCapabilities(netHandle, function (error, data) { connection.getNetCapabilities(netHandle, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -663,9 +663,9 @@ getNetCapabilities(netHandle: NetHandle): Promise\<NetCapabilities> ...@@ -663,9 +663,9 @@ getNetCapabilities(netHandle: NetHandle): Promise\<NetCapabilities>
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.getNetCapabilities(netHandle).then(function (data) { connection.getNetCapabilities(netHandle).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -697,8 +697,8 @@ isDefaultNetMetered(callback: AsyncCallback\<boolean>): void ...@@ -697,8 +697,8 @@ isDefaultNetMetered(callback: AsyncCallback\<boolean>): void
```js ```js
connection.isDefaultNetMetered(function (error, data) { connection.isDefaultNetMetered(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log('data: ' + data) console.log('data: ' + data)
}) })
``` ```
...@@ -730,7 +730,7 @@ isDefaultNetMetered(): Promise\<boolean> ...@@ -730,7 +730,7 @@ isDefaultNetMetered(): Promise\<boolean>
```js ```js
connection.isDefaultNetMetered().then(function (data) { connection.isDefaultNetMetered().then(function (data) {
console.log('data: ' + data) console.log('data: ' + data)
}) })
``` ```
...@@ -762,8 +762,8 @@ hasDefaultNet(callback: AsyncCallback\<boolean>): void ...@@ -762,8 +762,8 @@ hasDefaultNet(callback: AsyncCallback\<boolean>): void
```js ```js
connection.hasDefaultNet(function (error, data) { connection.hasDefaultNet(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log('data: ' + data) console.log('data: ' + data)
}) })
``` ```
...@@ -795,7 +795,7 @@ hasDefaultNet(): Promise\<boolean> ...@@ -795,7 +795,7 @@ hasDefaultNet(): Promise\<boolean>
```js ```js
connection.hasDefaultNet().then(function (data) { connection.hasDefaultNet().then(function (data) {
console.log('data: ' + data) console.log('data: ' + data)
}) })
``` ```
...@@ -828,7 +828,7 @@ enableAirplaneMode(callback: AsyncCallback\<void>): void ...@@ -828,7 +828,7 @@ enableAirplaneMode(callback: AsyncCallback\<void>): void
```js ```js
connection.enableAirplaneMode(function (error) { connection.enableAirplaneMode(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -861,7 +861,7 @@ enableAirplaneMode(): Promise\<void> ...@@ -861,7 +861,7 @@ enableAirplaneMode(): Promise\<void>
```js ```js
connection.enableAirplaneMode().then(function (error) { connection.enableAirplaneMode().then(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -894,7 +894,7 @@ disableAirplaneMode(callback: AsyncCallback\<void>): void ...@@ -894,7 +894,7 @@ disableAirplaneMode(callback: AsyncCallback\<void>): void
```js ```js
connection.disableAirplaneMode(function (error) { connection.disableAirplaneMode(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -927,7 +927,7 @@ disableAirplaneMode(): Promise\<void> ...@@ -927,7 +927,7 @@ disableAirplaneMode(): Promise\<void>
```js ```js
connection.disableAirplaneMode().then(function (error) { connection.disableAirplaneMode().then(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -935,8 +935,7 @@ connection.disableAirplaneMode().then(function (error) { ...@@ -935,8 +935,7 @@ connection.disableAirplaneMode().then(function (error) {
reportNetConnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): void reportNetConnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): void
向网络管理报告网络处于可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。 向网络管理报告网络处于可用状态，使用callback方式作为异步方法。
使用callback方式作为异步方法。
**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET **需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
...@@ -963,9 +962,9 @@ reportNetConnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): v ...@@ -963,9 +962,9 @@ reportNetConnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): v
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.reportNetConnected(netHandle, function (error) { connection.reportNetConnected(netHandle, function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}); });
}); });
``` ```
...@@ -973,8 +972,7 @@ connection.getDefaultNet().then(function (netHandle) { ...@@ -973,8 +972,7 @@ connection.getDefaultNet().then(function (netHandle) {
reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt; reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt;
向网络管理报告网络处于可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。 向网络管理报告网络处于可用状态，使用Promise方式作为异步方法。
使用Promise方式作为异步方法。
**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET **需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
...@@ -987,9 +985,7 @@ reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt; ...@@ -987,9 +985,7 @@ reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt;
| netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 | | netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 |
**返回值：** **返回值：**
| 类型 | 说明 | | 类型 | 说明 | | -------- | -------- | | Promise&lt;void&gt; | 无返回值的Promise对象。 |
| -------- | -------- |
| Promise&lt;void&gt; | 无返回值的Promise对象。 |
**错误码：** **错误码：**
...@@ -1005,9 +1001,9 @@ reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt; ...@@ -1005,9 +1001,9 @@ reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt;
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.reportNetConnected(netHandle).then(function () { connection.reportNetConnected(netHandle).then(function () {
console.log(`report success`) console.log(`report success`)
}); });
}); });
``` ```
...@@ -1015,8 +1011,7 @@ connection.getDefaultNet().then(function (netHandle) { ...@@ -1015,8 +1011,7 @@ connection.getDefaultNet().then(function (netHandle) {
reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): void reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): void
向网络管理报告网络处于不可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。 向网络管理报告网络处于不可用状态，使用callback方式作为异步方法。
使用callback方式作为异步方法。
**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET **需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
...@@ -1043,9 +1038,9 @@ reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;) ...@@ -1043,9 +1038,9 @@ reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;)
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.reportNetDisconnected(netHandle, function (error) { connection.reportNetDisconnected(netHandle, function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}); });
}); });
``` ```
...@@ -1053,8 +1048,7 @@ connection.getDefaultNet().then(function (netHandle) { ...@@ -1053,8 +1048,7 @@ connection.getDefaultNet().then(function (netHandle) {
reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt; reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt;
向网络管理报告网络处于不可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。 向网络管理报告网络处于不可用状态，使用Promise方式作为异步方法。
使用Promise方式作为异步方法。
**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET **需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
...@@ -1067,9 +1061,7 @@ reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt; ...@@ -1067,9 +1061,7 @@ reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt;
| netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 | | netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 |
**返回值：** **返回值：**
| 类型 | 说明 | | 类型 | 说明 | | -------- | -------- | | Promise&lt;void&gt; | 无返回值的Promise对象。 |
| -------- | -------- |
| Promise&lt;void&gt; | 无返回值的Promise对象。 |
**错误码：** **错误码：**
...@@ -1085,9 +1077,9 @@ reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt; ...@@ -1085,9 +1077,9 @@ reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt;
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
connection.reportNetDisconnected(netHandle).then(function () { connection.reportNetDisconnected(netHandle).then(function () {
console.log(`report success`) console.log(`report success`)
}); });
}); });
``` ```
...@@ -1123,8 +1115,8 @@ getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>): ...@@ -1123,8 +1115,8 @@ getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>):
```js ```js
let host = "xxxx"; let host = "xxxx";
connection.getAddressesByName(host, function (error, data) { connection.getAddressesByName(host, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1165,7 +1157,7 @@ getAddressesByName(host: string): Promise\<Array\<NetAddress>> ...@@ -1165,7 +1157,7 @@ getAddressesByName(host: string): Promise\<Array\<NetAddress>>
```js ```js
let host = "xxxx"; let host = "xxxx";
connection.getAddressesByName(host).then(function (data) { connection.getAddressesByName(host).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1199,12 +1191,11 @@ register(callback: AsyncCallback\<void>): void ...@@ -1199,12 +1191,11 @@ register(callback: AsyncCallback\<void>): void
| 2101008 | The callback is not exists. | | 2101008 | The callback is not exists. |
| 2101022 | The number of requests exceeded the maximum. | | 2101022 | The number of requests exceeded the maximum. |
**示例：** **示例：**
```js ```js
netConnection.register(function (error) { netConnection.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1234,7 +1225,7 @@ unregister(callback: AsyncCallback\<void>): void ...@@ -1234,7 +1225,7 @@ unregister(callback: AsyncCallback\<void>): void
```js ```js
netConnection.unregister(function (error) { netConnection.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1263,17 +1254,17 @@ let netCon = connection.createNetConnection() ...@@ -1263,17 +1254,17 @@ let netCon = connection.createNetConnection()
// 先使用register接口注册订阅事件 // 先使用register接口注册订阅事件
netCon.register(function (error) { netCon.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
// 订阅网络可用事件。调用register后，才能接收到此事件通知 // 订阅网络可用事件。调用register后，才能接收到此事件通知
netCon.on('netAvailable', function (data) { netCon.on('netAvailable', function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
// 使用unregister接口取消订阅 // 使用unregister接口取消订阅
netCon.unregister(function (error) { netCon.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1302,17 +1293,17 @@ let netCon = connection.createNetConnection() ...@@ -1302,17 +1293,17 @@ let netCon = connection.createNetConnection()
// 先使用register接口注册订阅事件 // 先使用register接口注册订阅事件
netCon.register(function (error) { netCon.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
// 订阅网络阻塞状态事件。调用register后，才能接收到此事件通知 // 订阅网络阻塞状态事件。调用register后，才能接收到此事件通知
netCon.on('netBlockStatusChange', function (data) { netCon.on('netBlockStatusChange', function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
// 使用unregister接口取消订阅 // 使用unregister接口取消订阅
netCon.unregister(function (error) { netCon.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1341,23 +1332,24 @@ let netCon = connection.createNetConnection() ...@@ -1341,23 +1332,24 @@ let netCon = connection.createNetConnection()
// 先使用register接口注册订阅事件 // 先使用register接口注册订阅事件
netCon.register(function (error) { netCon.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
// 订阅网络能力变化事件。调用register后，才能接收到此事件通知 // 订阅网络能力变化事件。调用register后，才能接收到此事件通知
netCon.on('netCapabilitiesChange', function (data) { netCon.on('netCapabilitiesChange', function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
// 使用unregister接口取消订阅 // 使用unregister接口取消订阅
netCon.unregister(function (error) { netCon.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
### on('netConnectionPropertiesChange') ### on('netConnectionPropertiesChange')
on(type: 'netConnectionPropertiesChange', callback: Callback<{ netHandle: NetHandle, connectionProperties: ConnectionProperties }>): void on(type: 'netConnectionPropertiesChange', callback: Callback<{ netHandle: NetHandle, connectionProperties:
ConnectionProperties }>): void
订阅网络连接信息变化事件。 订阅网络连接信息变化事件。
...@@ -1380,17 +1372,17 @@ let netCon = connection.createNetConnection() ...@@ -1380,17 +1372,17 @@ let netCon = connection.createNetConnection()
// 先使用register接口注册订阅事件 // 先使用register接口注册订阅事件
netCon.register(function (error) { netCon.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
// 订阅网络连接信息变化事件。调用register后，才能接收到此事件通知 // 订阅网络连接信息变化事件。调用register后，才能接收到此事件通知
netCon.on('netConnectionPropertiesChange', function (data) { netCon.on('netConnectionPropertiesChange', function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
// 使用unregister接口取消订阅 // 使用unregister接口取消订阅
netCon.unregister(function (error) { netCon.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1419,17 +1411,17 @@ let netCon = connection.createNetConnection() ...@@ -1419,17 +1411,17 @@ let netCon = connection.createNetConnection()
// 先使用register接口注册订阅事件 // 先使用register接口注册订阅事件
netCon.register(function (error) { netCon.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
// 订阅网络丢失事件。调用register后，才能接收到此事件通知 // 订阅网络丢失事件。调用register后，才能接收到此事件通知
netCon.on('netLost', function (data) { netCon.on('netLost', function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
// 使用unregister接口取消订阅 // 使用unregister接口取消订阅
netCon.unregister(function (error) { netCon.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1458,17 +1450,17 @@ let netCon = connection.createNetConnection() ...@@ -1458,17 +1450,17 @@ let netCon = connection.createNetConnection()
// 先使用register接口注册订阅事件 // 先使用register接口注册订阅事件
netCon.register(function (error) { netCon.register(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
// 订阅网络不可用事件。调用register后，才能接收到此事件通知 // 订阅网络不可用事件。调用register后，才能接收到此事件通知
netCon.on('netUnavailable', function (data) { netCon.on('netUnavailable', function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
// 使用unregister接口取消订阅 // 使用unregister接口取消订阅
netCon.unregister(function (error) { netCon.unregister(function (error) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
}) })
``` ```
...@@ -1514,48 +1506,51 @@ bindSocket(socketParam: TCPSocket \| UDPSocket, callback: AsyncCallback\<void>): ...@@ -1514,48 +1506,51 @@ bindSocket(socketParam: TCPSocket \| UDPSocket, callback: AsyncCallback\<void>):
```js ```js
import socket from "@ohos.net.socket"; import socket from "@ohos.net.socket";
connection.getDefaultNet().then((netHandle) => { connection.getDefaultNet().then((netHandle) => {
var tcp = socket.constructTCPSocketInstance(); var tcp = socket.constructTCPSocketInstance();
var udp = socket.constructUDPSocketInstance(); var udp = socket.constructUDPSocketInstance();
let socketType = "TCPSocket"; let socketType = "TCPSocket";
if (socketType == "TCPSocket") { if (socketType == "TCPSocket") {
tcp.bind({ tcp.bind({
address: '192.168.xx.xxx', port: 8080, family: 1 address: '192.168.xx.xxx', port: 8080, family: 1
}, error => { }, error => {
if (error) { if (error) {
console.log('bind fail'); console.log('bind fail');
} return;
netHandle.bindSocket(tcp, (error, data) => { }
if (error) { netHandle.bindSocket(tcp, (error, data) => {
console.log(JSON.stringify(error)); if (error) {
} else { console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); } else {
} console.log(JSON.stringify(data));
})
})
} else {
let callback = value => {
console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
} }
udp.on('message', callback); })
udp.bind({ })
address: '192.168.xx.xxx', port: 8080, family: 1 } else {
}, error => { let callback = value => {
if (error) { console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
console.log('bind fail');
}
udp.on('message', (data) => {
console.log(JSON.stringify(data))
});
netHandle.bindSocket(udp, (error, data) => {
if (error) {
console.log(JSON.stringify(error));
} else {
console.log(JSON.stringify(data));
}
})
})
} }
udp.on('message', callback);
udp.bind({
address: '192.168.xx.xxx', port: 8080, family: 1
}, error => {
if (error) {
console.log('bind fail');
return;
}
udp.on('message', (data) => {
console.log(JSON.stringify(data))
});
netHandle.bindSocket(udp, (error, data) => {
if (error) {
console.log(JSON.stringify(error));
} else {
console.log(JSON.stringify(data));
}
})
})
}
}) })
``` ```
...@@ -1592,44 +1587,47 @@ bindSocket(socketParam: TCPSocket \| UDPSocket): Promise\<void>; ...@@ -1592,44 +1587,47 @@ bindSocket(socketParam: TCPSocket \| UDPSocket): Promise\<void>;
```js ```js
import socket from "@ohos.net.socket"; import socket from "@ohos.net.socket";
connection.getDefaultNet().then((netHandle) => { connection.getDefaultNet().then((netHandle) => {
var tcp = socket.constructTCPSocketInstance(); var tcp = socket.constructTCPSocketInstance();
var udp = socket.constructUDPSocketInstance(); var udp = socket.constructUDPSocketInstance();
let socketType = "TCPSocket"; let socketType = "TCPSocket";
if (socketType == "TCPSocket") { if (socketType == "TCPSocket") {
tcp.bind({ tcp.bind({
address: '192.168.xx.xxx', port: 8080, family: 1 address: '192.168.xx.xxx', port: 8080, family: 1
}, error => { }, error => {
if (error) { if (error) {
console.log('bind fail'); console.log('bind fail');
} return;
netHandle.bindSocket(tcp).then((data) => { }
console.log(JSON.stringify(data)); netHandle.bindSocket(tcp).then((data) => {
}).catch(error => { console.log(JSON.stringify(data));
console.log(JSON.stringify(error)); }).catch(error => {
}) console.log(JSON.stringify(error));
}) })
} else { })
let callback = value => { } else {
console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo); let callback = value => {
} console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
udp.on('message', callback);
udp.bind({
address: '192.168.xx.xxx', port: 8080, family: 1
}, error => {
if (error) {
console.log('bind fail');
}
udp.on('message', (data) => {
console.log(JSON.stringify(data));
})
netHandle.bindSocket(udp).then((data) => {
console.log(JSON.stringify(data));
}).catch(error => {
console.log(JSON.stringify(error));
})
})
} }
udp.on('message', callback);
udp.bind({
address: '192.168.xx.xxx', port: 8080, family: 1
}, error => {
if (error) {
console.log('bind fail');
return;
}
udp.on('message', (data) => {
console.log(JSON.stringify(data));
})
netHandle.bindSocket(udp).then((data) => {
console.log(JSON.stringify(data));
}).catch(error => {
console.log(JSON.stringify(error));
})
})
}
}) })
``` ```
...@@ -1664,11 +1662,11 @@ getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>): ...@@ -1664,11 +1662,11 @@ getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>):
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
let host = "xxxx"; let host = "xxxx";
netHandle.getAddressesByName(host, function (error, data) { netHandle.getAddressesByName(host, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -1708,10 +1706,10 @@ getAddressesByName(host: string): Promise\<Array\<NetAddress>> ...@@ -1708,10 +1706,10 @@ getAddressesByName(host: string): Promise\<Array\<NetAddress>>
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
let host = "xxxx"; let host = "xxxx";
netHandle.getAddressesByName(host).then(function (data) { netHandle.getAddressesByName(host).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -1746,11 +1744,11 @@ getAddressByName(host: string, callback: AsyncCallback\<NetAddress>): void ...@@ -1746,11 +1744,11 @@ getAddressByName(host: string, callback: AsyncCallback\<NetAddress>): void
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
let host = "xxxx"; let host = "xxxx";
netHandle.getAddressByName(host, function (error, data) { netHandle.getAddressByName(host, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -1790,10 +1788,10 @@ getAddressByName(host: string): Promise\<NetAddress> ...@@ -1790,10 +1788,10 @@ getAddressByName(host: string): Promise\<NetAddress>
```js ```js
connection.getDefaultNet().then(function (netHandle) { connection.getDefaultNet().then(function (netHandle) {
let host = "xxxx"; let host = "xxxx";
netHandle.getAddressByName(host).then(function (data) { netHandle.getAddressByName(host).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
}) })
``` ```
...@@ -1905,8 +1903,5 @@ connection.getDefaultNet().then(function (netHandle) { ...@@ -1905,8 +1903,5 @@ connection.getDefaultNet().then(function (netHandle) {
**系统能力**：SystemCapability.Communication.NetManager.Core **系统能力**：SystemCapability.Communication.NetManager.Core
| 名称 | 类型 | 必填 | 说明 | | 名称 | 类型 | 必填 | 说明 | | ------- | ------ | -- |------------------------------ | | address | string | 是 |地址。 | | family |
| ------- | ------ | -- |------------------------------ | number | 否 |IPv4 = 1，IPv6 = 2，默认IPv4。 | | port | number | 否 |端口，取值范围\[0, 65535]。 |
| address | string | 是 |地址。 |
| family | number | 否 |IPv4 = 1，IPv6 = 2，默认IPv4。 |
| port | number | 否 |端口，取值范围\[0, 65535]。 |
zh-cn/application-dev/reference/apis/js-apis-net-ethernet.md
浏览文件 @ 75afe266
...@@ -48,19 +48,19 @@ setIfaceConfig(iface: string, ic: InterfaceConfiguration, callback: AsyncCallbac ...@@ -48,19 +48,19 @@ setIfaceConfig(iface: string, ic: InterfaceConfiguration, callback: AsyncCallbac
```js ```js
ethernet.setIfaceConfig("eth0", { ethernet.setIfaceConfig("eth0", {
mode: 0, mode: 0,
ipAddr: "192.168.xx.xxx", ipAddr: "192.168.xx.xxx",
route: "192.168.xx.xxx", route: "192.168.xx.xxx",
gateway: "192.168.xx.xxx", gateway: "192.168.xx.xxx",
netMask: "255.255.255.0", netMask: "255.255.255.0",
dnsServers: "1.1.1.1", dnsServers: "1.1.1.1",
domain: "2.2.2.2" domain: "2.2.2.2"
}, (error) => { }, (error) => {
if (error) { if (error) {
console.log("setIfaceConfig callback error = " + JSON.stringify(error)); console.log("setIfaceConfig callback error = " + JSON.stringify(error));
} else { } else {
console.log("setIfaceConfig callback ok "); console.log("setIfaceConfig callback ok ");
} }
}); });
``` ```
...@@ -106,17 +106,17 @@ setIfaceConfig(iface: string, ic: InterfaceConfiguration): Promise\<void> ...@@ -106,17 +106,17 @@ setIfaceConfig(iface: string, ic: InterfaceConfiguration): Promise\<void>
```js ```js
ethernet.setIfaceConfig("eth0", { ethernet.setIfaceConfig("eth0", {
mode: 0, mode: 0,
ipAddr: "192.168.xx.xxx", ipAddr: "192.168.xx.xxx",
route: "192.168.xx.xxx", route: "192.168.xx.xxx",
gateway: "192.168.xx.xxx", gateway: "192.168.xx.xxx",
netMask: "255.255.255.0", netMask: "255.255.255.0",
dnsServers: "1.1.1.1", dnsServers: "1.1.1.1",
domain: "2.2.2.2" domain: "2.2.2.2"
}).then(() => { }).then(() => {
console.log("setIfaceConfig promise ok "); console.log("setIfaceConfig promise ok ");
}).catch(error => { }).catch(error => {
console.log("setIfaceConfig promise error = " + JSON.stringify(error)); console.log("setIfaceConfig promise error = " + JSON.stringify(error));
}); });
``` ```
...@@ -154,17 +154,17 @@ getIfaceConfig(iface: string, callback: AsyncCallback\<InterfaceConfiguration>): ...@@ -154,17 +154,17 @@ getIfaceConfig(iface: string, callback: AsyncCallback\<InterfaceConfiguration>):
```js ```js
ethernet.getIfaceConfig("eth0", (error, value) => { ethernet.getIfaceConfig("eth0", (error, value) => {
if (error) { if (error) {
console.log("getIfaceConfig callback error = " + JSON.stringify(error)); console.log("getIfaceConfig callback error = " + JSON.stringify(error));
} else { } else {
console.log("getIfaceConfig callback mode = " + JSON.stringify(value.mode)); console.log("getIfaceConfig callback mode = " + JSON.stringify(value.mode));
console.log("getIfaceConfig callback ipAddr = " + JSON.stringify(value.ipAddr)); console.log("getIfaceConfig callback ipAddr = " + JSON.stringify(value.ipAddr));
console.log("getIfaceConfig callback route = " + JSON.stringify(value.route)); console.log("getIfaceConfig callback route = " + JSON.stringify(value.route));
console.log("getIfaceConfig callback gateway = " + JSON.stringify(value.gateway)); console.log("getIfaceConfig callback gateway = " + JSON.stringify(value.gateway));
console.log("getIfaceConfig callback netMask = " + JSON.stringify(value.netMask)); console.log("getIfaceConfig callback netMask = " + JSON.stringify(value.netMask));
console.log("getIfaceConfig callback dnsServers = " + JSON.stringify(value.dnsServers)); console.log("getIfaceConfig callback dnsServers = " + JSON.stringify(value.dnsServers));
console.log("getIfaceConfig callback domain = " + JSON.stringify(value.domain)); console.log("getIfaceConfig callback domain = " + JSON.stringify(value.domain));
} }
}); });
``` ```
...@@ -207,15 +207,15 @@ getIfaceConfig(iface: string): Promise\<InterfaceConfiguration> ...@@ -207,15 +207,15 @@ getIfaceConfig(iface: string): Promise\<InterfaceConfiguration>
```js ```js
ethernet.getIfaceConfig("eth0").then((data) => { ethernet.getIfaceConfig("eth0").then((data) => {
console.log("getIfaceConfig promise mode = " + JSON.stringify(data.mode)); console.log("getIfaceConfig promise mode = " + JSON.stringify(data.mode));
console.log("getIfaceConfig promise ipAddr = " + JSON.stringify(data.ipAddr)); console.log("getIfaceConfig promise ipAddr = " + JSON.stringify(data.ipAddr));
console.log("getIfaceConfig promise route = " + JSON.stringify(data.route)); console.log("getIfaceConfig promise route = " + JSON.stringify(data.route));
console.log("getIfaceConfig promise gateway = " + JSON.stringify(data.gateway)); console.log("getIfaceConfig promise gateway = " + JSON.stringify(data.gateway));
console.log("getIfaceConfig promise netMask = " + JSON.stringify(data.netMask)); console.log("getIfaceConfig promise netMask = " + JSON.stringify(data.netMask));
console.log("getIfaceConfig promise dnsServers = " + JSON.stringify(data.dnsServers)); console.log("getIfaceConfig promise dnsServers = " + JSON.stringify(data.dnsServers));
console.log("getIfaceConfig promise domain = " + JSON.stringify(data.domain)); console.log("getIfaceConfig promise domain = " + JSON.stringify(data.domain));
}).catch(error => { }).catch(error => {
console.log("getIfaceConfig promise error = " + JSON.stringify(error)); console.log("getIfaceConfig promise error = " + JSON.stringify(error));
}); });
``` ```
...@@ -253,11 +253,11 @@ isIfaceActive(iface: string, callback: AsyncCallback\<number>): void ...@@ -253,11 +253,11 @@ isIfaceActive(iface: string, callback: AsyncCallback\<number>): void
```js ```js
ethernet.isIfaceActive("eth0", (error, value) => { ethernet.isIfaceActive("eth0", (error, value) => {
if (error) { if (error) {
console.log("whether2Activate callback error = " + JSON.stringify(error)); console.log("whether2Activate callback error = " + JSON.stringify(error));
} else { } else {
console.log("whether2Activate callback = " + JSON.stringify(value)); console.log("whether2Activate callback = " + JSON.stringify(value));
} }
}); });
``` ```
...@@ -300,9 +300,9 @@ isIfaceActive(iface: string): Promise\<number> ...@@ -300,9 +300,9 @@ isIfaceActive(iface: string): Promise\<number>
```js ```js
ethernet.isIfaceActive("eth0").then((data) => { ethernet.isIfaceActive("eth0").then((data) => {
console.log("isIfaceActive promise = " + JSON.stringify(data)); console.log("isIfaceActive promise = " + JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log("isIfaceActive promise error = " + JSON.stringify(error)); console.log("isIfaceActive promise error = " + JSON.stringify(error));
}); });
``` ```
...@@ -336,14 +336,14 @@ getAllActiveIfaces(callback: AsyncCallback\<Array\<string>>): void ...@@ -336,14 +336,14 @@ getAllActiveIfaces(callback: AsyncCallback\<Array\<string>>): void
```js ```js
ethernet.getAllActiveIfaces((error, value) => { ethernet.getAllActiveIfaces((error, value) => {
if (error) { if (error) {
console.log("getAllActiveIfaces callback error = " + JSON.stringify(error)); console.log("getAllActiveIfaces callback error = " + JSON.stringify(error));
} else { } else {
console.log("getAllActiveIfaces callback value.length = " + JSON.stringify(value.length)); console.log("getAllActiveIfaces callback value.length = " + JSON.stringify(value.length));
for (let i = 0; i < value.length; i++) { for (let i = 0; i < value.length; i++) {
console.log("getAllActiveIfaces callback = " + JSON.stringify(value[i])); console.log("getAllActiveIfaces callback = " + JSON.stringify(value[i]));
}
} }
}
}); });
``` ```
...@@ -377,15 +377,83 @@ getAllActiveIfaces(): Promise\<Array\<string>> ...@@ -377,15 +377,83 @@ getAllActiveIfaces(): Promise\<Array\<string>>
```js ```js
ethernet.getAllActiveIfaces().then((data) => { ethernet.getAllActiveIfaces().then((data) => {
console.log("getAllActiveIfaces promise data.length = " + JSON.stringify(data.length)); console.log("getAllActiveIfaces promise data.length = " + JSON.stringify(data.length));
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
console.log("getAllActiveIfaces promise = " + JSON.stringify(data[i])); console.log("getAllActiveIfaces promise = " + JSON.stringify(data[i]));
} }
}).catch(error => { }).catch(error => {
console.log("getAllActiveIfaces promise error = " + JSON.stringify(error)); console.log("getAllActiveIfaces promise error = " + JSON.stringify(error));
}); });
``` ```
## ethernet.on('interfaceStateChange')<sup>10+</sup>
on(type: 'interfaceStateChange', callback: Callback\<{ iface: string, active: boolean }\>): void
注册网卡热插拔事件，使用callback方式作为异步方法。
**系统接口**：此接口为系统接口。
**需要权限**：ohos.permission.GET_NETWORK_INFO
**系统能力**：SystemCapability.Communication.NetManager.Ethernet
**参数：**
| 参数名 | 类型 | 必填 | 说明 |
| -------- | --------------------------------------- | ---- | ---------- |
| type | string | 是 | 订阅的事件类型，'interfaceStateChange'。 |
| callback | AsyncCallback\<{ iface: string, active: boolean }\> | 是 | 回调函数。<br>iface：网卡名称。<br>active：是否处于激活状态（true：激活；false：未激活） |
**错误码：**
| 错误码ID | 错误信息 |
| ------- | -------------------------------------------- |
| 201 | Permission denied. |
| 202 | Applicable only to system applications. |
| 401 | Parameter error. |
**示例：**
```js
ethernet.on('interfaceStateChange', (data) => {
console.log('on interfaceSharingStateChange：' + JSON.stringify(data));
});
```
## ethernet.off('interfaceStateChange')<sup>10+</sup>
off(type: 'interfaceStateChange', callback?: Callback\<{ iface: string, active: boolean }\>): void
注销网卡热插拔事件，使用callback方式作为异步方法。
**系统接口**：此接口为系统接口。
**需要权限**：ohos.permission.GET_NETWORK_INFO
**系统能力**：SystemCapability.Communication.NetManager.Ethernet
**参数：**
| 参数名 | 类型 | 必填 | 说明 |
| -------- | --------------------------------------- | ---- | ---------- |
| type | string | 是 | 订阅的事件类型，'interfaceStateChange'。 |
| callback | AsyncCallback\<{ iface: string, active: boolean }> | 否 | 回调函数。<br>iface：网卡名称。<br>active：是否处于激活状态（true：激活；false：未激活） |
**错误码：**
| 错误码ID | 错误信息 |
| ------- | -------------------------------------------- |
| 201 | Permission denied. |
| 202 | Applicable only to system applications. |
| 401 | Parameter error. |
**示例：**
```js
ethernet.off('interfaceStateChange');
```
## InterfaceConfiguration ## InterfaceConfiguration
以太网连接配置网络信息。 以太网连接配置网络信息。
......
zh-cn/application-dev/reference/apis/js-apis-net-mdns.md
浏览文件 @ 75afe266
...@@ -10,6 +10,7 @@ MDNS即多播DNS（Multicast DNS），提供局域网内的本地服务添加、 ...@@ -10,6 +10,7 @@ MDNS即多播DNS（Multicast DNS），提供局域网内的本地服务添加、
```js ```js
import mdns from '@ohos.net.mdns' import mdns from '@ohos.net.mdns'
``` ```
## mdns.addLocalService ## mdns.addLocalService
addLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: AsyncCallback\<LocalServiceInfo>): void addLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: AsyncCallback\<LocalServiceInfo>): void
...@@ -37,28 +38,28 @@ addLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: Async ...@@ -37,28 +38,28 @@ addLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: Async
| 2204008 | Service instance duplicated. | | 2204008 | Service instance duplicated. |
| 2204010 | Send packet failed. | | 2204010 | Send packet failed. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。 > 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。
**示例：** **示例：**
```js ```js
let localServiceInfo = { let localServiceInfo = {
serviceType: "_print._tcp", serviceType: "_print._tcp",
serviceName: "servicename", serviceName: "servicename",
port: 5555, port: 5555,
host: { host: {
address: "10.14.**.***", address: "10.14.**.***",
}, },
serviceAttribute: [{ serviceAttribute: [{
key: "111", key: "111",
value: [1] value: [1]
}] }]
} }
mdns.addLocalService(context, localServiceInfo, function (error, data) { mdns.addLocalService(context, localServiceInfo, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -94,27 +95,27 @@ addLocalService(context: Context, serviceInfo: LocalServiceInfo): Promise\<Local ...@@ -94,27 +95,27 @@ addLocalService(context: Context, serviceInfo: LocalServiceInfo): Promise\<Local
| 2204008 | Service instance duplicated. | | 2204008 | Service instance duplicated. |
| 2204010 | Send packet failed. | | 2204010 | Send packet failed. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。 > 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。
**示例：** **示例：**
```js ```js
let localServiceInfo = { let localServiceInfo = {
serviceType: "_print._tcp", serviceType: "_print._tcp",
serviceName: "servicename", serviceName: "servicename",
port: 5555, port: 5555,
host: { host: {
address: "10.14.**.***", address: "10.14.**.***",
}, },
serviceAttribute: [{ serviceAttribute: [{
key: "111", key: "111",
value: [1] value: [1]
}] }]
} }
mdns.addLocalService(context, localServiceInfo).then(function (data) { mdns.addLocalService(context, localServiceInfo).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -145,28 +146,28 @@ removeLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: As ...@@ -145,28 +146,28 @@ removeLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: As
| 2204008 | Service instance duplicated. | | 2204008 | Service instance duplicated. |
| 2204010 | Send packet failed. | | 2204010 | Send packet failed. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。 > 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。
**示例：** **示例：**
```js ```js
let localServiceInfo = { let localServiceInfo = {
serviceType: "_print._tcp", serviceType: "_print._tcp",
serviceName: "servicename", serviceName: "servicename",
port: 5555, port: 5555,
host: { host: {
address: "10.14.**.***", address: "10.14.**.***",
}, },
serviceAttribute: [{ serviceAttribute: [{
key: "111", key: "111",
value: [1] value: [1]
}] }]
} }
mdns.removeLocalService(context, localServiceInfo, function (error, data) { mdns.removeLocalService(context, localServiceInfo, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -202,27 +203,27 @@ removeLocalService(context: Context, serviceInfo: LocalServiceInfo): Promise\<Lo ...@@ -202,27 +203,27 @@ removeLocalService(context: Context, serviceInfo: LocalServiceInfo): Promise\<Lo
| 2204008 | Service instance duplicated. | | 2204008 | Service instance duplicated. |
| 2204010 | Send packet failed. | | 2204010 | Send packet failed. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。 > 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。
**示例：** **示例：**
```js ```js
let localServiceInfo = { let localServiceInfo = {
serviceType: "_print._tcp", serviceType: "_print._tcp",
serviceName: "servicename", serviceName: "servicename",
port: 5555, port: 5555,
host: { host: {
address: "10.14.**.***", address: "10.14.**.***",
}, },
serviceAttribute: [{ serviceAttribute: [{
key: "111", key: "111",
value: [1] value: [1]
}] }]
} }
mdns.removeLocalService(context, localServiceInfo).then(function (data) { mdns.removeLocalService(context, localServiceInfo).then(function (data) {
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -282,28 +283,28 @@ resolveLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: A ...@@ -282,28 +283,28 @@ resolveLocalService(context: Context, serviceInfo: LocalServiceInfo, callback: A
| 2204006 | Request timeout. | | 2204006 | Request timeout. |
| 2204010 | Send packet failed. | | 2204010 | Send packet failed. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。 > 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。
**示例：** **示例：**
```js ```js
let localServiceInfo = { let localServiceInfo = {
serviceType: "_print._tcp", serviceType: "_print._tcp",
serviceName: "servicename", serviceName: "servicename",
port: 5555, port: 5555,
host: { host: {
address: "10.14.**.***", address: "10.14.**.***",
}, },
serviceAttribute: [{ serviceAttribute: [{
key: "111", key: "111",
value: [1] value: [1]
}] }]
} }
mdns.resolveLocalService(context, localServiceInfo, function (error, data) { mdns.resolveLocalService(context, localServiceInfo, function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -339,27 +340,27 @@ resolveLocalService(context: Context, serviceInfo: LocalServiceInfo): Promise\<L ...@@ -339,27 +340,27 @@ resolveLocalService(context: Context, serviceInfo: LocalServiceInfo): Promise\<L
| 2204006 | Request timeout. | | 2204006 | Request timeout. |
| 2204010 | Send packet failed. | | 2204010 | Send packet failed. |
>**错误码说明：** > **错误码说明：**
> 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。 > 以上错误码的详细介绍参见[MDNS错误码](../errorcodes/errorcode-net-mdns.md)。
**示例：** **示例：**
```js ```js
let localServiceInfo = { let localServiceInfo = {
serviceType: "_print._tcp", serviceType: "_print._tcp",
serviceName: "servicename", serviceName: "servicename",
port: 5555, port: 5555,
host: { host: {
address: "10.14.**.***", address: "10.14.**.***",
}, },
serviceAttribute: [{ serviceAttribute: [{
key: "111", key: "111",
value: [1] value: [1]
}] }]
} }
mdns.resolveLocalService(context, localServiceInfo).then(function (data){ mdns.resolveLocalService(context, localServiceInfo).then(function (data) {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}) })
``` ```
...@@ -420,7 +421,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType); ...@@ -420,7 +421,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType);
discoveryService.startSearchingMDNS(); discoveryService.startSearchingMDNS();
discoveryService.on('discoveryStart', (data) => { discoveryService.on('discoveryStart', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
discoveryService.stopSearchingMDNS(); discoveryService.stopSearchingMDNS();
...@@ -449,7 +450,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType); ...@@ -449,7 +450,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType);
discoveryService.startSearchingMDNS(); discoveryService.startSearchingMDNS();
discoveryService.on('discoveryStop', (data) => { discoveryService.on('discoveryStop', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
discoveryService.stopSearchingMDNS(); discoveryService.stopSearchingMDNS();
...@@ -478,7 +479,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType); ...@@ -478,7 +479,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType);
discoveryService.startSearchingMDNS(); discoveryService.startSearchingMDNS();
discoveryService.on('serviceFound', (data) => { discoveryService.on('serviceFound', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
discoveryService.stopSearchingMDNS(); discoveryService.stopSearchingMDNS();
...@@ -507,7 +508,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType); ...@@ -507,7 +508,7 @@ let discoveryService = mdns.createDiscoveryService(context, serviceType);
discoveryService.startSearchingMDNS(); discoveryService.startSearchingMDNS();
discoveryService.on('serviceLost', (data) => { discoveryService.on('serviceLost', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
discoveryService.stopSearchingMDNS(); discoveryService.stopSearchingMDNS();
......
zh-cn/application-dev/reference/apis/js-apis-net-policy.md
浏览文件 @ 75afe266
...@@ -43,10 +43,12 @@ setBackgroundPolicy(isAllowed: boolean, callback: AsyncCallback\<void>): void ...@@ -43,10 +43,12 @@ setBackgroundPolicy(isAllowed: boolean, callback: AsyncCallback\<void>): void
```js ```js
policy.setBackgroundPolicy(Boolean(Number.parseInt(this.isBoolean))), (error, data) => { policy.setBackgroundPolicy(Boolean(Number.parseInt(this.isBoolean))), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); }
)
;
``` ```
## policy.setBackgroundPolicy ## policy.setBackgroundPolicy
...@@ -84,9 +86,9 @@ setBackgroundPolicy(isAllowed: boolean): Promise\<void> ...@@ -84,9 +86,9 @@ setBackgroundPolicy(isAllowed: boolean): Promise\<void>
**示例：** **示例：**
```js ```js
policy.setBackgroundPolicy(Boolean(Number.parseInt(this.isBoolean))).then(function(error, data) { policy.setBackgroundPolicy(Boolean(Number.parseInt(this.isBoolean))).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -118,9 +120,9 @@ isBackgroundAllowed(callback: AsyncCallback\<boolean>): void ...@@ -118,9 +120,9 @@ isBackgroundAllowed(callback: AsyncCallback\<boolean>): void
```js ```js
policy.isBackgroundAllowed((error, data) => { policy.isBackgroundAllowed((error, data) => {
this.callBack(error, data); this.callBack(error, data);
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}); });
``` ```
...@@ -151,9 +153,9 @@ isBackgroundAllowed(): Promise\<boolean>; ...@@ -151,9 +153,9 @@ isBackgroundAllowed(): Promise\<boolean>;
**示例：** **示例：**
```js ```js
policy.isBackgroundAllowed().then(function(error, data) { policy.isBackgroundAllowed().then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -190,10 +192,10 @@ setPolicyByUid(uid: number, policy: NetUidPolicy, callback: AsyncCallback\<void> ...@@ -190,10 +192,10 @@ setPolicyByUid(uid: number, policy: NetUidPolicy, callback: AsyncCallback\<void>
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), policy: Number.parseInt(this.currentNetUidPolicy) uid: Number.parseInt(this.firstParam), policy: Number.parseInt(this.currentNetUidPolicy)
} }
policy.setPolicyByUid(Number.parseInt(this.firstParam), Number.parseInt(this.currentNetUidPolicy), (error, data) => { policy.setPolicyByUid(Number.parseInt(this.firstParam), Number.parseInt(this.currentNetUidPolicy), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -234,11 +236,11 @@ setPolicyByUid(uid: number, policy: NetUidPolicy): Promise\<void>; ...@@ -234,11 +236,11 @@ setPolicyByUid(uid: number, policy: NetUidPolicy): Promise\<void>;
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), policy: Number.parseInt(this.currentNetUidPolicy) uid: Number.parseInt(this.firstParam), policy: Number.parseInt(this.currentNetUidPolicy)
} }
policy.setPolicyByUid(Number.parseInt(this.firstParam), Number.parseInt(this.currentNetUidPolicy)).then(function(error, data) { policy.setPolicyByUid(Number.parseInt(this.firstParam), Number.parseInt(this.currentNetUidPolicy)).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -274,7 +276,7 @@ getPolicyByUid(uid: number, callback: AsyncCallback\<NetUidPolicy>): void ...@@ -274,7 +276,7 @@ getPolicyByUid(uid: number, callback: AsyncCallback\<NetUidPolicy>): void
```js ```js
policy.getPolicyByUid(Number.parseInt(this.firstParam), (error, data) => { policy.getPolicyByUid(Number.parseInt(this.firstParam), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -313,9 +315,9 @@ getPolicyByUid(uid: number): Promise\<NetUidPolicy>; ...@@ -313,9 +315,9 @@ getPolicyByUid(uid: number): Promise\<NetUidPolicy>;
**示例：** **示例：**
```js ```js
policy.getPolicyByUid(Number.parseInt(this.firstParam)).then(function(error, data) { policy.getPolicyByUid(Number.parseInt(this.firstParam)).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -351,7 +353,7 @@ getUidsByPolicy(policy: NetUidPolicy, callback: AsyncCallback\<Array\<number>>): ...@@ -351,7 +353,7 @@ getUidsByPolicy(policy: NetUidPolicy, callback: AsyncCallback\<Array\<number>>):
```js ```js
policy.getUidsByPolicy(Number.parseInt(this.currentNetUidPolicy), (error, data) => { policy.getUidsByPolicy(Number.parseInt(this.currentNetUidPolicy), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -390,9 +392,9 @@ function getUidsByPolicy(policy: NetUidPolicy): Promise\<Array\<number>>; ...@@ -390,9 +392,9 @@ function getUidsByPolicy(policy: NetUidPolicy): Promise\<Array\<number>>;
**示例：** **示例：**
```js ```js
policy.getUidsByPolicy(Number.parseInt(this.firstParam)).then(function(error, data) { policy.getUidsByPolicy(Number.parseInt(this.firstParam)).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -425,7 +427,7 @@ getNetQuotaPolicies(callback: AsyncCallback\<Array\<NetQuotaPolicy>>): void ...@@ -425,7 +427,7 @@ getNetQuotaPolicies(callback: AsyncCallback\<Array\<NetQuotaPolicy>>): void
```js ```js
policy.getNetQuotaPolicies((error, data) => { policy.getNetQuotaPolicies((error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -456,9 +458,9 @@ getNetQuotaPolicies(): Promise\<Array\<NetQuotaPolicy>>; ...@@ -456,9 +458,9 @@ getNetQuotaPolicies(): Promise\<Array\<NetQuotaPolicy>>;
**示例：** **示例：**
```js ```js
policy.getNetQuotaPolicies().then(function(error, data) { policy.getNetQuotaPolicies().then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -493,12 +495,22 @@ setNetQuotaPolicies(quotaPolicies: Array\<NetQuotaPolicy>, callback: AsyncCallba ...@@ -493,12 +495,22 @@ setNetQuotaPolicies(quotaPolicies: Array\<NetQuotaPolicy>, callback: AsyncCallba
**示例：** **示例：**
```js ```js
let param = {netType:Number.parseInt(this.netType), iccid:this.iccid, ident:this.ident, periodDuration:this.periodDuration, warningBytes:Number.parseInt(this.warningBytes), let param = {
limitBytes:Number.parseInt(this.limitBytes), lastWarningRemind:this.lastWarningRemind, lastLimitRemind:this.lastLimitRemind, metered:Boolean(Number.parseInt(this.metered)), limitAction:this.limitAction}; netType: Number.parseInt(this.netType),
iccid: this.iccid,
ident: this.ident,
periodDuration: this.periodDuration,
warningBytes: Number.parseInt(this.warningBytes),
limitBytes: Number.parseInt(this.limitBytes),
lastWarningRemind: this.lastWarningRemind,
lastLimitRemind: this.lastLimitRemind,
metered: Boolean(Number.parseInt(this.metered)),
limitAction: this.limitAction
};
this.netQuotaPolicyList.push(param); this.netQuotaPolicyList.push(param);
policy.setNetQuotaPolicies(this.netQuotaPolicyList, (error, data) => { policy.setNetQuotaPolicies(this.netQuotaPolicyList, (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -537,13 +549,23 @@ setNetQuotaPolicies(quotaPolicies: Array\<NetQuotaPolicy>): Promise\<void>; ...@@ -537,13 +549,23 @@ setNetQuotaPolicies(quotaPolicies: Array\<NetQuotaPolicy>): Promise\<void>;
**示例：** **示例：**
```js ```js
let param = {netType:Number.parseInt(this.netType), iccid:this.iccid, ident:this.ident, periodDuration:this.periodDuration, warningBytes:Number.parseInt(this.warningBytes), let param = {
limitBytes:Number.parseInt(this.limitBytes), lastWarningRemind:this.lastWarningRemind, lastLimitRemind:this.lastLimitRemind, metered:Boolean(Number.parseInt(this.metered)), limitAction:this.limitAction}; netType: Number.parseInt(this.netType),
iccid: this.iccid,
ident: this.ident,
periodDuration: this.periodDuration,
warningBytes: Number.parseInt(this.warningBytes),
limitBytes: Number.parseInt(this.limitBytes),
lastWarningRemind: this.lastWarningRemind,
lastLimitRemind: this.lastLimitRemind,
metered: Boolean(Number.parseInt(this.metered)),
limitAction: this.limitAction
};
this.netQuotaPolicyList.push(param); this.netQuotaPolicyList.push(param);
policy.setNetQuotaPolicies(this.netQuotaPolicyList).then(function(error, data) { policy.setNetQuotaPolicies(this.netQuotaPolicyList).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -579,7 +601,7 @@ restoreAllPolicies(iccid: string, callback: AsyncCallback\<void>): void ...@@ -579,7 +601,7 @@ restoreAllPolicies(iccid: string, callback: AsyncCallback\<void>): void
```js ```js
this.firstParam = iccid; this.firstParam = iccid;
policy.restoreAllPolicies(this.firstParam, (error, data) => { policy.restoreAllPolicies(this.firstParam, (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -619,9 +641,9 @@ restoreAllPolicies(iccid: string): Promise\<void>; ...@@ -619,9 +641,9 @@ restoreAllPolicies(iccid: string): Promise\<void>;
```js ```js
this.firstParam = iccid; this.firstParam = iccid;
policy.restoreAllPolicies(this.firstParam).then(function(error, data){ policy.restoreAllPolicies(this.firstParam).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -659,10 +681,10 @@ isUidNetAllowed(uid: number, isMetered: boolean, callback: AsyncCallback\<boolea ...@@ -659,10 +681,10 @@ isUidNetAllowed(uid: number, isMetered: boolean, callback: AsyncCallback\<boolea
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), isMetered: Boolean(Number.parseInt(this.isBoolean)) uid: Number.parseInt(this.firstParam), isMetered: Boolean(Number.parseInt(this.isBoolean))
} }
policy.isUidNetAllowed(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean)), (error, data) => { policy.isUidNetAllowed(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean)), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -704,11 +726,11 @@ isUidNetAllowed(uid: number, isMetered: boolean): Promise\<boolean>; ...@@ -704,11 +726,11 @@ isUidNetAllowed(uid: number, isMetered: boolean): Promise\<boolean>;
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), isMetered: Boolean(Number.parseInt(this.isBoolean)) uid: Number.parseInt(this.firstParam), isMetered: Boolean(Number.parseInt(this.isBoolean))
} }
policy.isUidNetAllowed(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean))).then(function(error, data) { policy.isUidNetAllowed(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean))).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -746,10 +768,10 @@ isUidNetAllowed(uid: number, iface: string, callback: AsyncCallback\<boolean>): ...@@ -746,10 +768,10 @@ isUidNetAllowed(uid: number, iface: string, callback: AsyncCallback\<boolean>):
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), iface: this.secondParam uid: Number.parseInt(this.firstParam), iface: this.secondParam
} }
policy.isUidNetAllowed(Number.parseInt(this.firstParam), this.secondParam, (error, data) => { policy.isUidNetAllowed(Number.parseInt(this.firstParam), this.secondParam, (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -790,11 +812,11 @@ isUidNetAllowed(uid: number, iface: string): Promise\<boolean>; ...@@ -790,11 +812,11 @@ isUidNetAllowed(uid: number, iface: string): Promise\<boolean>;
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), iface: this.secondParam uid: Number.parseInt(this.firstParam), iface: this.secondParam
} }
policy.isUidNetAllowed(Number.parseInt(this.firstParam), this.secondParam).then(function(error, data) { policy.isUidNetAllowed(Number.parseInt(this.firstParam), this.secondParam).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -831,10 +853,10 @@ setDeviceIdleAllowList(uid: number, isAllowed: boolean, callback: AsyncCallback\ ...@@ -831,10 +853,10 @@ setDeviceIdleAllowList(uid: number, isAllowed: boolean, callback: AsyncCallback\
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean)) uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean))
} }
policy.setDeviceIdleAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean)), (error, data) => { policy.setDeviceIdleAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean)), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -875,11 +897,11 @@ setDeviceIdleAllowList(uid: number, isAllowed: boolean): Promise\<void>; ...@@ -875,11 +897,11 @@ setDeviceIdleAllowList(uid: number, isAllowed: boolean): Promise\<void>;
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean)) uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean))
} }
policy.setDeviceIdleAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean))).then(function(error, data) { policy.setDeviceIdleAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean))).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -912,7 +934,7 @@ getDeviceIdleAllowList(callback: AsyncCallback\<Array\<number>>): void ...@@ -912,7 +934,7 @@ getDeviceIdleAllowList(callback: AsyncCallback\<Array\<number>>): void
```js ```js
policy.getDeviceIdleAllowList((error, data) => { policy.getDeviceIdleAllowList((error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -943,9 +965,9 @@ getDeviceIdleAllowList(): Promise\<Array\<number>>; ...@@ -943,9 +965,9 @@ getDeviceIdleAllowList(): Promise\<Array\<number>>;
**示例：** **示例：**
```js ```js
policy.getDeviceIdleAllowList().then(function(error, data) { policy.getDeviceIdleAllowList().then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -981,7 +1003,7 @@ getBackgroundPolicyByUid(uid: number, callback: AsyncCallback\<NetBackgroundPoli ...@@ -981,7 +1003,7 @@ getBackgroundPolicyByUid(uid: number, callback: AsyncCallback\<NetBackgroundPoli
```js ```js
this.firstParam = uid this.firstParam = uid
policy.getBackgroundPolicyByUid(Number.parseInt(this.firstParam), (error, data) => { policy.getBackgroundPolicyByUid(Number.parseInt(this.firstParam), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -1021,9 +1043,9 @@ getBackgroundPolicyByUid(uid: number): Promise\<NetBackgroundPolicy>; ...@@ -1021,9 +1043,9 @@ getBackgroundPolicyByUid(uid: number): Promise\<NetBackgroundPolicy>;
```js ```js
this.firstParam = uid this.firstParam = uid
policy.getBackgroundPolicyByUid(Number.parseInt(this.firstParam)).then(function(error, data) { policy.getBackgroundPolicyByUid(Number.parseInt(this.firstParam)).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1059,7 +1081,7 @@ resetPolicies(iccid: string, callback: AsyncCallback\<void>): void ...@@ -1059,7 +1081,7 @@ resetPolicies(iccid: string, callback: AsyncCallback\<void>): void
```js ```js
this.firstParam = iccid this.firstParam = iccid
policy.resetPolicies(this.firstParam, (error, data) => { policy.resetPolicies(this.firstParam, (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -1098,13 +1120,13 @@ resetPolicies(iccid: string): Promise\<void>; ...@@ -1098,13 +1120,13 @@ resetPolicies(iccid: string): Promise\<void>;
**示例：** **示例：**
```js ```js
policy.getUidsByPolicy(Number.parseInt(this.firstParam)).then(function(error, data) { policy.getUidsByPolicy(Number.parseInt(this.firstParam)).then(function (error, data) {
}) })
this.firstParam = iccid this.firstParam = iccid
policy.resetPolicies(this.firstParam).then(function(error, data) { policy.resetPolicies(this.firstParam).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1142,10 +1164,10 @@ updateRemindPolicy(netType: NetBearType, iccid: string, remindType: RemindType, ...@@ -1142,10 +1164,10 @@ updateRemindPolicy(netType: NetBearType, iccid: string, remindType: RemindType,
```js ```js
let param = { let param = {
netType: Number.parseInt(this.netType), iccid: this.firstParam, remindType: this.currentRemindType netType: Number.parseInt(this.netType), iccid: this.firstParam, remindType: this.currentRemindType
} }
policy.updateRemindPolicy(Number.parseInt(this.netType), this.firstParam, Number.parseInt(this.currentRemindType), (error, data) => { policy.updateRemindPolicy(Number.parseInt(this.netType), this.firstParam, Number.parseInt(this.currentRemindType), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -1187,11 +1209,11 @@ updateRemindPolicy(netType: NetBearType, iccid: string, remindType: RemindType): ...@@ -1187,11 +1209,11 @@ updateRemindPolicy(netType: NetBearType, iccid: string, remindType: RemindType):
```js ```js
let param = { let param = {
netType: Number.parseInt(this.netType), iccid: this.firstParam, remindType: this.currentRemindType netType: Number.parseInt(this.netType), iccid: this.firstParam, remindType: this.currentRemindType
} }
policy.updateRemindPolicy(Number.parseInt(this.netType), this.firstParam, Number.parseInt(this.currentRemindType)).then(function(error, data) { policy.updateRemindPolicy(Number.parseInt(this.netType), this.firstParam, Number.parseInt(this.currentRemindType)).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1228,10 +1250,10 @@ setPowerSaveAllowList(uid: number, isAllowed: boolean, callback: AsyncCallback\< ...@@ -1228,10 +1250,10 @@ setPowerSaveAllowList(uid: number, isAllowed: boolean, callback: AsyncCallback\<
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean)) uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean))
} }
policy.setPowerSaveAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean)), (error, data) => { policy.setPowerSaveAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean)), (error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -1272,11 +1294,11 @@ setPowerSaveAllowList(uid: number, isAllowed: boolean): Promise\<void>; ...@@ -1272,11 +1294,11 @@ setPowerSaveAllowList(uid: number, isAllowed: boolean): Promise\<void>;
```js ```js
let param = { let param = {
uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean)) uid: Number.parseInt(this.firstParam), isAllowed: Boolean(Number.parseInt(this.isBoolean))
} }
policy.setPowerSaveAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean))).then(function(error, data) { policy.setPowerSaveAllowList(Number.parseInt(this.firstParam), Boolean(Number.parseInt(this.isBoolean))).then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1309,7 +1331,7 @@ getPowerSaveAllowList(callback: AsyncCallback\<Array\<number>>): void ...@@ -1309,7 +1331,7 @@ getPowerSaveAllowList(callback: AsyncCallback\<Array\<number>>): void
```js ```js
policy.getPowerSaveAllowList((error, data) => { policy.getPowerSaveAllowList((error, data) => {
this.callBack(error, data); this.callBack(error, data);
}); });
``` ```
...@@ -1340,9 +1362,9 @@ getPowerSaveAllowList(): Promise\<Array\<number>>; ...@@ -1340,9 +1362,9 @@ getPowerSaveAllowList(): Promise\<Array\<number>>;
**示例：** **示例：**
```js ```js
policy.getPowerSaveAllowList().then(function(error, data) { policy.getPowerSaveAllowList().then(function (error, data) {
console.log(JSON.stringify(error)) console.log(JSON.stringify(error))
console.log(JSON.stringify(data)) console.log(JSON.stringify(data))
}) })
``` ```
...@@ -1371,7 +1393,7 @@ on(type: "netUidPolicyChange", callback: Callback\<{ uid: number, policy: NetUid ...@@ -1371,7 +1393,7 @@ on(type: "netUidPolicyChange", callback: Callback\<{ uid: number, policy: NetUid
```js ```js
policy.on('netUidPolicyChange', (data) => { policy.on('netUidPolicyChange', (data) => {
this.log('on netUidPolicyChange：' + JSON.stringify(data)); this.log('on netUidPolicyChange：' + JSON.stringify(data));
}) })
``` ```
...@@ -1396,7 +1418,7 @@ on(type: "netUidRuleChange", callback: Callback\<{ uid: number, rule: NetUidRule ...@@ -1396,7 +1418,7 @@ on(type: "netUidRuleChange", callback: Callback\<{ uid: number, rule: NetUidRule
```js ```js
policy.on('netUidRuleChange', (data) => { policy.on('netUidRuleChange', (data) => {
this.log('on netUidRuleChange：' + JSON.stringify(data)); this.log('on netUidRuleChange：' + JSON.stringify(data));
}) })
``` ```
...@@ -1421,7 +1443,7 @@ on(type: "netMeteredIfacesChange", callback: Callback\<Array\<string>>): void ...@@ -1421,7 +1443,7 @@ on(type: "netMeteredIfacesChange", callback: Callback\<Array\<string>>): void
```js ```js
policy.on('netMeteredIfacesChange', (data) => { policy.on('netMeteredIfacesChange', (data) => {
this.log('on netMeteredIfacesChange：' + JSON.stringify(data)); this.log('on netMeteredIfacesChange：' + JSON.stringify(data));
}) })
``` ```
...@@ -1446,7 +1468,7 @@ on(type: "netQuotaPolicyChange", callback: Callback\<Array\<NetQuotaPolicy>>): v ...@@ -1446,7 +1468,7 @@ on(type: "netQuotaPolicyChange", callback: Callback\<Array\<NetQuotaPolicy>>): v
```js ```js
policy.on('netQuotaPolicyChange', (data) => { policy.on('netQuotaPolicyChange', (data) => {
this.log('on netQuotaPolicyChange：' + JSON.stringify(data)); this.log('on netQuotaPolicyChange：' + JSON.stringify(data));
}) })
``` ```
...@@ -1471,7 +1493,7 @@ on(type: "netBackgroundPolicyChange", callback: Callback\<boolean>): void ...@@ -1471,7 +1493,7 @@ on(type: "netBackgroundPolicyChange", callback: Callback\<boolean>): void
```js ```js
policy.on('netBackgroundPolicyChange', (data) => { policy.on('netBackgroundPolicyChange', (data) => {
this.log('on netBackgroundPolicyChange：' + JSON.stringify(data)); this.log('on netBackgroundPolicyChange：' + JSON.stringify(data));
}) })
``` ```
...@@ -1540,10 +1562,8 @@ policy.on('netBackgroundPolicyChange', (data) => { ...@@ -1540,10 +1562,8 @@ policy.on('netBackgroundPolicyChange', (data) => {
**系统能力**：SystemCapability.Communication.NetManager.Core **系统能力**：SystemCapability.Communication.NetManager.Core
| 参数名 | 值 | 说明 | | 参数名 | 值 | 说明 | | ---------------------- | - | ------- | | REMIND_TYPE_WARNING | 1 | 警告提醒 | | REMIND_TYPE_LIMIT | 2 |
| ---------------------- | - | ------- | 限制提醒 |
| REMIND_TYPE_WARNING | 1 | 警告提醒 |
| REMIND_TYPE_LIMIT | 2 | 限制提醒 |
## NetUidPolicy ## NetUidPolicy
......
zh-cn/application-dev/reference/apis/js-apis-net-sharing.md
浏览文件 @ 75afe266
...@@ -43,8 +43,8 @@ isSharingSupported(callback: AsyncCallback\<boolean>): void ...@@ -43,8 +43,8 @@ isSharingSupported(callback: AsyncCallback\<boolean>): void
```js ```js
sharing.isSharingSupported((error, data) => { sharing.isSharingSupported((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -79,9 +79,9 @@ isSharingSupported(): Promise\<boolean> ...@@ -79,9 +79,9 @@ isSharingSupported(): Promise\<boolean>
```js ```js
sharing.isSharingSupported().then(data => { sharing.isSharingSupported().then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -115,8 +115,8 @@ isSharing(callback: AsyncCallback\<boolean>): void ...@@ -115,8 +115,8 @@ isSharing(callback: AsyncCallback\<boolean>): void
```js ```js
sharing.isSharing((error, data) => { sharing.isSharing((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -150,9 +150,9 @@ isSharing(): Promise\<boolean> ...@@ -150,9 +150,9 @@ isSharing(): Promise\<boolean>
```js ```js
sharing.isSharing().then(data => { sharing.isSharing().then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -194,9 +194,10 @@ startSharing(type: SharingIfaceType, callback: AsyncCallback\<void>): void ...@@ -194,9 +194,10 @@ startSharing(type: SharingIfaceType, callback: AsyncCallback\<void>): void
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.startSharing(SHARING_WIFI, (error) => { sharing.startSharing(SHARING_WIFI, (error) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -243,11 +244,12 @@ startSharing(type: SharingIfaceType): Promise\<void> ...@@ -243,11 +244,12 @@ startSharing(type: SharingIfaceType): Promise\<void>
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.startSharing(SHARING_WIFI).then(() => { sharing.startSharing(SHARING_WIFI).then(() => {
console.log("start wifi sharing successful"); console.log("start wifi sharing successful");
}).catch(error => { }).catch(error => {
console.log("start wifi sharing failed"); console.log("start wifi sharing failed");
}); });
``` ```
...@@ -287,9 +289,10 @@ stopSharing(type: SharingIfaceType, callback: AsyncCallback\<void>): void ...@@ -287,9 +289,10 @@ stopSharing(type: SharingIfaceType, callback: AsyncCallback\<void>): void
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.stopSharing(SHARING_WIFI, (error) => { sharing.stopSharing(SHARING_WIFI, (error) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -334,11 +337,12 @@ stopSharing(type: SharingIfaceType): Promise\<void> ...@@ -334,11 +337,12 @@ stopSharing(type: SharingIfaceType): Promise\<void>
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.stopSharing(SHARING_WIFI).then(() => { sharing.stopSharing(SHARING_WIFI).then(() => {
console.log("stop wifi sharing successful"); console.log("stop wifi sharing successful");
}).catch(error => { }).catch(error => {
console.log("stop wifi sharing failed"); console.log("stop wifi sharing failed");
}); });
``` ```
...@@ -372,8 +376,8 @@ getStatsRxBytes(callback: AsyncCallback\<number>): void ...@@ -372,8 +376,8 @@ getStatsRxBytes(callback: AsyncCallback\<number>): void
```js ```js
sharing.getStatsRxBytes((error, data) => { sharing.getStatsRxBytes((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -407,9 +411,9 @@ getStatsRxBytes(): Promise\<number> ...@@ -407,9 +411,9 @@ getStatsRxBytes(): Promise\<number>
```js ```js
sharing.getStatsRxBytes().then(data => { sharing.getStatsRxBytes().then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -443,8 +447,8 @@ getStatsTxBytes(callback: AsyncCallback\<number>): void ...@@ -443,8 +447,8 @@ getStatsTxBytes(callback: AsyncCallback\<number>): void
```js ```js
sharing.getStatsTxBytes((error, data) => { sharing.getStatsTxBytes((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -478,9 +482,9 @@ getStatsTxBytes(): Promise\<number> ...@@ -478,9 +482,9 @@ getStatsTxBytes(): Promise\<number>
```js ```js
sharing.getStatsTxBytes().then(data => { sharing.getStatsTxBytes().then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -514,8 +518,8 @@ getStatsTotalBytes(callback: AsyncCallback\<number>): void ...@@ -514,8 +518,8 @@ getStatsTotalBytes(callback: AsyncCallback\<number>): void
```js ```js
sharing.getStatsTotalBytes((error, data) => { sharing.getStatsTotalBytes((error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -549,9 +553,9 @@ getStatsTotalBytes(): Promise\<number> ...@@ -549,9 +553,9 @@ getStatsTotalBytes(): Promise\<number>
```js ```js
sharing.getStatsTotalBytes().then(data => { sharing.getStatsTotalBytes().then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -588,10 +592,11 @@ getSharingIfaces(state: SharingIfaceState, callback: AsyncCallback\<Array\<strin ...@@ -588,10 +592,11 @@ getSharingIfaces(state: SharingIfaceState, callback: AsyncCallback\<Array\<strin
```js ```js
import SharingIfaceState from '@ohos.net.sharing' import SharingIfaceState from '@ohos.net.sharing'
let SHARING_BLUETOOTH=2;
let SHARING_BLUETOOTH = 2;
sharing.getSharingIfaces(SHARING_BLUETOOTH, (error, data) => { sharing.getSharingIfaces(SHARING_BLUETOOTH, (error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -633,11 +638,12 @@ getSharingIfaces(state: SharingIfaceState): Promise\<Array\<string>> ...@@ -633,11 +638,12 @@ getSharingIfaces(state: SharingIfaceState): Promise\<Array\<string>>
```js ```js
import SharingIfaceState from '@ohos.net.sharing' import SharingIfaceState from '@ohos.net.sharing'
let SHARING_BLUETOOTH=2;
let SHARING_BLUETOOTH = 2;
sharing.getSharingIfaces(SHARING_BLUETOOTH).then(data => { sharing.getSharingIfaces(SHARING_BLUETOOTH).then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -674,10 +680,11 @@ getSharingState(type: SharingIfaceType, callback: AsyncCallback\<SharingIfaceSta ...@@ -674,10 +680,11 @@ getSharingState(type: SharingIfaceType, callback: AsyncCallback\<SharingIfaceSta
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.getSharingState(SHARING_WIFI, (error, data) => { sharing.getSharingState(SHARING_WIFI, (error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -719,11 +726,12 @@ getSharingState(type: SharingIfaceType): Promise\<SharingIfaceState> ...@@ -719,11 +726,12 @@ getSharingState(type: SharingIfaceType): Promise\<SharingIfaceState>
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.getSharingState(SHARING_WIFI).then(data => { sharing.getSharingState(SHARING_WIFI).then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -760,10 +768,11 @@ getSharableRegexes(type: SharingIfaceType, callback: AsyncCallback\<Array\<strin ...@@ -760,10 +768,11 @@ getSharableRegexes(type: SharingIfaceType, callback: AsyncCallback\<Array\<strin
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.getSharableRegexes(SHARING_WIFI, (error, data) => { sharing.getSharableRegexes(SHARING_WIFI, (error, data) => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -805,11 +814,12 @@ getSharableRegexes(type: SharingIfaceType): Promise\<Array\<string>> ...@@ -805,11 +814,12 @@ getSharableRegexes(type: SharingIfaceType): Promise\<Array\<string>>
```js ```js
import SharingIfaceType from '@ohos.net.sharing' import SharingIfaceType from '@ohos.net.sharing'
let SHARING_WIFI=0;
let SHARING_WIFI = 0;
sharing.getSharableRegexes(SHARING_WIFI).then(data => { sharing.getSharableRegexes(SHARING_WIFI).then(data => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}).catch(error => { }).catch(error => {
console.log(JSON.stringify(error)); console.log(JSON.stringify(error));
}); });
``` ```
...@@ -842,8 +852,8 @@ on(type: 'sharingStateChange', callback: Callback\<boolean>): void ...@@ -842,8 +852,8 @@ on(type: 'sharingStateChange', callback: Callback\<boolean>): void
**示例：** **示例：**
```js ```js
sharing.on('sharingStateChange', (data) => { sharing.on('sharingStateChange', (data) => {
console.log('on sharingStateChange：' + JSON.stringify(data)); console.log('on sharingStateChange: ' + JSON.stringify(data));
}); });
``` ```
...@@ -877,13 +887,14 @@ off(type: 'sharingStateChange', callback?: Callback\<boolean>): void ...@@ -877,13 +887,14 @@ off(type: 'sharingStateChange', callback?: Callback\<boolean>): void
```js ```js
sharing.off('sharingStateChange', (data) => { sharing.off('sharingStateChange', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
## sharing.on('interfaceSharingStateChange') ## sharing.on('interfaceSharingStateChange')
on(type: 'interfaceSharingStateChange', callback: Callback\<{ type: SharingIfaceType, iface: string, state: SharingIfaceState }>): void on(type: 'interfaceSharingStateChange', callback: Callback\<{ type: SharingIfaceType, iface: string, state:
SharingIfaceState }>): void
注册网卡网络共享状态变化事件，使用callback方式作为异步方法。 注册网卡网络共享状态变化事件，使用callback方式作为异步方法。
...@@ -910,14 +921,15 @@ on(type: 'interfaceSharingStateChange', callback: Callback\<{ type: SharingIface ...@@ -910,14 +921,15 @@ on(type: 'interfaceSharingStateChange', callback: Callback\<{ type: SharingIface
**示例：** **示例：**
```js ```js
sharing.on('interfaceSharingStateChange', (data) => { sharing.on('interfaceSharingStateChange', (data) => {
console.log('on interfaceSharingStateChange：' + JSON.stringify(data)); console.log('on interfaceSharingStateChange:' + JSON.stringify(data));
}); });
``` ```
## sharing.off('interfaceSharingStateChange') ## sharing.off('interfaceSharingStateChange')
off(type: 'interfaceSharingStateChange', callback?: Callback\<{ type: SharingIfaceType, iface: string, state: SharingIfaceState }>): void off(type: 'interfaceSharingStateChange', callback?: Callback\<{ type: SharingIfaceType, iface: string, state:
SharingIfaceState }>): void
注销网卡网络共享状态变化事件，使用callback方式作为异步方法。 注销网卡网络共享状态变化事件，使用callback方式作为异步方法。
...@@ -945,7 +957,7 @@ off(type: 'interfaceSharingStateChange', callback?: Callback\<{ type: SharingIfa ...@@ -945,7 +957,7 @@ off(type: 'interfaceSharingStateChange', callback?: Callback\<{ type: SharingIfa
```js ```js
sharing.off('interfaceSharingStateChange', (data) => { sharing.off('interfaceSharingStateChange', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -978,8 +990,8 @@ on(type: 'sharingUpstreamChange', callback: Callback\<NetHandle>): void ...@@ -978,8 +990,8 @@ on(type: 'sharingUpstreamChange', callback: Callback\<NetHandle>): void
**示例：** **示例：**
```js ```js
sharing.on('sharingUpstreamChange', (data) => { sharing.on('sharingUpstreamChange', (data) => {
console.log('on sharingUpstreamChange：' + JSON.stringify(data)); console.log('on sharingUpstreamChange:' + JSON.stringify(data));
}); });
``` ```
...@@ -1013,7 +1025,7 @@ off(type: 'sharingUpstreamChange', callback?: Callback\<NetHandle>): void ...@@ -1013,7 +1025,7 @@ off(type: 'sharingUpstreamChange', callback?: Callback\<NetHandle>): void
```js ```js
sharing.off('sharingUpstreamChange', (data) => { sharing.off('sharingUpstreamChange', (data) => {
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
......
zh-cn/application-dev/reference/apis/js-apis-socket.md
浏览文件 @ 75afe266
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
本模块提供利用Socket进行数据传输的能力，支持TCPSocket、UDPSocket、WebSocket和TLSSocket。 本模块提供利用Socket进行数据传输的能力，支持TCPSocket、UDPSocket、WebSocket和TLSSocket。
> **说明：** > **说明：**
> >
> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 > 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
...@@ -26,14 +26,12 @@ constructUDPSocketInstance(): UDPSocket ...@@ -26,14 +26,12 @@ constructUDPSocketInstance(): UDPSocket
| :--------------------------------- | :---------------------- | | :--------------------------------- | :---------------------- |
| [UDPSocket](#udpsocket) | 返回一个UDPSocket对象。 | | [UDPSocket](#udpsocket) | 返回一个UDPSocket对象。 |
**示例：** **示例：**
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
``` ```
## UDPSocket ## UDPSocket
UDPSocket连接。在调用UDPSocket的方法前，需要先通过[socket.constructUDPSocketInstance](#socketconstructudpsocketinstance)创建UDPSocket对象。 UDPSocket连接。在调用UDPSocket的方法前，需要先通过[socket.constructUDPSocketInstance](#socketconstructudpsocketinstance)创建UDPSocket对象。
...@@ -68,14 +66,13 @@ bind(address: NetAddress, callback: AsyncCallback\<void\>): void ...@@ -68,14 +66,13 @@ bind(address: NetAddress, callback: AsyncCallback\<void\>): void
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => { udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
}) })
``` ```
### bind ### bind
bind(address: NetAddress): Promise\<void\> bind(address: NetAddress): Promise\<void\>
...@@ -110,14 +107,13 @@ bind(address: NetAddress): Promise\<void\> ...@@ -110,14 +107,13 @@ bind(address: NetAddress): Promise\<void\>
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
let promise = udp.bind({address: '192.168.xx.xxx', port: 8080, family: 1}); let promise = udp.bind({address: '192.168.xx.xxx', port: 8080, family: 1});
promise .then(() => { promise.then(() => {
console.log('bind success'); console.log('bind success');
}).catch(err => { }).catch(err => {
console.log('bind fail'); console.log('bind fail');
}); });
``` ```
### send ### send
send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void
...@@ -149,22 +145,21 @@ send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void ...@@ -149,22 +145,21 @@ send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.send({ udp.send({
data:'Hello, server!', data: 'Hello, server!',
address: { address: {
address:'192.168.xx.xxx', address: '192.168.xx.xxx',
port:xxxx, port: xxxx,
family:1 family: 1
} }
}, err=> { }, err => {
if (err) { if (err) {
console.log('send fail'); console.log('send fail');
return; return;
} }
console.log('send success'); console.log('send success');
}) })
``` ```
### send ### send
send(options: UDPSendOptions): Promise\<void\> send(options: UDPSendOptions): Promise\<void\>
...@@ -201,11 +196,11 @@ send(options: UDPSendOptions): Promise\<void\> ...@@ -201,11 +196,11 @@ send(options: UDPSendOptions): Promise\<void\>
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
let promise = udp.send({ let promise = udp.send({
data:'Hello, server!', data: 'Hello, server!',
address: { address: {
address:'192.168.xx.xxx', address: '192.168.xx.xxx',
port:xxxx, port: xxxx,
family:1 family: 1
} }
}); });
promise.then(() => { promise.then(() => {
...@@ -215,7 +210,6 @@ promise.then(() => { ...@@ -215,7 +210,6 @@ promise.then(() => {
}); });
``` ```
### close ### close
close(callback: AsyncCallback\<void\>): void close(callback: AsyncCallback\<void\>): void
...@@ -238,14 +232,13 @@ close(callback: AsyncCallback\<void\>): void ...@@ -238,14 +232,13 @@ close(callback: AsyncCallback\<void\>): void
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.close(err => { udp.close(err => {
if (err) { if (err) {
console.log('close fail'); console.log('close fail');
return; return;
} }
console.log('close success'); console.log('close success');
}) })
``` ```
### close ### close
close(): Promise\<void\> close(): Promise\<void\>
...@@ -274,15 +267,14 @@ promise.then(() => { ...@@ -274,15 +267,14 @@ promise.then(() => {
}); });
``` ```
### getState ### getState
getState(callback: AsyncCallback\<SocketStateBase\>): void getState(callback: AsyncCallback\<SocketStateBase\>): void
获取UDPSocket状态。使用callback方式作为异步方法。 获取UDPSocket状态。使用callback方式作为异步方法。
>**说明：** > **说明：**
>bind方法调用成功后，才可调用此方法。 > bind方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -306,29 +298,28 @@ getState(callback: AsyncCallback\<SocketStateBase\>): void ...@@ -306,29 +298,28 @@ getState(callback: AsyncCallback\<SocketStateBase\>): void
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => { udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
udp.getState((err, data) => { udp.getState((err, data) => {
if (err) { if (err) {
console.log('getState fail'); console.log('getState fail');
return; return;
} }
console.log('getState success:' + JSON.stringify(data)); console.log('getState success:' + JSON.stringify(data));
}) })
}) })
``` ```
### getState ### getState
getState(): Promise\<SocketStateBase\> getState(): Promise\<SocketStateBase\>
获取UDPSocket状态。使用Promise方式作为异步方法。 获取UDPSocket状态。使用Promise方式作为异步方法。
>**说明：** > **说明：**
>bind方法调用成功后，才可调用此方法。 > bind方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -344,30 +335,30 @@ getState(): Promise\<SocketStateBase\> ...@@ -344,30 +335,30 @@ getState(): Promise\<SocketStateBase\>
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => { let promise = udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1});
promise.then(err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
let promise = udp.getState(); let promise = udp.getState();
promise.then(data => { promise.then(data => {
console.log('getState success:' + JSON.stringify(data)); console.log('getState success:' + JSON.stringify(data));
}).catch(err => { }).catch(err => {
console.log('getState fail'); console.log('getState fail');
}); });
}) });
``` ```
### setExtraOptions ### setExtraOptions
setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback\<void\>): void setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback\<void\>): void
设置UDPSocket连接的其他属性。使用callback方式作为异步方法。 设置UDPSocket连接的其他属性。使用callback方式作为异步方法。
>**说明：** > **说明：**
>bind方法调用成功后，才可调用此方法。 > bind方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -391,37 +382,36 @@ setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback\<void\>): void ...@@ -391,37 +382,36 @@ setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback\<void\>): void
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.bind({address:'192.168.xx.xxx', port:xxxx, family:1}, err=> { udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
udp.setExtraOptions({ udp.setExtraOptions({
receiveBufferSize:1000, receiveBufferSize: 1000,
sendBufferSize:1000, sendBufferSize: 1000,
reuseAddress:false, reuseAddress: false,
socketTimeout:6000, socketTimeout: 6000,
broadcast:true broadcast: true
}, err=> { }, err => {
if (err) { if (err) {
console.log('setExtraOptions fail'); console.log('setExtraOptions fail');
return; return;
} }
console.log('setExtraOptions success'); console.log('setExtraOptions success');
}) })
}) })
``` ```
### setExtraOptions ### setExtraOptions
setExtraOptions(options: UDPExtraOptions): Promise\<void\> setExtraOptions(options: UDPExtraOptions): Promise\<void\>
设置UDPSocket连接的其他属性。使用Promise方式作为异步方法。 设置UDPSocket连接的其他属性。使用Promise方式作为异步方法。
>**说明：** > **说明：**
>bind方法调用成功后，才可调用此方法。 > bind方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -450,27 +440,26 @@ setExtraOptions(options: UDPExtraOptions): Promise\<void\> ...@@ -450,27 +440,26 @@ setExtraOptions(options: UDPExtraOptions): Promise\<void\>
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
let promise = udp.bind({address:'192.168.xx.xxx', port:xxxx, family:1}); let promise = udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1});
promise.then(() => { promise.then(() => {
console.log('bind success'); console.log('bind success');
let promise1 = udp.setExtraOptions({ let promise1 = udp.setExtraOptions({
receiveBufferSize:1000, receiveBufferSize: 1000,
sendBufferSize:1000, sendBufferSize: 1000,
reuseAddress:false, reuseAddress: false,
socketTimeout:6000, socketTimeout: 6000,
broadcast:true broadcast: true
}); });
promise1.then(() => { promise1.then(() => {
console.log('setExtraOptions success'); console.log('setExtraOptions success');
}).catch(err => { }).catch(err => {
console.log('setExtraOptions fail'); console.log('setExtraOptions fail');
}); });
}).catch(err => { }).catch(err => {
console.log('bind fail'); console.log('bind fail');
}); });
``` ```
### on('message') ### on('message')
on(type: 'message', callback: Callback\<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void on(type: 'message', callback: Callback\<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void
...@@ -491,19 +480,18 @@ on(type: 'message', callback: Callback\<{message: ArrayBuffer, remoteInfo: Socke ...@@ -491,19 +480,18 @@ on(type: 'message', callback: Callback\<{message: ArrayBuffer, remoteInfo: Socke
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.on('message', value => { udp.on('message', value => {
console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo); console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
}); });
``` ```
### off('message') ### off('message')
off(type: 'message', callback?: Callback\<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void off(type: 'message', callback?: Callback\<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void
取消订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。 取消订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -518,8 +506,8 @@ off(type: 'message', callback?: Callback\<{message: ArrayBuffer, remoteInfo: Soc ...@@ -518,8 +506,8 @@ off(type: 'message', callback?: Callback\<{message: ArrayBuffer, remoteInfo: Soc
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
let callback = value =>{ let callback = value => {
console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo); console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
} }
udp.on('message', callback); udp.on('message', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
...@@ -527,7 +515,6 @@ udp.off('message', callback); ...@@ -527,7 +515,6 @@ udp.off('message', callback);
udp.off('message'); udp.off('message');
``` ```
### on('listening' | 'close') ### on('listening' | 'close')
on(type: 'listening' | 'close', callback: Callback\<void\>): void on(type: 'listening' | 'close', callback: Callback\<void\>): void
...@@ -548,22 +535,21 @@ on(type: 'listening' | 'close', callback: Callback\<void\>): void ...@@ -548,22 +535,21 @@ on(type: 'listening' | 'close', callback: Callback\<void\>): void
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.on('listening', () => { udp.on('listening', () => {
console.log("on listening success"); console.log("on listening success");
}); });
udp.on('close', () => { udp.on('close', () => {
console.log("on close success" ); console.log("on close success");
}); });
``` ```
### off('listening' | 'close') ### off('listening' | 'close')
off(type: 'listening' | 'close', callback?: Callback\<void\>): void off(type: 'listening' | 'close', callback?: Callback\<void\>): void
取消订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。 取消订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -578,15 +564,15 @@ off(type: 'listening' | 'close', callback?: Callback\<void\>): void ...@@ -578,15 +564,15 @@ off(type: 'listening' | 'close', callback?: Callback\<void\>): void
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
let callback1 = () =>{ let callback1 = () => {
console.log("on listening, success"); console.log("on listening, success");
} }
udp.on('listening', callback1); udp.on('listening', callback1);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
udp.off('listening', callback1); udp.off('listening', callback1);
udp.off('listening'); udp.off('listening');
let callback2 = () =>{ let callback2 = () => {
console.log("on close, success"); console.log("on close, success");
} }
udp.on('close', callback2); udp.on('close', callback2);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
...@@ -594,7 +580,6 @@ udp.off('close', callback2); ...@@ -594,7 +580,6 @@ udp.off('close', callback2);
udp.off('close'); udp.off('close');
``` ```
### on('error') ### on('error')
on(type: 'error', callback: ErrorCallback): void on(type: 'error', callback: ErrorCallback): void
...@@ -615,19 +600,18 @@ on(type: 'error', callback: ErrorCallback): void ...@@ -615,19 +600,18 @@ on(type: 'error', callback: ErrorCallback): void
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
udp.on('error', err => { udp.on('error', err => {
console.log("on error, err:" + JSON.stringify(err)) console.log("on error, err:" + JSON.stringify(err))
}); });
``` ```
### off('error') ### off('error')
off(type: 'error', callback?: ErrorCallback): void off(type: 'error', callback?: ErrorCallback): void
取消订阅UDPSocket连接的error事件。使用callback方式作为异步方法。 取消订阅UDPSocket连接的error事件。使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -642,8 +626,8 @@ off(type: 'error', callback?: ErrorCallback): void ...@@ -642,8 +626,8 @@ off(type: 'error', callback?: ErrorCallback): void
```js ```js
let udp = socket.constructUDPSocketInstance(); let udp = socket.constructUDPSocketInstance();
let callback = err =>{ let callback = err => {
console.log("on error, err:" + JSON.stringify(err)); console.log("on error, err:" + JSON.stringify(err));
} }
udp.on('error', callback); udp.on('error', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
...@@ -651,7 +635,6 @@ udp.off('error', callback); ...@@ -651,7 +635,6 @@ udp.off('error', callback);
udp.off('error'); udp.off('error');
``` ```
## NetAddress ## NetAddress
目标地址信息。 目标地址信息。
...@@ -730,9 +713,9 @@ constructTCPSocketInstance(): TCPSocket ...@@ -730,9 +713,9 @@ constructTCPSocketInstance(): TCPSocket
**返回值：** **返回值：**
| 类型 | 说明 | | 类型 | 说明 |
| :--------------------------------- | :---------------------- | | :--------------------------------- | :---------------------- |
| [TCPSocket](#tcpsocket) | 返回一个TCPSocket对象。 | | [TCPSocket](#tcpsocket) | 返回一个TCPSocket对象。 |
**示例：** **示例：**
...@@ -740,7 +723,6 @@ constructTCPSocketInstance(): TCPSocket ...@@ -740,7 +723,6 @@ constructTCPSocketInstance(): TCPSocket
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
``` ```
## TCPSocket ## TCPSocket
TCPSocket连接。在调用TCPSocket的方法前，需要先通过[socket.constructTCPSocketInstance](#socketconstructtcpsocketinstance)创建TCPSocket对象。 TCPSocket连接。在调用TCPSocket的方法前，需要先通过[socket.constructTCPSocketInstance](#socketconstructtcpsocketinstance)创建TCPSocket对象。
...@@ -775,14 +757,13 @@ bind(address: NetAddress, callback: AsyncCallback\<void\>): void ...@@ -775,14 +757,13 @@ bind(address: NetAddress, callback: AsyncCallback\<void\>): void
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
tcp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => { tcp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
} }
console.log('bind success'); console.log('bind success');
}) })
``` ```
### bind ### bind
bind(address: NetAddress): Promise\<void\> bind(address: NetAddress): Promise\<void\>
...@@ -824,15 +805,14 @@ promise.then(() => { ...@@ -824,15 +805,14 @@ promise.then(() => {
}); });
``` ```
### connect ### connect
connect(options: TCPConnectOptions, callback: AsyncCallback\<void\>): void connect(options: TCPConnectOptions, callback: AsyncCallback\<void\>): void
连接到指定的IP地址和端口。使用callback方法作为异步方法。 连接到指定的IP地址和端口。使用callback方法作为异步方法。
>**说明：** > **说明：**
>bind方法调用成功后，才可调用此方法。 > bind方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -856,16 +836,15 @@ connect(options: TCPConnectOptions, callback: AsyncCallback\<void\>): void ...@@ -856,16 +836,15 @@ connect(options: TCPConnectOptions, callback: AsyncCallback\<void\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}, err => { tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000}, err => {
if (err) { if (err) {
console.log('connect fail'); console.log('connect fail');
return; return;
} }
console.log('connect success'); console.log('connect success');
}) })
``` ```
### connect ### connect
connect(options: TCPConnectOptions): Promise\<void\> connect(options: TCPConnectOptions): Promise\<void\>
...@@ -899,7 +878,7 @@ connect(options: TCPConnectOptions): Promise\<void\> ...@@ -899,7 +878,7 @@ connect(options: TCPConnectOptions): Promise\<void\>
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000});
promise.then(() => { promise.then(() => {
console.log('connect success') console.log('connect success')
}).catch(err => { }).catch(err => {
...@@ -907,15 +886,14 @@ promise.then(() => { ...@@ -907,15 +886,14 @@ promise.then(() => {
}); });
``` ```
### send ### send
send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void
通过TCPSocket连接发送数据。使用callback方式作为异步方法。 通过TCPSocket连接发送数据。使用callback方式作为异步方法。
>**说明：** > **说明：**
>connect方法调用成功后，才可调用此方法。 > connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -939,32 +917,29 @@ send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void ...@@ -939,32 +917,29 @@ send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000}, () => {
promise.then(() => {
console.log('connect success'); console.log('connect success');
tcp.send({ tcp.send({
data:'Hello, server!' data: 'Hello, server!'
},err => { //此处省略encoding， 默认为utf-8编码格式
if (err) { }, err => {
console.log('send fail'); if (err) {
return; console.log('send fail');
} return;
console.log('send success'); }
console.log('send success');
}) })
}).catch(err => { })
console.log('connect fail');
});
``` ```
### send ### send
send(options: TCPSendOptions): Promise\<void\> send(options: TCPSendOptions): Promise\<void\>
通过TCPSocket连接发送数据。使用Promise方式作为异步方法。 通过TCPSocket连接发送数据。使用Promise方式作为异步方法。
>**说明：** > **说明：**
>connect方法调用成功后，才可调用此方法。 > connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -993,23 +968,22 @@ send(options: TCPSendOptions): Promise\<void\> ...@@ -993,23 +968,22 @@ send(options: TCPSendOptions): Promise\<void\>
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise1 = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise1 = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000});
promise1.then(() => { promise1.then(() => {
console.log('connect success'); console.log('connect success');
let promise2 = tcp.send({ let promise2 = tcp.send({
data:'Hello, server!' data: 'Hello, server!'
}); });
promise2.then(() => { promise2.then(() => {
console.log('send success'); console.log('send success');
}).catch(err => { }).catch(err => {
console.log('send fail'); console.log('send fail');
}); });
}).catch(err => { }).catch(err => {
console.log('connect fail'); console.log('connect fail');
}); });
``` ```
### close ### close
close(callback: AsyncCallback\<void\>): void close(callback: AsyncCallback\<void\>): void
...@@ -1038,14 +1012,13 @@ close(callback: AsyncCallback\<void\>): void ...@@ -1038,14 +1012,13 @@ close(callback: AsyncCallback\<void\>): void
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
tcp.close(err => { tcp.close(err => {
if (err) { if (err) {
console.log('close fail'); console.log('close fail');
return; return;
} }
console.log('close success'); console.log('close success');
}) })
``` ```
### close ### close
close(): Promise\<void\> close(): Promise\<void\>
...@@ -1080,15 +1053,14 @@ promise.then(() => { ...@@ -1080,15 +1053,14 @@ promise.then(() => {
}); });
``` ```
### getRemoteAddress ### getRemoteAddress
getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void
获取对端Socket地址。使用callback方式作为异步方法。 获取对端Socket地址。使用callback方式作为异步方法。
>**说明：** > **说明：**
>connect方法调用成功后，才可调用此方法。 > connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -1110,30 +1082,26 @@ getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void ...@@ -1110,30 +1082,26 @@ getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000}, () => {
promise.then(() => {
console.log('connect success'); console.log('connect success');
tcp.getRemoteAddress((err, data) => { tcp.getRemoteAddress((err, data) => {
if (err) { if (err) {
console.log('getRemoteAddressfail'); console.log('getRemoteAddressfail');
return; return;
} }
console.log('getRemoteAddresssuccess:' + JSON.stringify(data)); console.log('getRemoteAddresssuccess:' + JSON.stringify(data));
}) })
}).catch(err => {
console.log('connect fail');
}); });
``` ```
### getRemoteAddress ### getRemoteAddress
getRemoteAddress(): Promise\<NetAddress\> getRemoteAddress(): Promise\<NetAddress\>
获取对端Socket地址。使用Promise方式作为异步方法。 获取对端Socket地址。使用Promise方式作为异步方法。
>**说明：** > **说明：**
>connect方法调用成功后，才可调用此方法。 > connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -1155,29 +1123,28 @@ getRemoteAddress(): Promise\<NetAddress\> ...@@ -1155,29 +1123,28 @@ getRemoteAddress(): Promise\<NetAddress\>
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise1 = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise1 = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000});
promise1.then(() => { promise1.then(() => {
console.log('connect success'); console.log('connect success');
let promise2 = tcp.getRemoteAddress(); let promise2 = tcp.getRemoteAddress();
promise2.then(() => { promise2.then(() => {
console.log('getRemoteAddress success'); console.log('getRemoteAddress success');
}).catch(err => { }).catch(err => {
console.log('getRemoteAddressfail'); console.log('getRemoteAddressfail');
}); });
}).catch(err => { }).catch(err => {
console.log('connect fail'); console.log('connect fail');
}); });
``` ```
### getState ### getState
getState(callback: AsyncCallback\<SocketStateBase\>): void getState(callback: AsyncCallback\<SocketStateBase\>): void
获取TCPSocket状态。使用callback方式作为异步方法。 获取TCPSocket状态。使用callback方式作为异步方法。
>**说明：** > **说明：**
>bind或connect方法调用成功后，才可调用此方法。 > bind或connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -1199,30 +1166,26 @@ getState(callback: AsyncCallback\<SocketStateBase\>): void ...@@ -1199,30 +1166,26 @@ getState(callback: AsyncCallback\<SocketStateBase\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000}, () => {
promise.then(() => {
console.log('connect success'); console.log('connect success');
tcp.getState((err, data) => { tcp.getState((err, data) => {
if (err) { if (err) {
console.log('getState fail'); console.log('getState fail');
return; return;
} }
console.log('getState success:' + JSON.stringify(data)); console.log('getState success:' + JSON.stringify(data));
}); });
}).catch(err => {
console.log('connect fail');
}); });
``` ```
### getState ### getState
getState(): Promise\<SocketStateBase\> getState(): Promise\<SocketStateBase\>
获取TCPSocket状态。使用Promise方式作为异步方法。 获取TCPSocket状态。使用Promise方式作为异步方法。
>**说明：** > **说明：**
>bind或connect方法调用成功后，才可调用此方法。 > bind或connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -1244,29 +1207,28 @@ getState(): Promise\<SocketStateBase\> ...@@ -1244,29 +1207,28 @@ getState(): Promise\<SocketStateBase\>
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000});
promise.then(() => { promise.then(() => {
console.log('connect success'); console.log('connect success');
let promise1 = tcp.getState(); let promise1 = tcp.getState();
promise1.then(() => { promise1.then(() => {
console.log('getState success'); console.log('getState success');
}).catch(err => { }).catch(err => {
console.log('getState fail'); console.log('getState fail');
}); });
}).catch(err => { }).catch(err => {
console.log('connect fail'); console.log('connect fail');
}); });
``` ```
### setExtraOptions ### setExtraOptions
setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void
设置TCPSocket连接的其他属性。使用callback方式作为异步方法。 设置TCPSocket连接的其他属性。使用callback方式作为异步方法。
>**说明：** > **说明：**
>bind或connect方法调用成功后，才可调用此方法。 > bind或connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -1290,39 +1252,35 @@ setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void ...@@ -1290,39 +1252,35 @@ setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000}, () => {
promise.then(() => {
console.log('connect success'); console.log('connect success');
tcp.setExtraOptions({ tcp.setExtraOptions({
keepAlive: true, keepAlive: true,
OOBInline: true, OOBInline: true,
TCPNoDelay: true, TCPNoDelay: true,
socketLinger: { on:true, linger:10 }, socketLinger: {on: true, linger: 10},
receiveBufferSize: 1000, receiveBufferSize: 1000,
sendBufferSize: 1000, sendBufferSize: 1000,
reuseAddress: true, reuseAddress: true,
socketTimeout: 3000, socketTimeout: 3000,
},err => { }, err => {
if (err) { if (err) {
console.log('setExtraOptions fail'); console.log('setExtraOptions fail');
return; return;
} }
console.log('setExtraOptions success'); console.log('setExtraOptions success');
}); });
}).catch(err => {
console.log('connect fail');
}); });
``` ```
### setExtraOptions ### setExtraOptions
setExtraOptions(options: TCPExtraOptions): Promise\<void\> setExtraOptions(options: TCPExtraOptions): Promise\<void\>
设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。 设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。
>**说明：** > **说明：**
>bind或connect方法调用成功后，才可调用此方法。 > bind或connect方法调用成功后，才可调用此方法。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
...@@ -1351,30 +1309,29 @@ setExtraOptions(options: TCPExtraOptions): Promise\<void\> ...@@ -1351,30 +1309,29 @@ setExtraOptions(options: TCPExtraOptions): Promise\<void\>
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}); let promise = tcp.connect({address: {address: '192.168.xx.xxx', port: xxxx, family: 1}, timeout: 6000});
promise.then(() => { promise.then(() => {
console.log('connect success'); console.log('connect success');
let promise1 = tcp.setExtraOptions({ let promise1 = tcp.setExtraOptions({
keepAlive: true, keepAlive: true,
OOBInline: true, OOBInline: true,
TCPNoDelay: true, TCPNoDelay: true,
socketLinger: { on:true, linger:10 }, socketLinger: {on: true, linger: 10},
receiveBufferSize: 1000, receiveBufferSize: 1000,
sendBufferSize: 1000, sendBufferSize: 1000,
reuseAddress: true, reuseAddress: true,
socketTimeout: 3000, socketTimeout: 3000,
}); });
promise1.then(() => { promise1.then(() => {
console.log('setExtraOptions success'); console.log('setExtraOptions success');
}).catch(err => { }).catch(err => {
console.log('setExtraOptions fail'); console.log('setExtraOptions fail');
}); });
}).catch(err => { }).catch(err => {
console.log('connect fail'); console.log('connect fail');
}); });
``` ```
### on('message') ### on('message')
on(type: 'message', callback: Callback<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void on(type: 'message', callback: Callback<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void
...@@ -1395,19 +1352,18 @@ on(type: 'message', callback: Callback<{message: ArrayBuffer, remoteInfo: Socket ...@@ -1395,19 +1352,18 @@ on(type: 'message', callback: Callback<{message: ArrayBuffer, remoteInfo: Socket
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
tcp.on('message', value => { tcp.on('message', value => {
console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo) console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo)
}); });
``` ```
### off('message') ### off('message')
off(type: 'message', callback?: Callback<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void off(type: 'message', callback?: Callback<{message: ArrayBuffer, remoteInfo: SocketRemoteInfo}\>): void
取消订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。 取消订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -1422,8 +1378,8 @@ off(type: 'message', callback?: Callback<{message: ArrayBuffer, remoteInfo: Sock ...@@ -1422,8 +1378,8 @@ off(type: 'message', callback?: Callback<{message: ArrayBuffer, remoteInfo: Sock
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let callback = value =>{ let callback = value => {
console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo); console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
} }
tcp.on('message', callback); tcp.on('message', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
...@@ -1431,7 +1387,6 @@ tcp.off('message', callback); ...@@ -1431,7 +1387,6 @@ tcp.off('message', callback);
tcp.off('message'); tcp.off('message');
``` ```
### on('connect' | 'close') ### on('connect' | 'close')
on(type: 'connect' | 'close', callback: Callback\<void\>): void on(type: 'connect' | 'close', callback: Callback\<void\>): void
...@@ -1452,22 +1407,21 @@ on(type: 'connect' | 'close', callback: Callback\<void\>): void ...@@ -1452,22 +1407,21 @@ on(type: 'connect' | 'close', callback: Callback\<void\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
tcp.on('connect', () => { tcp.on('connect', () => {
console.log("on connect success") console.log("on connect success")
}); });
tcp.on('close', data => { tcp.on('close', data => {
console.log("on close success") console.log("on close success")
}); });
``` ```
### off('connect' | 'close') ### off('connect' | 'close')
off(type: 'connect' | 'close', callback?: Callback\<void\>): void off(type: 'connect' | 'close', callback?: Callback\<void\>): void
取消订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。 取消订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -1482,15 +1436,15 @@ off(type: 'connect' | 'close', callback?: Callback\<void\>): void ...@@ -1482,15 +1436,15 @@ off(type: 'connect' | 'close', callback?: Callback\<void\>): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let callback1 = () =>{ let callback1 = () => {
console.log("on connect success"); console.log("on connect success");
} }
tcp.on('connect', callback1); tcp.on('connect', callback1);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
tcp.off('connect', callback1); tcp.off('connect', callback1);
tcp.off('connect'); tcp.off('connect');
let callback2 = () =>{ let callback2 = () => {
console.log("on close success"); console.log("on close success");
} }
tcp.on('close', callback2); tcp.on('close', callback2);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
...@@ -1498,7 +1452,6 @@ tcp.off('close', callback2); ...@@ -1498,7 +1452,6 @@ tcp.off('close', callback2);
tcp.off('close'); tcp.off('close');
``` ```
### on('error') ### on('error')
on(type: 'error', callback: ErrorCallback): void on(type: 'error', callback: ErrorCallback): void
...@@ -1519,19 +1472,18 @@ on(type: 'error', callback: ErrorCallback): void ...@@ -1519,19 +1472,18 @@ on(type: 'error', callback: ErrorCallback): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
tcp.on('error', err => { tcp.on('error', err => {
console.log("on error, err:" + JSON.stringify(err)) console.log("on error, err:" + JSON.stringify(err))
}); });
``` ```
### off('error') ### off('error')
off(type: 'error', callback?: ErrorCallback): void off(type: 'error', callback?: ErrorCallback): void
取消订阅TCPSocket连接的error事件。使用callback方式作为异步方法。 取消订阅TCPSocket连接的error事件。使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -1546,8 +1498,8 @@ off(type: 'error', callback?: ErrorCallback): void ...@@ -1546,8 +1498,8 @@ off(type: 'error', callback?: ErrorCallback): void
```js ```js
let tcp = socket.constructTCPSocketInstance(); let tcp = socket.constructTCPSocketInstance();
let callback = err =>{ let callback = err => {
console.log("on error, err:" + JSON.stringify(err)); console.log("on error, err:" + JSON.stringify(err));
} }
tcp.on('error', callback); tcp.on('error', callback);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
...@@ -1555,7 +1507,6 @@ tcp.off('error', callback); ...@@ -1555,7 +1507,6 @@ tcp.off('error', callback);
tcp.off('error'); tcp.off('error');
``` ```
## TCPConnectOptions ## TCPConnectOptions
TCPSocket连接的参数。 TCPSocket连接的参数。
...@@ -1769,12 +1720,11 @@ getState(): Promise\<SocketStateBase\> ...@@ -1769,12 +1720,11 @@ getState(): Promise\<SocketStateBase\>
**示例：** **示例：**
```js ```js
tls.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => { let promiseBind = tls.bind({address: '192.168.xx.xxx', port: xxxx, family: 1});
if (err) { promiseBind.then(() => {
console.log('bind fail');
return;
}
console.log('bind success'); console.log('bind success');
}).catch((err) => {
console.log('bind fail');
}); });
let promise = tls.getState(); let promise = tls.getState();
promise.then(() => { promise.then(() => {
...@@ -1822,18 +1772,19 @@ tls.setExtraOptions({ ...@@ -1822,18 +1772,19 @@ tls.setExtraOptions({
keepAlive: true, keepAlive: true,
OOBInline: true, OOBInline: true,
TCPNoDelay: true, TCPNoDelay: true,
socketLinger: { on:true, linger:10 }, socketLinger: {on: true, linger: 10},
receiveBufferSize: 1000, receiveBufferSize: 1000,
sendBufferSize: 1000, sendBufferSize: 1000,
reuseAddress: true, reuseAddress: true,
socketTimeout: 3000, socketTimeout: 3000,
},err => { }, err => {
if (err) { if (err) {
console.log('setExtraOptions fail'); console.log('setExtraOptions fail');
return; return;
} }
console.log('setExtraOptions success'); console.log('setExtraOptions success');
}); });
``` ```
### setExtraOptions<sup>9+</sup> ### setExtraOptions<sup>9+</sup>
...@@ -1878,7 +1829,7 @@ let promise = tls.setExtraOptions({ ...@@ -1878,7 +1829,7 @@ let promise = tls.setExtraOptions({
keepAlive: true, keepAlive: true,
OOBInline: true, OOBInline: true,
TCPNoDelay: true, TCPNoDelay: true,
socketLinger: { on:true, linger:10 }, socketLinger: {on: true, linger: 10},
receiveBufferSize: 1000, receiveBufferSize: 1000,
sendBufferSize: 1000, sendBufferSize: 1000,
reuseAddress: true, reuseAddress: true,
...@@ -1956,12 +1907,12 @@ let options = { ...@@ -1956,12 +1907,12 @@ let options = {
}, },
}; };
tlsTwoWay.connect(options, (err, data) => { tlsTwoWay.connect(options, (err, data) => {
console.error("connect callback error"+err); console.error("connect callback error" + err);
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
let tlsOneWay = socket.constructTLSSocketInstance(); // One way authentication let tlsOneWay = socket.constructTLSSocketInstance(); // One way authentication
tlsOneWay.bind({address: '192.168.xxx.xxx', port: 8080, family: 1}, err => { tlsOneWay.bind({address: '192.168.xxx.xxx', port: 8080, family: 1}, err => {
if (err) { if (err) {
console.log('bind fail'); console.log('bind fail');
return; return;
...@@ -1975,12 +1926,12 @@ let oneWayOptions = { ...@@ -1975,12 +1926,12 @@ let oneWayOptions = {
family: 1, family: 1,
}, },
secureOptions: { secureOptions: {
ca: ["xxxx","xxxx"], ca: ["xxxx", "xxxx"],
cipherSuite: "AES256-SHA256", cipherSuite: "AES256-SHA256",
}, },
}; };
tlsOneWay.connect(oneWayOptions, (err, data) => { tlsOneWay.connect(oneWayOptions, (err, data) => {
console.error("connect callback error"+err); console.error("connect callback error" + err);
console.log(JSON.stringify(data)); console.log(JSON.stringify(data));
}); });
``` ```
...@@ -2075,7 +2026,7 @@ let oneWayOptions = { ...@@ -2075,7 +2026,7 @@ let oneWayOptions = {
family: 1, family: 1,
}, },
secureOptions: { secureOptions: {
ca: ["xxxx","xxxx"], ca: ["xxxx", "xxxx"],
cipherSuite: "AES256-SHA256", cipherSuite: "AES256-SHA256",
}, },
}; };
...@@ -2551,7 +2502,7 @@ send(data: string): Promise\<void\> ...@@ -2551,7 +2502,7 @@ send(data: string): Promise\<void\>
**示例：** **示例：**
```js ```js
tls.send("xxxx").then(() =>{ tls.send("xxxx").then(() => {
console.log("send success"); console.log("send success");
}).catch(err => { }).catch(err => {
console.error(err); console.error(err);
...@@ -2619,7 +2570,7 @@ close(): Promise\<void\> ...@@ -2619,7 +2570,7 @@ close(): Promise\<void\>
**示例：** **示例：**
```js ```js
tls.close().then(() =>{ tls.close().then(() => {
console.log("close success"); console.log("close success");
}).catch(err => { }).catch(err => {
console.error(err); console.error(err);
......
zh-cn/application-dev/reference/apis/js-apis-webSocket.md
浏览文件 @ 75afe266
# @ohos.net.webSocket (WebSocket连接) # @ohos.net.webSocket (WebSocket连接)
> **说明：** > **说明：**
> >
> 本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 > 本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
使用WebSocket建立服务器与客户端的双向连接，需要先通过[createWebSocket](#websocketcreatewebsocket)方法创建[WebSocket](#websocket)对象，然后通过[connect](#connect)方法连接到服务器。当连接成功后，客户端会收到[open](#onopen)事件的回调，之后客户端就可以通过[send](#send)方法与服务器进行通信。当服务器发信息给客户端时，客户端会收到[message](#onmessage)事件的回调。当客户端不要此连接时，可以通过调用[close](#close)方法主动断开连接，之后客户端会收到[close](#onclose)事件的回调。 使用WebSocket建立服务器与客户端的双向连接，需要先通过[createWebSocket](#websocketcreatewebsocket)方法创建[WebSocket](#websocket)对象，然后通过[connect](#connect)方法连接到服务器。
当连接成功后，客户端会收到[open](#onopen)事件的回调，之后客户端就可以通过[send](#send)方法与服务器进行通信。
当服务器发信息给客户端时，客户端会收到[message](#onmessage)事件的回调。当客户端不要此连接时，可以通过调用[close](#close)方法主动断开连接，之后客户端会收到[close](#onclose)事件的回调。
若在上述任一过程中发生错误，客户端会收到[error](#onerror)事件的回调。 若在上述任一过程中发生错误，客户端会收到[error](#onerror)事件的回调。
## 导入模块 ## 导入模块
```js ```js
...@@ -21,44 +22,48 @@ import webSocket from '@ohos.net.webSocket'; ...@@ -21,44 +22,48 @@ import webSocket from '@ohos.net.webSocket';
```js ```js
import webSocket from '@ohos.net.webSocket'; import webSocket from '@ohos.net.webSocket';
var defaultIpAddress = "ws://"; let defaultIpAddress = "ws://";
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
ws.on('open', (err, value) => { ws.on('open', (err, value) => {
console.log("on open, status:" + value['status'] + ", message:" + value['message']); if (err != undefined) {
// 当收到on('open')事件时，可以通过send()方法与服务器进行通信 console.log(JSON.stringify(err))
ws.send("Hello, server!", (err, value) => { return
if (!err) { }
console.log("send success"); console.log("on open, status:" + value['status'] + ", message:" + value['message']);
} else { // 当收到on('open')事件时，可以通过send()方法与服务器进行通信
console.log("send fail, err:" + JSON.stringify(err)); ws.send("Hello, server!", (err, value) => {
} if (!err) {
}); console.log("send success");
} else {
console.log("send fail, err:" + JSON.stringify(err));
}
});
}); });
ws.on('message', (err, value) => { ws.on('message', (err, value) => {
console.log("on message, message:" + value); console.log("on message, message:" + value);
// 当收到服务器的`bye`消息时（此消息字段仅为示意，具体字段需要与服务器协商），主动断开连接 // 当收到服务器的`bye`消息时（此消息字段仅为示意，具体字段需要与服务器协商），主动断开连接
if (value === 'bye') { if (value === 'bye') {
ws.close((err, value) => { ws.close((err, value) => {
if (!err) { if (!err) {
console.log("close success"); console.log("close success");
} else { } else {
console.log("close fail, err is " + JSON.stringify(err)); console.log("close fail, err is " + JSON.stringify(err));
} }
}); });
} }
}); });
ws.on('close', (err, value) => { ws.on('close', (err, value) => {
console.log("on close, code is " + value.code + ", reason is " + value.reason); console.log("on close, code is " + value.code + ", reason is " + value.reason);
}); });
ws.on('error', (err) => { ws.on('error', (err) => {
console.log("on error, error:" + JSON.stringify(err)); console.log("on error, error:" + JSON.stringify(err));
}); });
ws.connect(defaultIpAddress, (err, value) => { ws.connect(defaultIpAddress, (err, value) => {
if (!err) { if (!err) {
console.log("connect success"); console.log("connect success");
} else { } else {
console.log("connect fail, err:" + JSON.stringify(err)); console.log("connect fail, err:" + JSON.stringify(err));
} }
}); });
``` ```
...@@ -82,7 +87,6 @@ createWebSocket(): WebSocket ...@@ -82,7 +87,6 @@ createWebSocket(): WebSocket
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
``` ```
## WebSocket ## WebSocket
在调用WebSocket的方法前，需要先通过[webSocket.createWebSocket](#websocketcreatewebsocket)创建一个WebSocket。 在调用WebSocket的方法前，需要先通过[webSocket.createWebSocket](#websocketcreatewebsocket)创建一个WebSocket。
...@@ -93,6 +97,9 @@ connect(url: string, callback: AsyncCallback\<boolean\>): void ...@@ -93,6 +97,9 @@ connect(url: string, callback: AsyncCallback\<boolean\>): void
根据URL地址，建立一个WebSocket连接，使用callback方式作为异步方法。 根据URL地址，建立一个WebSocket连接，使用callback方式作为异步方法。
> **说明：**
> 可通过监听error事件获得该接口的执行结果，错误发生时会得到错误码：200。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -117,21 +124,23 @@ connect(url: string, callback: AsyncCallback\<boolean\>): void ...@@ -117,21 +124,23 @@ connect(url: string, callback: AsyncCallback\<boolean\>): void
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://" let url = "ws://"
ws.connect(url, (err, value) => { ws.connect(url, (err, value) => {
if (!err) { if (!err) {
console.log("connect success"); console.log("connect success");
} else { } else {
console.log("connect fail, err:" + JSON.stringify(err)) console.log("connect fail, err:" + JSON.stringify(err))
} }
}); });
``` ```
### connect ### connect
connect(url: string, options: WebSocketRequestOptions, callback: AsyncCallback\<boolean\>): void connect(url: string, options: WebSocketRequestOptions, callback: AsyncCallback\<boolean\>): void
根据URL地址和header，建立一个WebSocket连接，使用callback方式作为异步方法。 根据URL地址和header，建立一个WebSocket连接，使用callback方式作为异步方法。
> **说明：**
> 可通过监听error事件获得该接口的执行结果，错误发生时会得到错误码：200。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -157,26 +166,28 @@ connect(url: string, options: WebSocketRequestOptions, callback: AsyncCallback\< ...@@ -157,26 +166,28 @@ connect(url: string, options: WebSocketRequestOptions, callback: AsyncCallback\<
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://" let url = "ws://"
ws.connect(url, { ws.connect(url, {
header: { header: {
"key": "value", "key": "value",
"key2": "value2" "key2": "value2"
} }
}, (err, value) => { }, (err, value) => {
if (!err) { if (!err) {
console.log("connect success"); console.log("connect success");
} else { } else {
console.log("connect fail, err:" + JSON.stringify(err)) console.log("connect fail, err:" + JSON.stringify(err))
} }
}); });
``` ```
### connect ### connect
connect(url: string, options?: WebSocketRequestOptions): Promise\<boolean\> connect(url: string, options?: WebSocketRequestOptions): Promise\<boolean\>
根据URL地址和header，建立一个WebSocket连接，使用Promise方式作为异步方法。 根据URL地址和header，建立一个WebSocket连接，使用Promise方式作为异步方法。
> **说明：**
> 可通过监听error事件获得该接口的执行结果，错误发生时会得到错误码：200。
**需要权限**：ohos.permission.INTERNET **需要权限**：ohos.permission.INTERNET
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -208,13 +219,12 @@ let ws = webSocket.createWebSocket(); ...@@ -208,13 +219,12 @@ let ws = webSocket.createWebSocket();
let url = "ws://" let url = "ws://"
let promise = ws.connect(url); let promise = ws.connect(url);
promise.then((value) => { promise.then((value) => {
console.log("connect success") console.log("connect success")
}).catch((err) => { }).catch((err) => {
console.log("connect fail, error:" + JSON.stringify(err)) console.log("connect fail, error:" + JSON.stringify(err))
}); });
``` ```
### send ### send
send(data: string | ArrayBuffer, callback: AsyncCallback\<boolean\>): void send(data: string | ArrayBuffer, callback: AsyncCallback\<boolean\>): void
...@@ -245,17 +255,16 @@ send(data: string | ArrayBuffer, callback: AsyncCallback\<boolean\>): void ...@@ -245,17 +255,16 @@ send(data: string | ArrayBuffer, callback: AsyncCallback\<boolean\>): void
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://" let url = "ws://"
ws.connect(url, (err, value) => { ws.connect(url, (err, value) => {
ws.send("Hello, server!", (err, value) => { ws.send("Hello, server!", (err, value) => {
if (!err) { if (!err) {
console.log("send success"); console.log("send success");
} else { } else {
console.log("send fail, err:" + JSON.stringify(err)) console.log("send fail, err:" + JSON.stringify(err))
} }
}); });
}); });
``` ```
### send ### send
send(data: string | ArrayBuffer): Promise\<boolean\> send(data: string | ArrayBuffer): Promise\<boolean\>
...@@ -291,16 +300,15 @@ send(data: string | ArrayBuffer): Promise\<boolean\> ...@@ -291,16 +300,15 @@ send(data: string | ArrayBuffer): Promise\<boolean\>
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://" let url = "ws://"
ws.connect(url, (err, value) => { ws.connect(url, (err, value) => {
let promise = ws.send("Hello, server!"); let promise = ws.send("Hello, server!");
promise.then((value) => { promise.then((value) => {
console.log("send success") console.log("send success")
}).catch((err) => { }).catch((err) => {
console.log("send fail, error:" + JSON.stringify(err)) console.log("send fail, error:" + JSON.stringify(err))
}); });
}); });
``` ```
### close ### close
close(callback: AsyncCallback\<boolean\>): void close(callback: AsyncCallback\<boolean\>): void
...@@ -328,17 +336,15 @@ close(callback: AsyncCallback\<boolean\>): void ...@@ -328,17 +336,15 @@ close(callback: AsyncCallback\<boolean\>): void
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://"
ws.close((err, value) => { ws.close((err, value) => {
if (!err) { if (!err) {
console.log("close success") console.log("close success")
} else { } else {
console.log("close fail, err is " + JSON.stringify(err)) console.log("close fail, err is " + JSON.stringify(err))
} }
}); });
``` ```
### close ### close
close(options: WebSocketCloseOptions, callback: AsyncCallback\<boolean\>): void close(options: WebSocketCloseOptions, callback: AsyncCallback\<boolean\>): void
...@@ -367,20 +373,18 @@ close(options: WebSocketCloseOptions, callback: AsyncCallback\<boolean\>): void ...@@ -367,20 +373,18 @@ close(options: WebSocketCloseOptions, callback: AsyncCallback\<boolean\>): void
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://"
ws.close({ ws.close({
code: 1000, code: 1000,
reason: "your reason" reason: "your reason"
}, (err, value) => { }, (err, value) => {
if (!err) { if (!err) {
console.log("close success") console.log("close success")
} else { } else {
console.log("close fail, err is " + JSON.stringify(err)) console.log("close fail, err is " + JSON.stringify(err))
} }
}); });
``` ```
### close ### close
close(options?: WebSocketCloseOptions): Promise\<boolean\> close(options?: WebSocketCloseOptions): Promise\<boolean\>
...@@ -414,19 +418,17 @@ close(options?: WebSocketCloseOptions): Promise\<boolean\> ...@@ -414,19 +418,17 @@ close(options?: WebSocketCloseOptions): Promise\<boolean\>
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let url = "ws://"
let promise = ws.close({ let promise = ws.close({
code: 1000, code: 1000,
reason: "your reason" reason: "your reason"
}); });
promise.then((value) => { promise.then((value) => {
console.log("close success") console.log("close success")
}).catch((err) => { }).catch((err) => {
console.log("close fail, err is " + JSON.stringify(err)) console.log("close fail, err is " + JSON.stringify(err))
}); });
``` ```
### on('open') ### on('open')
on(type: 'open', callback: AsyncCallback\<Object\>): void on(type: 'open', callback: AsyncCallback\<Object\>): void
...@@ -442,25 +444,23 @@ on(type: 'open', callback: AsyncCallback\<Object\>): void ...@@ -442,25 +444,23 @@ on(type: 'open', callback: AsyncCallback\<Object\>): void
| type | string | 是 | 'open'：WebSocket的打开事件。 | | type | string | 是 | 'open'：WebSocket的打开事件。 |
| callback | AsyncCallback\<Object\> | 是 | 回调函数。 | | callback | AsyncCallback\<Object\> | 是 | 回调函数。 |
**示例：** **示例：**
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
ws.on('open', (err, value) => { ws.on('open', (err, value) => {
console.log("on open, status:" + value['status'] + ", message:" + value['message']); console.log("on open, status:" + value['status'] + ", message:" + value['message']);
}); });
``` ```
### off('open') ### off('open')
off(type: 'open', callback?: AsyncCallback\<Object\>): void off(type: 'open', callback?: AsyncCallback\<Object\>): void
取消订阅WebSocket的打开事件，使用callback方式作为异步方法。 取消订阅WebSocket的打开事件，使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -476,22 +476,21 @@ off(type: 'open', callback?: AsyncCallback\<Object\>): void ...@@ -476,22 +476,21 @@ off(type: 'open', callback?: AsyncCallback\<Object\>): void
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
let callback1 = (err, value) => { let callback1 = (err, value) => {
console.log("on open, status:" + value['status'] + ", message:" + value['message']); console.log("on open, status:" + value['status'] + ", message:" + value['message']);
} }
ws.on('open', callback1); ws.on('open', callback1);
// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅
ws.off('open', callback1); ws.off('open', callback1);
``` ```
### on('message') ### on('message')
on(type: 'message', callback: AsyncCallback\<string | ArrayBuffer\>): void on(type: 'message', callback: AsyncCallback\<string | ArrayBuffer\>): void
订阅WebSocket的接收到服务器消息事件，使用callback方式作为异步方法。每个消息最大长度为4K，超过4K自动分片。 订阅WebSocket的接收到服务器消息事件，使用callback方式作为异步方法。每个消息最大长度为4K，超过4K自动分片。
>**说明：** > **说明：**
>AsyncCallback中的数据可以是字符串(API 6)或ArrayBuffer(API 8)。 > AsyncCallback中的数据可以是字符串(API 6)或ArrayBuffer(API 8)。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -507,20 +506,19 @@ on(type: 'message', callback: AsyncCallback\<string | ArrayBuffer\>): void ...@@ -507,20 +506,19 @@ on(type: 'message', callback: AsyncCallback\<string | ArrayBuffer\>): void
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
ws.on('message', (err, value) => { ws.on('message', (err, value) => {
console.log("on message, message:" + value); console.log("on message, message:" + value);
}); });
``` ```
### off('message') ### off('message')
off(type: 'message', callback?: AsyncCallback\<string | ArrayBuffer\>): void off(type: 'message', callback?: AsyncCallback\<string | ArrayBuffer\>): void
取消订阅WebSocket的接收到服务器消息事件，使用callback方式作为异步方法。每个消息最大长度为4K，超过4K自动分片。 取消订阅WebSocket的接收到服务器消息事件，使用callback方式作为异步方法。每个消息最大长度为4K，超过4K自动分片。
>**说明：** > **说明：**
>AsyncCallback中的数据可以是字符串(API 6)或ArrayBuffer(API 8)。 > AsyncCallback中的数据可以是字符串(API 6)或ArrayBuffer(API 8)。
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -538,7 +536,6 @@ let ws = webSocket.createWebSocket(); ...@@ -538,7 +536,6 @@ let ws = webSocket.createWebSocket();
ws.off('message'); ws.off('message');
``` ```
### on('close') ### on('close')
on(type: 'close', callback: AsyncCallback\<{ code: number, reason: string }\>): void on(type: 'close', callback: AsyncCallback\<{ code: number, reason: string }\>): void
...@@ -559,19 +556,18 @@ on(type: 'close', callback: AsyncCallback\<{ code: number, reason: string }\>): ...@@ -559,19 +556,18 @@ on(type: 'close', callback: AsyncCallback\<{ code: number, reason: string }\>):
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
ws.on('close', (err, value) => { ws.on('close', (err, value) => {
console.log("on close, code is " + value.code + ", reason is " + value.reason); console.log("on close, code is " + value.code + ", reason is " + value.reason);
}); });
``` ```
### off('close') ### off('close')
off(type: 'close', callback?: AsyncCallback\<{ code: number, reason: string }\>): void off(type: 'close', callback?: AsyncCallback\<{ code: number, reason: string }\>): void
取消订阅WebSocket的关闭事件，使用callback方式作为异步方法。 取消订阅WebSocket的关闭事件，使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -589,7 +585,6 @@ let ws = webSocket.createWebSocket(); ...@@ -589,7 +585,6 @@ let ws = webSocket.createWebSocket();
ws.off('close'); ws.off('close');
``` ```
### on('error') ### on('error')
on(type: 'error', callback: ErrorCallback): void on(type: 'error', callback: ErrorCallback): void
...@@ -603,26 +598,25 @@ on(type: 'error', callback: ErrorCallback): void ...@@ -603,26 +598,25 @@ on(type: 'error', callback: ErrorCallback): void
| 参数名 | 类型 | 必填 | 说明 | | 参数名 | 类型 | 必填 | 说明 |
| -------- | ------------- | ---- | ------------------------------- | | -------- | ------------- | ---- | ------------------------------- |
| type | string | 是 | 'error'：WebSocket的Error事件。 | | type | string | 是 | 'error'：WebSocket的Error事件。 |
| callback | ErrorCallback | 是 | 回调函数。 | | callback | ErrorCallback | 是 | 回调函数。<br>常见错误码：200 |
**示例：** **示例：**
```js ```js
let ws = webSocket.createWebSocket(); let ws = webSocket.createWebSocket();
ws.on('error', (err) => { ws.on('error', (err) => {
console.log("on error, error:" + JSON.stringify(err)) console.log("on error, error:" + JSON.stringify(err))
}); });
``` ```
### off('error') ### off('error')
off(type: 'error', callback?: ErrorCallback): void off(type: 'error', callback?: ErrorCallback): void
取消订阅WebSocket的Error事件，使用callback方式作为异步方法。 取消订阅WebSocket的Error事件，使用callback方式作为异步方法。
>**说明：** > **说明：**
>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 > 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
**系统能力**：SystemCapability.Communication.NetStack **系统能力**：SystemCapability.Communication.NetStack
...@@ -640,7 +634,6 @@ let ws = webSocket.createWebSocket(); ...@@ -640,7 +634,6 @@ let ws = webSocket.createWebSocket();
ws.off('error'); ws.off('error');
``` ```
## WebSocketRequestOptions ## WebSocketRequestOptions
建立WebSocket连接时，可选参数的类型和说明。 建立WebSocket连接时，可选参数的类型和说明。
...@@ -651,7 +644,6 @@ ws.off('error'); ...@@ -651,7 +644,6 @@ ws.off('error');
| ------ | ------ | ---- | ------------------------------------------------------------ | | ------ | ------ | ---- | ------------------------------------------------------------ |
| header | Object | 否 | 建立WebSocket连接可选参数，代表建立连接时携带的HTTP头信息。参数内容自定义，也可以不指定。 | | header | Object | 否 | 建立WebSocket连接可选参数，代表建立连接时携带的HTTP头信息。参数内容自定义，也可以不指定。 |
## WebSocketCloseOptions ## WebSocketCloseOptions
关闭WebSocket连接时，可选参数的类型和说明。 关闭WebSocket连接时，可选参数的类型和说明。
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或