diff --git a/zh-cn/application-dev/reference/apis/js-apis-http.md b/zh-cn/application-dev/reference/apis/js-apis-http.md
new file mode 100644
index 0000000000000000000000000000000000000000..23b7eb543c2bf16fe372381abbb53fd19590916f
--- /dev/null
+++ b/zh-cn/application-dev/reference/apis/js-apis-http.md
@@ -0,0 +1,431 @@
+# 数据请求
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>
+>本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+>
+>本模块所有接口需要设备具有系统能力：SystemCapability.Communication.NetStack
+
+## 导入模块
+
+```
+import http from '@ohos.net.http';
+```
+
+## 完整示例
+
+```
+import http from '@ohos.net.http';
+
+// 每一个httpRequest对应一个http请求任务，不可复用
+let httpRequest = http.createHttp();
+// 用于订阅http响应头，此接口会比request请求先返回。可以根据业务需要订阅此消息
+// 从API 8开始，使用on('headersReceive', Callback)替代on('headerReceive', AsyncCallback)。 8+
+httpRequest.on('headersReceive', (data) => {
+    console.info('header: ' + data.header);
+});
+httpRequest.request(
+    // 填写http请求的url地址，可以带参数也可以不带参数。URL地址需要开发者自定义。GET请求的参数可以在extraData中指定
+    "EXAMPLE_URL",
+    {
+        method: 'POST', // 可选，默认为“GET”
+        // 开发者根据自身业务需要添加header字段
+        header: {
+            'Content-Type': 'application/json'
+        },
+        // 当使用POST请求时此字段用于传递内容
+ 
+        extraData: {
+            "data": "data to send",
+        },
+        connectTimeout: 60000, // 可选，默认为60s
+        readTimeout: 60000, // 可选，默认为60s
+    },(err, data) => {
+        if (!err) {
+            // data.result为http响应内容，可根据业务需要进行解析
+            console.info('Result:' + data.result);
+            console.info('code:' + data.responseCode);
+            // data.header为http响应头，可根据业务需要进行解析
+            console.info('header:' + data.header);
+            console.info('cookies:' + data.cookies); // 8+
+        } else {
+            console.info('error:' + err);
+            // 当该请求使用完毕时，调用destroy方法主动销毁。
+            httpRequest.destroy();
+        }
+    }
+);
+```
+
+## http.createHttp
+
+createHttp\(\): HttpRequest
+
+创建一个http，里面包括发起请求、中断请求、订阅/取消订阅HTTP Response Header 事件。每一个HttpRequest对象对应一个Http请求。如需发起多个Http请求，须为每个Http请求创建对应HttpRequest对象。
+
+**返回值：**
+
+| 类型        | 说明                                                         |
+| :---------- | :----------------------------------------------------------- |
+| HttpRequest | 返回一个HttpRequest对象，里面包括request、destroy、on和off方法。 |
+
+**示例：**
+
+```
+import http from '@ohos.net.http';
+let httpRequest = http.createHttp();
+```
+
+
+## HttpRequest
+
+http请求任务。在调用HttpRequest的方法前，需要先通过[createHttp\(\)](#httpcreatehttp)创建一个任务。
+
+### request
+
+request\(url: string, callback: AsyncCallback\<HttpResponse\>\):void
+
+根据URL地址，发起HTTP网络请求，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                                    | 必填 | 说明                    |
+| -------- | ------------------------------------------------------- | ---- | ----------------------- |
+| url      | string                                                  | 是   | 发起网络请求的URL地址。 |
+| callback | AsyncCallback\<[HttpResponse](#httpresponse)\> | 是   | 回调函数。              |
+
+**示例：**
+
+```
+let httpRequest = http.createHttp();
+httpRequest.request("EXAMPLE_URL", (err, data) => {
+  if (!err) {
+    console.info('Result:' + data.result);
+    console.info('code:' + data.responseCode);
+    console.info('header:' + data.header);
+    console.info('cookies:' + data.cookies); // 8+
+  } else {
+    console.info('error:' + err.data);
+  }
+});
+```
+
+### request
+
+request\(url: string, options: HttpRequestOptions, callback: AsyncCallback<HttpResponse\>\):void
+
+根据URL地址和相关配置项，发起HTTP网络请求，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                           | 必填 | 说明                                            |
+| -------- | ---------------------------------------------- | ---- | ----------------------------------------------- |
+| url      | string                                         | 是   | 发起网络请求的URL地址。                         |
+| options  | HttpRequestOptions                             | 是   | 参考[HttpRequestOptions](#httprequestoptions)。 |
+| callback | AsyncCallback\<[HttpResponse](#httpresponse)\> | 是   | 回调函数。                                      |
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.request("EXAMPLE_URL",
+{
+  method: 'GET',
+  header: {
+	'Content-Type': 'application/json'
+  },
+  readTimeout: 60000,
+  connectTimeout: 60000
+},(err, data) => {
+  if (!err) {
+	console.info('Result:' + data.result);
+	console.info('code:' + data.responseCode);
+	console.info('header:' + data.header);
+	console.info('cookies:' + data.cookies); // 8+
+	console.info('header['Content-Type']:' + data.header['Content-Type']);
+	console.info('header['Status-Line']:' + data.header['Status-Line']);
+	console.info('header.Date:' + data.header.Date);
+	console.info('header.Server:' + data.header.Server);
+  } else {
+	console.info('error:' + err.data);
+  }
+});
+```
+
+
+### request
+
+request\(url: string, options? : HttpRequestOptions\): Promise<HttpResponse\>
+
+根据URL地址，发起HTTP网络请求，使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型               | 必填 | 说明                                               |
+| ------- | ------------------ | ---- | -------------------------------------------------- |
+| url     | string             | 是   | 发起网络请求的URL地址。                            |
+| options | HttpRequestOptions | 是   | 参考[HttpRequestOptions](#httprequestoptions)。 |
+
+**返回值：**
+
+| 类型                  | 说明                              |
+| :-------------------- | :-------------------------------- |
+| Promise<[HttpResponse](#httpresponse)> | 以Promise形式返回发起请求的结果。 |
+
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+let promise = httpRequest.request("EXAMPLE_URL", {
+  method: "GET",
+  connectTimeout: 60000,
+  readTimeout: 60000,
+  header: {
+	'Content-Type': 'application/json'
+  }
+});
+promise.then((value) => {
+	console.info('Result:' + value.result);
+	console.info('code:' + value.responseCode);
+	console.info('header:' + value.header);
+	console.info('cookies:' + value.cookies); // 8+
+	console.info('header['Content-Type']:' + value.header['Content-Type']);
+	console.info('header['Status-Line']:' + value.header['Status-Line']);
+	console.info('header.Date:' + value.header.Date);
+	console.info('header.Server:' + value.header.Server);
+}).catch((err) => {
+	console.error(`errCode:${err.code}, errMessage:${err.data}`);
+});
+```
+
+### destroy
+
+destroy\(\): void
+
+中断请求任务。
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.destroy();
+```
+
+### on\('headerReceive'\)
+
+on\(type: 'headerReceive', callback: AsyncCallback<Object\>\):void
+
+订阅HTTP Response Header 事件。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+> 此接口已废弃，建议使用[on\('headersReceive'\)<sup>8+</sup>](#onheadersreceive8)替代。
+
+**参数：**
+
+| 参数名   | 类型                    | 必填 | 说明                              |
+| -------- | ----------------------- | ---- | --------------------------------- |
+| type     | string                  | 是   | 订阅的事件类型，'headerReceive'。 |
+| callback | AsyncCallback\<Object\> | 是   | 回调函数。                        |
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.on('headerReceive', (err, data) => {
+  if (!err) {
+	console.info('header: ' + data.header);
+  } else {
+	console.info('error:' + err.data);
+  }
+});
+```
+
+
+### off\('headerReceive'\)
+
+off\(type: 'headerReceive', callback?: AsyncCallback<Object\>\):void
+
+取消订阅HTTP Response Header 事件。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>
+>1. 此接口已废弃，建议使用[off\('headersReceive'\)<sup>8+</sup>](#offheadersreceive8)替代。
+>
+>2. 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型                    | 必填 | 说明                                  |
+| -------- | ----------------------- | ---- | ------------------------------------- |
+| type     | string                  | 是   | 取消订阅的事件类型，'headerReceive'。 |
+| callback | AsyncCallback\<Object\> | 否   | 回调函数。                            |
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.on('headerReceive', (err, data) => {
+  if (!err) {
+	console.info('header: ' + data.header);
+  } else {
+	console.info('error:' + err.data);
+  }
+});
+httpRequest.off('headerReceive');
+```
+
+### on\('headersReceive'\)<sup>8+</sup>
+
+on\(type: 'headersReceive', callback: Callback<Object\>\):void
+
+订阅HTTP Response Header 事件。
+
+**参数：**
+
+| 参数名   | 类型               | 必填 | 说明                               |
+| -------- | ------------------ | ---- | ---------------------------------- |
+| type     | string             | 是   | 订阅的事件类型：'headersReceive'。 |
+| callback | Callback\<Object\> | 是   | 回调函数。                         |
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.on('headersReceive', (data) => {
+  console.info('header: ' + data.header);
+});
+```
+
+
+### off\('headersReceive'\)<sup>8+</sup>
+
+off\(type: 'headersReceive', callback?: Callback<Object\>\):void
+
+取消订阅HTTP Response Header 事件。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型               | 必填 | 说明                                   |
+| -------- | ------------------ | ---- | -------------------------------------- |
+| type     | string             | 是   | 取消订阅的事件类型：'headersReceive'。 |
+| callback | Callback\<Object\> | 否   | 回调函数。                             |
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.off('headersReceive');
+```
+
+### once\('headersReceive'\)<sup>8+</sup>
+
+once\(type: "headersReceive", callback: Callback<Object\>\): void
+
+订阅HTTP Response Header 事件，但是只触发一次。一旦触发之后，订阅器就会被移除。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型               | 必填 | 说明                               |
+| -------- | ------------------ | ---- | ---------------------------------- |
+| type     | string             | 是   | 订阅的事件类型：'headersReceive'。 |
+| callback | Callback\<Object\> | 是   | 回调函数。                         |
+
+**示例：**
+
+```
+let httpRequest= http.createHttp();
+httpRequest.once('headersReceive', (data) => {
+  console.info('header: ' + data.header);
+});
+```
+
+## HttpRequestOptions
+
+发起请求可选参数的类型和取值范围。
+
+| 参数           | 类型                                 | 必填 | 说明                                                       |
+| -------------- | ------------------------------------ | ---- | ---------------------------------------------------------- |
+| method         | [RequestMethod](#requestmethod) | 否   | 请求方式。                                                 |
+| extraData      | string \| Object  \| ArrayBuffer<sup>8+</sup> | 否   | 发送请求的额外数据。<br />- 当HTTP请求为POST、PUT等方法时，此字段为HTTP请求的content。<br />- 当HTTP请求为GET、OPTIONS、DELETE、TRACE、CONNECT等方法时，此字段为HTTP请求的参数补充，参数内容会拼接到URL中进行发送。<sup>8+</sup><br />- 开发者传入string对象，开发者需要自行编码，将编码后的string传入。<sup>8+</sup> |
+| header         | Object                               | 否   | HTTP请求头字段。默认{'Content-Type': 'application/json'}。 |
+| readTimeout    | number                               | 否   | 读取超时时间。单位为毫秒（ms），默认为60000ms。            |
+| connectTimeout | number                               | 否   | 连接超时时间。单位为毫秒（ms），默认为60000ms。            |
+
+## RequestMethod
+
+HTTP 请求方法。
+
+| **method 的合法值** | 说明                |
+| :------------------ | :------------------ |
+| OPTIONS             | HTTP 请求 OPTIONS。 |
+| GET                 | HTTP 请求 GET。     |
+| HEAD                | HTTP 请求 HEAD。    |
+| POST                | HTTP 请求 POST。    |
+| PUT                 | HTTP 请求 PUT。     |
+| DELETE              | HTTP 请求 DELETE。  |
+| TRACE               | HTTP 请求 TRACE。   |
+| CONNECT             | HTTP 请求 CONNECT。 |
+
+## ResponseCode
+
+发起请求返回的响应码。
+
+| 变量              | 值   | 说明                                                         |
+| ----------------- | ---- | ------------------------------------------------------------ |
+| OK                | 200  | 请求成功。一般用于GET与POST请求。                            |
+| CREATED           | 201  | 已创建。成功请求并创建了新的资源。                           |
+| ACCEPTED          | 202  | 已接受。已经接受请求，但未处理完成。                         |
+| NOT_AUTHORITATIVE | 203  | 非授权信息。请求成功。                                       |
+| NO_CONTENT        | 204  | 无内容。服务器成功处理，但未返回内容。                       |
+| RESET             | 205  | 重置内容。                                                   |
+| PARTIAL           | 206  | 部分内容。服务器成功处理了部分GET请求。                      |
+| MULT_CHOICE       | 300  | 多种选择。                                                   |
+| MOVED_PERM        | 301  | 永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。 |
+| MOVED_TEMP        | 302  | 临时移动。                                                   |
+| SEE_OTHER         | 303  | 查看其它地址。                                               |
+| NOT_MODIFIED      | 304  | 未修改。                                                     |
+| USE_PROXY         | 305  | 使用代理。                                                   |
+| BAD_REQUEST       | 400  | 客户端请求的语法错误，服务器无法理解。                       |
+| UNAUTHORIZED      | 401  | 请求要求用户的身份认证。                                     |
+| PAYMENT_REQUIRED  | 402  | 保留，将来使用。                                             |
+| FORBIDDEN         | 403  | 服务器理解请求客户端的请求，但是拒绝执行此请求。             |
+| NOT_FOUND         | 404  | 服务器无法根据客户端的请求找到资源（网页）。                 |
+| BAD_METHOD        | 405  | 客户端请求中的方法被禁止。                                   |
+| NOT_ACCEPTABLE    | 406  | 服务器无法根据客户端请求的内容特性完成请求。                 |
+| PROXY_AUTH        | 407  | 请求要求代理的身份认证。                                     |
+| CLIENT_TIMEOUT    | 408  | 请求时间过长，超时。                                         |
+| CONFLICT          | 409  | 服务器完成客户端的PUT请求是可能返回此代码，服务器处理请求时发生了冲突。 |
+| GONE              | 410  | 客户端请求的资源已经不存在。                                 |
+| LENGTH_REQUIRED   | 411  | 服务器无法处理客户端发送的不带Content-Length的请求信息。     |
+| PRECON_FAILED     | 412  | 客户端请求信息的先决条件错误。                               |
+| ENTITY_TOO_LARGE  | 413  | 由于请求的实体过大，服务器无法处理，因此拒绝请求。           |
+| REQ_TOO_LONG      | 414  | 请求的URI过长（URI通常为网址），服务器无法处理。             |
+| UNSUPPORTED_TYPE  | 415  | 服务器无法处理请求的格式。                                   |
+| INTERNAL_ERROR    | 500  | 服务器内部错误，无法完成请求。                               |
+| NOT_IMPLEMENTED   | 501  | 服务器不支持请求的功能，无法完成请求。                       |
+| BAD_GATEWAY       | 502  | 充当网关或代理的服务器，从远端服务器接收到了一个无效的请求。 |
+| UNAVAILABLE       | 503  | 由于超载或系统维护，服务器暂时的无法处理客户端的请求。       |
+| GATEWAY_TIMEOUT   | 504  | 充当网关或代理的服务器，未及时从远端服务器获取请求。         |
+| VERSION           | 505  | 服务器请求的HTTP协议的版本。                                 |
+
+## HttpResponse
+
+request方法回调函数的返回值类型。
+
+| 参数名               | 类型                                         | 必填 | 说明                                                         |
+| -------------------- | -------------------------------------------- | ---- | ------------------------------------------------------------ |
+| result               | string \| Object \| ArrayBuffer<sup>8+</sup> | 是   | Http请求根据响应头中Content-type类型返回对应的响应格式内容：<br />- application/json：返回JSON格式的字符串，如需Http响应具体内容，需开发者自行解析<br />- application/octet-stream：ArrayBuffer<br />- 其他：string |
+| responseCode         | [ResponseCode](#responsecode) \| number      | 是   | 回调函数执行成功时，此字段为[ResponseCode](#responsecode)。若执行失败，错误码将会从AsyncCallback中的err字段返回。错误码如下：<br />- 200：通用错误<br />- 202：参数错误<br />- 300：I/O错误 |
+| 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> | Array\<string\>                              | 是   | 服务器返回的 cookies。                                       |
+
diff --git a/zh-cn/application-dev/reference/apis/js-apis-net-connection.md b/zh-cn/application-dev/reference/apis/js-apis-net-connection.md
index 3b72f6733c4785062fa3cb6f3168cc90342576ca..107a0b739fdef9400beda39e01091f9534a47859 100644
--- a/zh-cn/application-dev/reference/apis/js-apis-net-connection.md
+++ b/zh-cn/application-dev/reference/apis/js-apis-net-connection.md
@@ -1,5 +1,6 @@
 # 网络连接管理
 
+
 > **说明：**
 >
 > 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
@@ -104,6 +105,54 @@ connection.hasDefaultNet().then(function (has) {
 })
 ```
 
+## connection.getAllNets
+
+getAllNets(callback: AsyncCallback&lt;Array&lt;NetHandle&gt;&gt;): void
+
+获取全部激活的数据网络列表，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.GET_NETWORK_INFO
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名 | 类型 | 必填 | 说明 |
+| -------- | -------- | -------- | -------- |
+| callback | AsyncCallback&lt;Array&lt;[NetHandle](#nethandle)&gt;&gt; | 是 | 回调函数。 |
+
+**示例：**
+
+```
+connection.getAllNets(function (error, nets) {
+    console.log(JSON.stringify(error))
+    console.log(JSON.stringify(nets))
+});
+```
+
+
+## connection.getAllNets
+
+getAllNets(): Promise&lt;Array&lt;NetHandle&gt;&gt;
+
+获取全部激活的数据网络列表，使用promise方式作为异步方法。
+
+**需要权限**：ohos.permission.GET_NETWORK_INFO
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**返回值：**
+| 类型 | 说明 |
+| -------- | -------- |
+| Promise&lt;Array&lt;[NetHandle](#nethandle)&gt;&gt; | 以Promise形式返回激活的数据网络列表。 |
+
+**示例：**
+
+```
+connection.getAllNets().then(function (nets) {
+    console.log(JSON.stringify(nets))
+});
+```
+
 ## connection.getConnectionProperties
 
 getConnectionProperties(netHandle: NetHandle, callback: AsyncCallback\<ConnectionProperties>): void
@@ -224,6 +273,121 @@ connection.getDefaultNet().then(function (netHandle) {
 })
 ```
 
+## connection.reportNetConnected
+
+reportNetConnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): void
+
+报告网络状态已连接，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名 | 类型 | 必填 | 说明 |
+| -------- | -------- | -------- | -------- |
+| netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 |
+| callback | AsyncCallback&lt;void&gt; | 是 | 回调函数。 |
+
+**示例：**
+
+```
+connection.getDefaultNet().then(function (netHandle) {
+    connection.reportNetConnected(netHandle, function (error) {
+        console.log(JSON.stringify(error))
+    });
+});
+```
+
+
+## connection.reportNetConnected
+
+reportNetConnected(netHandle: NetHandle): Promise&lt;void&gt;
+
+报告网络状态已连接，使用promise方式作为异步方法。
+
+**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名 | 类型 | 必填 | 说明 |
+| -------- | -------- | -------- | -------- |
+| netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 |
+
+**返回值：**
+| 类型 | 说明 |
+| -------- | -------- |
+| Promise&lt;void&gt; | 以Promise形式返回执行结果。 |
+
+**示例：**
+
+```
+connection.getDefaultNet().then(function (netHandle) {
+    connection.reportNetConnected(netHandle).then(function () {
+        console.log(`report success`)
+    });
+});
+```
+
+
+## connection.reportNetDisconnected
+
+reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback&lt;void&gt;): void
+
+报告网络状态已断开，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名 | 类型 | 必填 | 说明 |
+| -------- | -------- | -------- | -------- |
+| netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 |
+| callback | AsyncCallback&lt;void&gt; | 是 | 回调函数。 |
+
+**示例：**
+
+```
+connection.getDefaultNet().then(function (netHandle) {
+    connection.reportNetDisconnected(netHandle, function (error) {
+        console.log(JSON.stringify(error))
+    });
+});
+```
+
+
+## connection.reportNetDisconnected
+
+reportNetDisconnected(netHandle: NetHandle): Promise&lt;void&gt;
+
+报告网络状态已断开，使用promise方式作为异步方法。
+
+**需要权限**：ohos.permission.GET_NETWORK_INFO 和 ohos.permission.INTERNET
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名 | 类型 | 必填 | 说明 |
+| -------- | -------- | -------- | -------- |
+| netHandle | [NetHandle](#nethandle) | 是 | 数据网络的句柄，参考[NetHandle](#nethandle)。 |
+
+**返回值：**
+| 类型 | 说明 |
+| -------- | -------- |
+| Promise&lt;void&gt; | 以Promise形式返回执行结果。 |
+
+**示例：**
+
+```
+connection.getDefaultNet().then(function (netHandle) {
+    connection.reportNetDisconnected(netHandle).then(function () {
+        console.log(`report success`)
+    });
+});
+```
+
 ## connection.getAddressesByName
 
 getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>): void
@@ -243,18 +407,17 @@ getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>):
 
 **示例：**
 
-```javascript
-connection.getDefaultNet().then(function (netHandle) {
-    connection.getAddressesByName(netHandle, function (error, info) {
-        console.log(JSON.stringify(error))
-        console.log(JSON.stringify(info))
-    })
+```
+let host = "xxxx";
+connection.getAddressesByName(host, function (error, addresses) {
+    console.log(JSON.stringify(error))
+    console.log(JSON.stringify(addresses))
 })
 ```
 
 ## connection.getAddressesByName
 
-getAddressesByName(netHandle: NetHandle): Promise\<Array\<NetAddress>>
+getAddressesByName(host: string): Promise\<Array\<NetAddress>>
 
 使用默认网络解析主机名以获取所有IP地址，使用Promise方式作为异步方法。
 
@@ -276,11 +439,10 @@ getAddressesByName(netHandle: NetHandle): Promise\<Array\<NetAddress>>
 
 **示例：**
 
-```javascript
-connection.getDefaultNet().then(function (netHandle) {
-    connection.getAddressesByName(netHandle).then(function (info) {
-        console.log(JSON.stringify(info))
-    })
+```
+let host = "xxxx";
+connection.getAddressesByName(host).then(function (addresses) {
+    console.log(JSON.stringify(addresses))
 })
 ```
 
@@ -309,12 +471,12 @@ createNetConnection(netSpecifier?: NetSpecifier, timeout?: number): NetConnectio
 
 ```javascript
 // 关注默认网络
-let netConnection1 = connection.createNetConnection()
+let netConnection = connection.createNetConnection()
 
 // 关注蜂窝网络
-let netConnection2 = connection.createNetConnection({
+let netConnectionCellular = connection.createNetConnection({
     netCapabilities: {
-        networkCap: [0]
+        bearerTypes: [NetBearType.BEARER_CELLULAR]
     }
 })
 ```
@@ -327,7 +489,7 @@ let netConnection2 = connection.createNetConnection({
 
 on(type: 'netAvailable', callback: Callback\<NetHandle>): void
 
-监听网络可用事件。
+订阅网络可用事件。
 
 **系统能力**：SystemCapability.Communication.NetManager.Core
 
@@ -335,13 +497,13 @@ on(type: 'netAvailable', callback: Callback\<NetHandle>): void
 
 | 参数名   | 类型                               | 必填 | 说明                                                         |
 | -------- | ---------------------------------- | ---- | ------------------------------------------------------------ |
-| type     | string                             | 是   | 监听事件，固定为'netAvailable'。<br>netAvailable：数据网络可用事件。 |
+| type     | string                             | 是   | 订阅事件，固定为'netAvailable'。<br>netAvailable：数据网络可用事件。 |
 | callback | Callback\<[NetHandle](#nethandle)> | 是   | 回调函数。                                                   |
 
 **示例：**
 
 ```javascript
-connection.createNetConnection().on('netAvailable', function (data) {
+netConnection.on('netAvailable', function (data) {
     console.log(JSON.stringify(data))
 })
 ```
@@ -350,7 +512,7 @@ connection.createNetConnection().on('netAvailable', function (data) {
 
 on(type: 'netCapabilitiesChange', callback: Callback<{ netHandle: NetHandle, netCap: NetCapabilities }>): void
 
-监听网络能力变化事件。
+订阅网络能力变化事件。
 
 **系统能力**：SystemCapability.Communication.NetManager.Core
 
@@ -358,13 +520,13 @@ on(type: 'netCapabilitiesChange', callback: Callback<{ netHandle: NetHandle, net
 
 | 参数名   | 类型                                                         | 必填 | 说明                                                         |
 | -------- | ------------------------------------------------------------ | ---- | ------------------------------------------------------------ |
-| type     | string                                                       | 是   | 监听事件，固定为'netCapabilitiesChange'。<br/>netCapabilitiesChange：网络能力变化事件。 |
+| type     | string                                                       | 是   | 订阅事件，固定为'netCapabilitiesChange'。<br/>netCapabilitiesChange：网络能力变化事件。 |
 | callback | Callback<{ netHandle: [NetHandle](#nethandle), netCap: [NetCapabilities](#netcapabilities) }> | 是   | 回调函数。                                                   |
 
 **示例：**
 
 ```javascript
-connection.createNetConnection().on('netCapabilitiesChange', function (data) {
+netConnection.on('netCapabilitiesChange', function (data) {
     console.log(JSON.stringify(data))
 })
 ```
@@ -373,7 +535,7 @@ connection.createNetConnection().on('netCapabilitiesChange', function (data) {
 
 on(type: 'netConnectionPropertiesChange', callback: Callback<{ netHandle: NetHandle, connectionProperties: ConnectionProperties }>): void
 
-监听网络连接信息变化事件。
+订阅网络连接信息变化事件。
 
 **系统能力**：SystemCapability.Communication.NetManager.Core
 
@@ -381,13 +543,36 @@ on(type: 'netConnectionPropertiesChange', callback: Callback<{ netHandle: NetHan
 
 | 参数名   | 类型                                                         | 必填 | 说明                                                         |
 | -------- | ------------------------------------------------------------ | ---- | ------------------------------------------------------------ |
-| type     | string                                                       | 是   | 监听事件，固定为'netConnectionPropertiesChange'。<br/>netConnectionPropertiesChange：网络连接信息变化事件。 |
+| type     | string                                                       | 是   | 订阅事件，固定为'netConnectionPropertiesChange'。<br/>netConnectionPropertiesChange：网络连接信息变化事件。 |
 | callback | Callback<{ netHandle: [NetHandle](#nethandle), connectionProperties: [ConnectionProperties](#connectionproperties) }> | 是   | 回调函数。                                                   |
 
 **示例：**
 
 ```javascript
-connection.createNetConnection().on('netConnectionPropertiesChange', function (data) {
+netConnection.on('netConnectionPropertiesChange', function (data) {
+    console.log(JSON.stringify(data))
+})
+```
+
+### on('netBlockStatusChange')
+
+on(type: 'netBlockStatusChange', callback: Callback&lt;{ netHandle: NetHandle, blocked: boolean }&gt;): void
+
+订阅网络阻塞状态事件，使用callback方式作为异步方法。
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+
+| 参数名   | 类型                                                         | 必填 | 说明                                                         |
+| -------- | ------------------------------------------------------------ | ---- | ------------------------------------------------------------ |
+| type     | string                                                       | 是   | 订阅事件，固定为'netBlockStatusChange'。<br/>netBlockStatusChange：网络阻塞状态事件。 |
+| callback | Callback&lt;{&nbsp;netHandle:&nbsp;[NetHandle](#nethandle),&nbsp;blocked:&nbsp;boolean&nbsp;}&gt; | 是   | 回调函数。                                                   |
+
+**示例：**
+
+```javascript
+netConnection.on('netBlockStatusChange', function (data) {
     console.log(JSON.stringify(data))
 })
 ```
@@ -396,7 +581,7 @@ connection.createNetConnection().on('netConnectionPropertiesChange', function (d
 
 on(type: 'netLost', callback: Callback\<NetHandle>): void
 
-监听网络丢失事件。
+订阅网络丢失事件。
 
 **系统能力**：SystemCapability.Communication.NetManager.Core
 
@@ -404,13 +589,14 @@ on(type: 'netLost', callback: Callback\<NetHandle>): void
 
 | 参数名   | 类型                               | 必填 | 说明                                                         |
 | -------- | ---------------------------------- | ---- | ------------------------------------------------------------ |
-| type     | string                             | 是   | 监听事件，固定为'netLost'。<br/>netLost：网络严重中断或正常断开事件。 |
+| type     | string                             | 是   | 订阅事件，固定为'netLost'。<br/>netLost：网络严重中断或正常断开事件。 |
 | callback | Callback\<[NetHandle](#nethandle)> | 是   | 回调函数。                                                   |
 
 **示例：**
 
 ```javascript
-connection.createNetConnection().on('netLost', function (data) {
+let netConnection1 = connection.createNetConnection()
+netConnection1.on('netLost', function (data) {
     console.log(JSON.stringify(data))
 })
 ```
@@ -419,7 +605,7 @@ connection.createNetConnection().on('netLost', function (data) {
 
 on(type: 'netUnavailable', callback: Callback\<void>): void
 
-监听网络不可用事件。
+订阅网络不可用事件。
 
 **系统能力**：SystemCapability.Communication.NetManager.Core
 
@@ -427,13 +613,13 @@ on(type: 'netUnavailable', callback: Callback\<void>): void
 
 | 参数名   | 类型            | 必填 | 说明                                                         |
 | -------- | --------------- | ---- | ------------------------------------------------------------ |
-| type     | string          | 是   | 监听事件，固定为'netUnavailable'。<br/>netUnavailable：网络不可用事件。 |
+| type     | string          | 是   | 订阅事件，固定为'netUnavailable'。<br/>netUnavailable：网络不可用事件。 |
 | callback | Callback\<void> | 是   | 回调函数。                                                   |
 
 **示例：**
 
 ```javascript
-connection.createNetConnection().on('netUnavailable', function (data) {
+netConnection.on('netUnavailable', function (data) {
     console.log(JSON.stringify(data))
 })
 ```
@@ -442,7 +628,7 @@ connection.createNetConnection().on('netUnavailable', function (data) {
 
 register(callback: AsyncCallback\<void>): void
 
-注册网络的监听。
+订阅指定网络状态变化的通知。
 
 **需要权限**：ohos.permission.GET_NETWORK_INFO
 
@@ -457,7 +643,7 @@ register(callback: AsyncCallback\<void>): void
 **示例：**
 
 ```javascript
-connection.createNetConnection().register(function (error) {
+netConnection.register(function (error) {
     console.log(JSON.stringify(error))
 })
 ```
@@ -466,7 +652,7 @@ connection.createNetConnection().register(function (error) {
 
 unregister(callback: AsyncCallback\<void>): void
 
-注销网络的监听。
+取消订阅默认网络状态变化的通知。
 
 **系统能力**：SystemCapability.Communication.NetManager.Core
 
@@ -479,7 +665,7 @@ unregister(callback: AsyncCallback\<void>): void
 **示例：**
 
 ```javascript
-connection.createNetConnection().unregister(function (error) {
+netConnection.unregister(function (error) {
     console.log(JSON.stringify(error))
 })
 ```
@@ -496,6 +682,77 @@ connection.createNetConnection().unregister(function (error) {
 | ----- | ------ | ------------------------- |
 | netId | number | 网络ID，必须大于等于100。 |
 
+### bindSocket
+
+bindSocket(socketParam: TCPSocket | UDPSocket, callback: AsyncCallback&lt;void&gt;): void
+
+将TCPSocket或UDPSocket绑定到当前网络，使用callback方式作为异步方法。
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名      | 类型                      | 必填 | 说明             |
+| ----------- | ------------------------- | ---- | ---------------- |
+| socketParam | TCPSocket \| UDPSocket    | 是   | TCPSocket或UDPSocket对象。 |
+| callback    | AsyncCallback&lt;void&gt; | 是   | 回调函数。       |
+
+**示例：**
+
+```
+// 绑定TCPSocket
+connection.getDefaultNet().then(function (netHandle) {
+    let tcpSocket = socket.constructTCPSocketInstance()
+    netHandle.bindSocket(tcpSocket, (function (error) {
+        console.log(JSON.stringify(error))
+    }))
+})
+// 绑定UDPSocket
+connection.getDefaultNet().then(function (netHandle) {
+    let udpSocket = socket.constructUDPSocketInstance()
+    netHandle.bindSocket(udpSocket, (function (error) {
+        console.log(JSON.stringify(error))
+    }))
+})
+```
+
+
+### bindSocket
+
+bindSocket(socketParam: TCPSocket | UDPSocket): Promise&lt;void&gt;
+
+将TCPSocket或UDPSocket绑定到当前网络，使用promise方式作为异步方法。
+
+**系统能力**：SystemCapability.Communication.NetManager.Core
+
+**参数：**
+| 参数名      | 类型                                                         | 必填 | 说明                                                         |
+| ----------- | ------------------------------------------------------------ | ---- | ------------------------------------------------------------ |
+| socketParam | TCPSocket \| UDPSocket    | 是   | TCPSocket或UDPSocket对象。 |
+
+**返回值：**
+| 类型                | 说明                        |
+| ------------------- | --------------------------- |
+| Promise&lt;void&gt; | 以Promise形式返回执行结果。 |
+
+**示例：**
+
+```
+// 绑定TCPSocket
+connection.getDefaultNet().then(function (netHandle) {
+    let tcpSocket = socket.constructTCPSocketInstance()
+    netHandle.bindSocket(tcpSocket).then(function () {
+        console.log("bind socket success")
+    })
+})
+// 绑定UDPSocket
+connection.getDefaultNet().then(function (netHandle) {
+    let udpSocket = socket.constructUDPSocketInstance()
+    netHandle.bindSocket(udpSocket).then(function () {
+        console.log("bind socket success")
+    })
+})
+```
+
 ### getAddressesByName
 
 getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>): void
@@ -515,9 +772,10 @@ getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>):
 
 ```javascript
 connection.getDefaultNet().then(function (netHandle) {
-    connection.getAddressesByName(netHandle, function (error, info) {
+    let host = "xxxx";
+    netHandle.getAddressesByName(host, function (error, addresses) {
         console.log(JSON.stringify(error))
-        console.log(JSON.stringify(info))
+        console.log(JSON.stringify(addresses))
     })
 })
 ```
@@ -546,8 +804,9 @@ getAddressesByName(netHandle: NetHandle): Promise\<Array\<NetAddress>>
 
 ```javascript
 connection.getDefaultNet().then(function (netHandle) {
-    connection.getAddressesByName(netHandle).then(function (info) {
-        console.log(JSON.stringify(info))
+    let host = "xxxx";
+    netHandle.getAddressesByName(host).then(function (addresses) {
+        console.log(JSON.stringify(addresses))
     })
 })
 ```
@@ -571,9 +830,10 @@ getAddressByName(host: string, callback: AsyncCallback\<NetAddress>): void
 
 ```javascript
 connection.getDefaultNet().then(function (netHandle) {
-    connection.getAddressByName(netHandle, function (error, info) {
+    let host = "xxxx";
+    netHandle.getAddressByName(host, function (error, address) {
         console.log(JSON.stringify(error))
-        console.log(JSON.stringify(info))
+        console.log(JSON.stringify(address))
     })
 })
 ```
@@ -602,8 +862,9 @@ getAddressByName(netHandle: NetHandle): Promise\<NetAddress>
 
 ```javascript
 connection.getDefaultNet().then(function (netHandle) {
-    connection.getAddressByName(netHandle).then(function (info) {
-        console.log(JSON.stringify(info))
+    let host = "xxxx";
+    netHandle.getAddressByName(host).then(function (address) {
+        console.log(JSON.stringify(address))
     })
 })
 ```
@@ -634,7 +895,10 @@ connection.getDefaultNet().then(function (netHandle) {
 
 | 变量                     | 值   | 说明                   |
 | ------------------------ | ---- | ---------------------- |
+| NET_CAPABILITY_MMS | 0 | 表示网络可以访问运营商的MMSC（Multimedia&nbsp;Message&nbsp;Service，多媒体短信服务）发送和接收彩信。 |
+| NET_CAPABILITY_NOT_METERED | 11 | 表示网络流量未被计费。 |
 | NET_CAPABILITY_INTERNET  | 12   | 网络可以访问Internet。 |
+| NET_CAPABILITY_NOT_VPN | 15 | 表示网络不使用VPN（Virtual&nbsp;Private&nbsp;Network，虚拟专用网络）。 |
 | NET_CAPABILITY_VALIDATED | 16   | 网络可用。             |
 
 ## NetBearType
@@ -645,6 +909,7 @@ connection.getDefaultNet().then(function (netHandle) {
 | --------------- | ---- | ----------- |
 | BEARER_CELLULAR | 0    | 蜂窝网络。  |
 | BEARER_WIFI     | 1    | Wi-Fi网络。 |
+| BEARER_ETHERNET | 3 | 以太网网络。 |
 
 ## ConnectionProperties
 
@@ -656,6 +921,7 @@ connection.getDefaultNet().then(function (netHandle) {
 | domains       | string                             | 所属域，默认""。 |
 | linkAddresses | Array<[LinkAddress](#linkaddress)> | 链路信息。       |
 | routes        | Array<[RouteInfo](#routeinfo)>     | 路由信息。       |
+| dnses | Array&lt;[NetAddress](#netaddress)&gt; | 网络地址，参考[NetAddress](#netaddress)。 |
 | mtu           | number                             | 最大传输单元。   |
 
 ## LinkAddress
diff --git a/zh-cn/application-dev/reference/apis/js-apis-socket.md b/zh-cn/application-dev/reference/apis/js-apis-socket.md
new file mode 100644
index 0000000000000000000000000000000000000000..701c53fd9c4e9d38a35e2166543605d7812b5f36
--- /dev/null
+++ b/zh-cn/application-dev/reference/apis/js-apis-socket.md
@@ -0,0 +1,1364 @@
+# Socket连接
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>
+>本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+>
+>本模块所有接口需要设备具有系统能力：SystemCapability.Communication.NetStack
+
+## 导入模块
+
+```
+import socket from '@ohos.net.socket';
+```
+
+## 权限列表
+
+ohos.permission.INTERNET
+
+## socket.constructUDPSocketInstance
+
+constructUDPSocketInstance\(\): UDPSocket
+
+创建一个UDPSocket对象。
+
+**返回值：**
+
+| 类型                               | 说明                    |
+| :--------------------------------- | :---------------------- |
+| [UDPSocket](#udpsocket) | 返回一个UDPSocket对象。 |
+
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+```
+
+
+## UDPSocket
+
+UDPSocket连接。在调用UDPSocket的方法前，需要先通过[socket.constructUDPSocketInstance](#socketconstructudpsocketinstance)创建UDPSocket对象。
+
+### bind
+
+bind\(address: NetAddress, callback: AsyncCallback<void\>\): void
+
+绑定IP地址和端口，端口可以指定或由系统随机分配。使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                               | 必填 | 说明                                                   |
+| -------- | ---------------------------------- | ---- | ------------------------------------------------------ |
+| address  | [NetAddress](#netaddress) | 是   | 目标地址信息，参考[NetAddress](#netaddress)。 |
+| callback | AsyncCallback\<void\>              | 是   | 回调函数。                                             |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
+  if (err) {
+	console.log('bind fail');
+	return;
+  }
+  console.log('bind success');
+})
+```
+
+
+### bind
+
+bind\(address: NetAddress\): Promise<void\>
+
+绑定IP地址和端口，端口可以指定或由系统随机分配。使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                               | 必填 | 说明                                                   |
+| ------- | ---------------------------------- | ---- | ------------------------------------------------------ |
+| address | [NetAddress](#netaddress) | 是   | 目标地址信息，参考[NetAddress](#netaddress)。 |
+
+
+**返回值：**
+
+| 类型            | 说明                                       |
+| :-------------- | :----------------------------------------- |
+| Promise\<void\> | 以Promise形式异步返回UDPSocket绑定的结果。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+let promise = udp.bind({address: '192.168.xx.xxx', port: 8080, family: 1});
+promise .then(() => {
+  console.log('bind success');
+}).catch(err => {
+  console.log('bind fail');
+});
+```
+
+
+### send
+
+send\(options: UDPSendOptions, callback: AsyncCallback<void\>\): void
+
+通过UDPSocket连接发送数据。使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                     | 必填 | 说明                                                         |
+| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| options  | [UDPSendOptions](#udpsendoptions) | 是   | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 |
+| callback | AsyncCallback\<void\>                    | 是   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.send({
+  data:'Hello, server!',
+  address: {
+	address:'192.168.xx.xxx',
+	port:xxxx,
+	family:1
+  }
+}, err=> {
+	if (err) {
+	  console.log('send fail');
+	  return;
+	}
+	console.log('send success');
+})
+```
+
+
+### send
+
+send\(options: UDPSendOptions\): Promise<void\>
+
+通过UDPSocket连接发送数据。使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                                     | 必填 | 说明                                                         |
+| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| options | [UDPSendOptions](#udpsendoptions) | 是   | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 |
+
+**返回值：**
+
+| 类型            | 说明                                           |
+| :-------------- | :--------------------------------------------- |
+| Promise\<void\> | 以Promise形式返回UDPSocket连接发送数据的结果。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+let promise = udp.send({
+  data:'Hello, server!',
+  address: {
+	address:'192.168.xx.xxx',
+	port:xxxx,
+	family:1
+  }
+});
+promise.then(() => {
+  console.log('send success');
+}).catch(err => {
+  console.log('send fail');
+});
+```
+
+
+### close
+
+close\(callback: AsyncCallback<void\>\): void
+
+关闭UDPSocket连接。使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明       |
+| -------- | --------------------- | ---- | ---------- |
+| callback | AsyncCallback\<void\> | 是   | 回调函数。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.close(err => {
+  if (err) {
+	console.log('close fail');
+	return;
+  }
+  console.log('close success');
+})
+```
+
+
+### close
+
+close\(\): Promise<void\>
+
+关闭UDPSocket连接。使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**返回值：**
+
+| 类型            | 说明                                       |
+| :-------------- | :----------------------------------------- |
+| Promise\<void\> | 以Promise形式返回关闭UDPSocket连接的结果。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+let promise = udp.close();
+promise.then(() => {
+  console.log('close success');
+}).catch(err => {
+  console.log('close fail');
+});
+```
+
+
+### getState
+
+getState\(callback: AsyncCallback<SocketStateBase\>\): void
+
+获取UDPSocket状态。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                                   | 必填 | 说明       |
+| -------- | ------------------------------------------------------ | ---- | ---------- |
+| callback | AsyncCallback<[SocketStateBase](#socketstatebase)> | 是   | 回调函数。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
+  if (err) {
+	console.log('bind fail');
+	return;
+  }
+  console.log('bind success');
+  udp.getState((err, data) => {
+	if (err) {
+	  console.log('getState fail');
+	  return;
+	}
+	console.log('getState success:' + JSON.stringify(data));
+  })
+})
+```
+
+
+### getState
+
+getState\(\): Promise<SocketStateBase\>
+
+获取UDPSocket状态。使用Promise方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**返回值：**
+
+| 类型                                             | 说明                                       |
+| :----------------------------------------------- | :----------------------------------------- |
+| Promise<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取UDPSocket状态的结果。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
+  if (err) {
+	console.log('bind fail');
+	return;
+  }
+  console.log('bind success');
+  let promise = udp.getState({});
+  promise.then(data => {
+	console.log('getState success:' + JSON.stringify(data));
+  }).catch(err => {
+	console.log('getState fail');
+  });
+})
+```
+
+
+### setExtraOptions
+
+setExtraOptions\(options: UDPExtraOptions, callback: AsyncCallback<void\>\): void
+
+设置UDPSocket连接的其他属性。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                     | 必填 | 说明                                                         |
+| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| options  | [UDPExtraOptions](#udpextraoptions) | 是   | UDPSocket连接的其他属性，参考[UDPExtraOptions](#udpextraoptions)。 |
+| callback | AsyncCallback\<void\>                    | 是   | 回调函数。                                                   |
+
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.bind({address:'192.168.xx.xxx', port:xxxx, family:1}, err=> {
+  if (err) {
+	console.log('bind fail');
+	return;
+  }
+  console.log('bind success');
+  udp.setExtraOptions({
+	receiveBufferSize:1000,
+	sendBufferSize:1000,
+	reuseAddress:false,
+	socketTimeout:6000,
+	broadcast:true
+  }, err=> {
+	if (err) {
+	  console.log('setExtraOptions fail');
+	  return;
+	}
+	console.log('setExtraOptions success');
+  })
+})
+```
+
+
+### setExtraOptions
+
+setExtraOptions\(options: UDPExtraOptions\): Promise<void\>
+
+设置UDPSocket连接的其他属性。使用Promise方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                                     | 必填 | 说明                                                         |
+| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| options | [UDPExtraOptions](#udpextraoptions) | 是   | UDPSocket连接的其他属性，参考[UDPExtraOptions](#udpextraoptions)。 |
+
+**返回值：**
+
+| 类型            | 说明                                                 |
+| :-------------- | :--------------------------------------------------- |
+| Promise\<void\> | 以Promise形式返回设置UDPSocket连接的其他属性的结果。 |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+let promise = udp.bind({address:'192.168.xx.xxx', port:xxxx, family:1});
+promise.then(() => {
+  console.log('bind success');
+  let promise1 = udp.setExtraOptions({
+	receiveBufferSize:1000,
+	sendBufferSize:1000,
+	reuseAddress:false,
+	socketTimeout:6000,
+	broadcast:true
+  });
+  promise1.then(() => {
+	console.log('setExtraOptions success');
+  }).catch(err => {
+	console.log('setExtraOptions fail');
+  });
+}).catch(err => {
+  console.log('bind fail');
+});
+```
+
+
+### on\('message'\)
+
+on\(type: 'message', callback: Callback<\{message: ArrayBuffer, remoteInfo: SocketRemoteInfo\}\>\): void
+
+订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型                                                         | 必填 | 说明                                      |
+| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- |
+| type     | string                                                       | 是   | 订阅的事件类型。'message'：接收消息事件。 |
+| callback | Callback<{message: ArrayBuffer, remoteInfo: [SocketRemoteInfo](#socketremoteinfo)}> | 是   | 回调函数。                                |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.on('message', value => {
+	console.log("on message, message:" + value.message) + ", remoteInfo:" + value.remoteInfo);
+});
+```
+
+
+### off\('message'\)
+
+off\(type: 'message', callback?: Callback<\{message: ArrayBuffer, remoteInfo: SocketRemoteInfo\}\>\): void
+
+取消订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型                                                         | 必填 | 说明                                      |
+| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- |
+| type     | string                                                       | 是   | 订阅的事件类型。'message'：接收消息事件。 |
+| callback | Callback<{message: ArrayBuffer, remoteInfo: [SocketRemoteInfo](#socketremoteinfo)}> | 否   | 回调函数。                                |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+let callback = value =>{
+	console.log("on message, message:" + value.message) + ", remoteInfo:" + value.remoteInfo);
+}
+udp.on('message', callback);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+udp.off('message', callback);
+udp.off('message');
+```
+
+
+### on\('listening' | 'close'\)
+
+on\(type: 'listening' | 'close', callback: Callback<void\>\): void
+
+订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型             | 必填 | 说明                                                         |
+| -------- | ---------------- | ---- | ------------------------------------------------------------ |
+| type     | string           | 是   | 订阅的事件类型。<br />- 'listening'：数据包消息事件。<br />- 'close'：关闭事件。 |
+| callback | Callback\<void\> | 是   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+udp.on('listening', () => {
+	console.log("on listening success"));
+});
+udp.on('close', () => {
+	console.log("on close success" );
+});
+```
+
+
+### off\('listening' | 'close'\)
+
+off\(type: 'listening' | 'close', callback?: Callback<void\>\): void
+
+取消订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型             | 必填 | 说明                                                         |
+| -------- | ---------------- | ---- | ------------------------------------------------------------ |
+| type     | string           | 是   | 订阅事件类型。<br />- 'listening'：数据包消息事件。<br />- 'close'：关闭事件。 |
+| callback | Callback\<void\> | 否   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance();
+let callback1 = () =>{
+	console.log("on listening, success");
+}
+udp.on('listening', callback1);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+udp.off('listening', callback1);
+udp.off('listening');
+let callback2 = () =>{
+	console.log("on close, success");
+}
+udp.on('close', callback2);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+udp.off('close', callback2);
+udp.off('close');
+```
+
+
+### on\('error'\)
+
+on\(type: 'error', callback: ErrorCallback\): void
+
+订阅UDPSocket连接的error事件。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型          | 必填 | 说明                                 |
+| -------- | ------------- | ---- | ------------------------------------ |
+| type     | string        | 是   | 订阅的事件类型。'error'：error事件。 |
+| callback | ErrorCallback | 是   | 回调函数。                           |
+
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance()
+udp.on('error', err => {
+	console.log("on error, err:" + JSON.stringify(err))
+});
+```
+
+
+### off\('error'\)
+
+off\(type: 'error', callback?: ErrorCallback\): void
+
+取消订阅UDPSocket连接的error事件。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型          | 必填 | 说明                                 |
+| -------- | ------------- | ---- | ------------------------------------ |
+| type     | string        | 是   | 订阅的事件类型。'error'：error事件。 |
+| callback | ErrorCallback | 否   | 回调函数。                           |
+
+**示例：**
+
+```
+let udp = socket.constructUDPSocketInstance()
+let callback = err =>{
+	console.log("on error, err:" + JSON.stringify(err));
+}
+udp.on('error', callback);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+udp.off('error', callback);
+udp.off('error');
+```
+
+
+## NetAddress
+
+目标地址信息。
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| address | string | 是   | 本地绑定的ip地址。                                           |
+| port    | number | 否   | 端口号 ，范围0~65535。如果不指定系统随机分配端口。           |
+| family  | number | 否   | 网络协议类型，可选类型：<br />- 1：IPv4<br />- 2：IPv6<br />默认为1。 |
+
+## UDPSendOptions
+
+UDPSocket发送参数。
+
+| 参数名  | 类型                               | 必填 | 说明           |
+| ------- | ---------------------------------- | ---- | -------------- |
+| data    | string                             | 是   | 发送的数据。   |
+| address | [NetAddress](#netaddress) | 是   | 目标地址信息。 |
+
+## UDPExtraOptions
+
+UDPSocket连接的其他属性。
+
+| 参数名            | 类型    | 必填 | 说明                             |
+| ----------------- | ------- | ---- | -------------------------------- |
+| broadcast         | boolean | 否   | 是否可以发送广播。默认为false。  |
+| receiveBufferSize | number  | 否   | 接收缓冲区大小（单位：Byte）。   |
+| sendBufferSize    | number  | 否   | 发送缓冲区大小（单位：Byte）。   |
+| reuseAddress      | boolean | 否   | 是否重用地址。默认为false。      |
+| socketTimeout     | number  | 否   | 套接字超时时间，单位毫秒（ms）。 |
+
+## SocketStateBase
+
+Socket的状态信息。
+
+| 参数名      | 类型    | 必填 | 说明       |
+| ----------- | ------- | ---- | ---------- |
+| isBound     | boolean | 是   | 是否绑定。 |
+| isClose     | boolean | 是   | 是否关闭。 |
+| isConnected | boolean | 是   | 是否连接。 |
+
+## SocketRemoteInfo
+
+Socket的连接信息。
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| address | string | 是   | 本地绑定的ip地址。                                           |
+| family  | string | 是   | 网络协议类型，可选类型：<br />- IPv4<br />- IPv6<br />默认为IPv4。 |
+| port    | number | 是   | 端口号，范围0~65535。                                        |
+| size    | number | 是   | 服务器响应信息的字节长度。                                   |
+
+## socket.constructTCPSocketInstance
+
+constructTCPSocketInstance\(\): TCPSocket
+
+创建一个TCPSocket对象。
+
+**返回值：**
+
+  | 类型                               | 说明                    |
+  | :--------------------------------- | :---------------------- |
+  | [TCPSocket](#tcpsocket) | 返回一个TCPSocket对象。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+```
+
+
+## TCPSocket
+
+TCPSocket连接。在调用TCPSocket的方法前，需要先通过[socket.constructTCPSocketInstance](#socketconstructtcpsocketinstance)创建TCPSocket对象。
+
+### bind
+
+bind\(address: NetAddress, callback: AsyncCallback<void\>\): void
+
+绑定IP地址和端口，端口可以指定或由系统随机分配。使用callback方法作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                               | 必填 | 说明                                                   |
+| -------- | ---------------------------------- | ---- | ------------------------------------------------------ |
+| address  | [NetAddress](#netaddress) | 是   | 目标地址信息，参考[NetAddress](#netaddress)。 |
+| callback | AsyncCallback\<void\>              | 是   | 回调函数。                                             |
+
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+tcp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1}, err => {
+  if (err) {
+	console.log('bind fail');
+	return;
+  }
+  console.log('bind success');
+})
+```
+
+
+### bind
+
+bind\(address NetAddress\): Promise<void\>
+
+绑定IP地址和端口，端口可以指定或由系统随机分配。使用Promise方法作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                               | 必填 | 说明                                                   |
+| ------- | ---------------------------------- | ---- | ------------------------------------------------------ |
+| address | [NetAddress](#netaddress) | 是   | 目标地址信息，参考[NetAddress](#netaddress)。 |
+
+**返回值：**
+
+| 类型            | 说明                                                     |
+| :-------------- | :------------------------------------------------------- |
+| Promise\<void\> | 以Promise形式返回TCPSocket绑定本机的IP地址和端口的结果。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.bind({address: '192.168.xx.xxx', port: xxxx, family: 1});
+promise.then(() => {
+  console.log('bind success');
+}).catch(err => {
+  console.log('bind fail');
+});
+```
+
+
+### connect
+
+connect\(options: TCPConnectOptions, callback: AsyncCallback<void\>\): void
+
+连接到指定的IP地址和端口。使用callback方法作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                     | 必填 | 说明                                                         |
+| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| options  | [TCPConnectOptions](#tcpconnectoptions) | 是   | TCPSocket连接的参数，参考[TCPConnectOptions](#tcpconnectoptions)。 |
+| callback | AsyncCallback\<void\>                    | 是   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000}, err => {
+  if (err) {
+	console.log('connect fail');
+	return;
+  }
+  console.log('connect success');
+})
+```
+
+
+### connect
+
+connect\(options: TCPConnectOptions\): Promise<void\>
+
+连接到指定的IP地址和端口。使用promise方法作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                                     | 必填 | 说明                                                         |
+| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| options | [TCPConnectOptions](#tcpconnectoptions) | 是   | TCPSocket连接的参数，参考[TCPConnectOptions](#tcpconnectoptions)。 |
+
+**返回值：**
+
+| 类型            | 说明                                                       |
+| :-------------- | :--------------------------------------------------------- |
+| Promise\<void\> | 以Promise形式返回TCPSocket连接到指定的IP地址和端口的结果。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success')
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### send
+
+send\(options: TCPSendOptions, callback: AsyncCallback<void\>\): void
+
+通过TCPSocket连接发送数据。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                    | 必填 | 说明                                                         |
+| -------- | --------------------------------------- | ---- | ------------------------------------------------------------ |
+| options  | [TCPSendOptions](#tcpsendoptions) | 是   | TCPSocket发送请求的参数，参考[TCPSendOptions](#tcpsendoptions)。 |
+| callback | AsyncCallback\<void\>                   | 是   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success');
+  tcp.send({
+	data:'Hello, server!'
+  },err => {
+	if (err) {
+	  console.log('send fail');
+	  return;
+	}
+	console.log('send success');
+  })
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### send
+
+send\(options: TCPSendOptions\): Promise<void\>
+
+通过TCPSocket连接发送数据。使用Promise方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                                    | 必填 | 说明                                                         |
+| ------- | --------------------------------------- | ---- | ------------------------------------------------------------ |
+| options | [TCPSendOptions](#tcpsendoptions) | 是   | TCPSocket发送请求的参数，参考[TCPSendOptions](#tcpsendoptions)。 |
+
+**返回值：**
+
+| 类型            | 说明                                               |
+| :-------------- | :------------------------------------------------- |
+| Promise\<void\> | 以Promise形式返回通过TCPSocket连接发送数据的结果。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise1 = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise1.then(() => {
+  console.log('connect success');
+  let promise2 = tcp.send({
+	data:'Hello, server!'
+  });
+  promise2.then(() => {
+	console.log('send success');
+  }).catch(err => {
+	console.log('send fail');
+  });
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### close
+
+close\(callback: AsyncCallback<void\>\): void
+
+关闭TCPSocket连接。使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明       |
+| -------- | --------------------- | ---- | ---------- |
+| callback | AsyncCallback\<void\> | 是   | 回调函数。 |
+
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+tcp.close(err => {
+  if (err) {
+	console.log('close fail');
+	return;
+  }
+  console.log('close success');
+})
+```
+
+
+### close
+
+close\(\): Promise<void\>
+
+关闭TCPSocket连接。使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**返回值：**
+
+| 类型            | 说明                                       |
+| :-------------- | :----------------------------------------- |
+| Promise\<void\> | 以Promise形式返回关闭TCPSocket连接的结果。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.close();
+promise.then(() => {
+  console.log('close success');
+}).catch(err => {
+  console.log('close fail');
+});
+```
+
+
+### getRemoteAddress
+
+getRemoteAddress\(callback: AsyncCallback<NetAddress\>\): void
+
+获取对端Socket地址。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                              | 必填 | 说明       |
+| -------- | ------------------------------------------------- | ---- | ---------- |
+| callback | AsyncCallback<[NetAddress](#netaddress)> | 是   | 回调函数。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success');
+  tcp.getRemoteAddress((err, data) => {
+	if (err) {
+	  console.log('getRemoteAddressfail');
+	  return;
+	}
+	console.log('getRemoteAddresssuccess:' + JSON.stringify(data));
+  })
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### getRemoteAddress
+
+getRemoteAddress\(\): Promise<NetAddress\>
+
+获取对端Socket地址。使用Promise方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**返回值：**
+
+| 类型                                        | 说明                                        |
+| :------------------------------------------ | :------------------------------------------ |
+| Promise<[NetAddress](#netaddress)> | 以Promise形式返回获取对端socket地址的结果。 |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise1 = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise1.then(() => {
+  console.log('connect success');
+  let promise2 = tcp.getRemoteAddress();
+  promise2.then(() => {
+	console.log('getRemoteAddress success:' + JSON.stringify(data));
+  }).catch(err => {
+	console.log('getRemoteAddressfail');
+  });
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### getState
+
+getState\(callback: AsyncCallback<SocketStateBase\>\): void
+
+获取TCPSocket状态。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)或[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                                   | 必填 | 说明       |
+| -------- | ------------------------------------------------------ | ---- | ---------- |
+| callback | AsyncCallback<[SocketStateBase](#socketstatebase)> | 是   | 回调函数。 |
+
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success');
+  tcp.getState((err, data) => {
+	if (err) {
+	  console.log('getState fail');
+	  return;
+	}
+	console.log('getState success:' + JSON.stringify(data));
+  });
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### getState
+
+getState\(\): Promise<SocketStateBase\>
+
+获取TCPSocket状态。使用Promise方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)或[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**返回值：**
+
+| 类型                                             | 说明                                       |
+| :----------------------------------------------- | :----------------------------------------- |
+| Promise<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取TCPSocket状态的结果。 |
+
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success');
+  let promise1 = tcp.getState();
+  promise1.then(() => {
+	console.log('getState success:' + JSON.stringify(data));
+  }).catch(err => {
+	console.log('getState fail');
+  });
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### setExtraOptions
+
+setExtraOptions\(options: TCPExtraOptions, callback: AsyncCallback<void\>\): void
+
+设置TCPSocket连接的其他属性。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)或[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                                      | 必填 | 说明                                                         |
+| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ |
+| options  | [TCPExtraOptions](#tcpextraoptions) | 是   | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 |
+| callback | AsyncCallback\<void\>                     | 是   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success');
+  tcp.setExtraOptions({
+	keepAlive: true,
+	OOBInline: true,
+	TCPNoDelay: true,
+	socketLinger: { on:true, linger:10 }
+	receiveBufferSize: 1000,
+	sendBufferSize: 1000,
+	reuseAddress: true,
+	socketTimeout: 3000,
+  },err => {
+	if (err) {
+	  console.log('setExtraOptions fail');
+	  return;
+	}
+	console.log('setExtraOptions success');
+  });
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### setExtraOptions
+
+setExtraOptions\(options: TCPExtraOptions\): Promise<void\>
+
+设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>[bind](#bind)或[connect](#connect)方法调用成功后，才可调用此方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                                      | 必填 | 说明                                                         |
+| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ |
+| options | [TCPExtraOptions](#tcpextraoptions) | 是   | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 |
+
+**返回值：**
+
+| 类型            | 说明                                                 |
+| :-------------- | :--------------------------------------------------- |
+| Promise\<void\> | 以Promise形式返回设置TCPSocket连接的其他属性的结果。 |
+
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let promise = tcp.connect({ address: {address: '192.168.xx.xxx', port: xxxx, family: 1} , timeout: 6000});
+promise.then(() => {
+  console.log('connect success');
+  let promise1 = tcp.setExtraOptions({
+	keepAlive: true,
+	OOBInline: true,
+	TCPNoDelay: true,
+	socketLinger: { on:true, linger:10 }
+	receiveBufferSize: 1000,
+	sendBufferSize: 1000,
+	reuseAddress: true,
+	socketTimeout: 3000,
+  });
+  promise1.then(() => {
+	console.log('setExtraOptions success');
+  }).catch(err => {
+	console.log('setExtraOptions fail');
+  });
+}).catch(err => {
+  console.log('connect fail');
+});
+```
+
+
+### on\('message'\)
+
+on\(type: 'message', callback: Callback<\{message: ArrayBuffer, remoteInfo: SocketRemoteInfo\}\>\): void
+
+订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型                                                         | 必填 | 说明                                      |
+| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- |
+| type     | string                                                       | 是   | 订阅的事件类型。'message'：接收消息事件。 |
+| callback | Callback<{message: ArrayBuffer, remoteInfo: [SocketRemoteInfo](#socketremoteinfo)}> | 是   | 回调函数。                                |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+tcp.on('message', value => {
+	console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo)
+});
+```
+
+
+### off\('message'\)
+
+off\(type: 'message', callback?: Callback<\{message: ArrayBuffer, remoteInfo: SocketRemoteInfo\}\>\): void
+
+取消订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型                                                         | 必填 | 说明                                      |
+| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- |
+| type     | string                                                       | 是   | 订阅的事件类型。'message'：接收消息事件。 |
+| callback | Callback<{message: ArrayBuffer, remoteInfo: [SocketRemoteInfo](#socketremoteinfo)}> | 否   | 回调函数。                                |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let callback = value =>{
+	console.log("on message, message:" + value.message + ", remoteInfo:" + value.remoteInfo);
+}
+tcp.on('message', callback);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+tcp.off('message', callback);
+tcp.off('message');
+```
+
+
+### on\('connect' | 'close'\)
+
+on\(type: 'connect' | 'close', callback: Callback<void\>\): void
+
+订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型             | 必填 | 说明                                                         |
+| -------- | ---------------- | ---- | ------------------------------------------------------------ |
+| type     | string           | 是   | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 |
+| callback | Callback\<void\> | 是   | 回调函数。                                                   |
+
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+tcp.on('connect', () => {
+	console.log("on connect success")
+});
+tcp.on('close', data => {
+	console.log("on close success")
+});
+```
+
+
+### off\('connect' | 'close'\)
+
+off\(type: 'connect' | 'close', callback: Callback<void\>\): void
+
+取消订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型             | 必填 | 说明                                                         |
+| -------- | ---------------- | ---- | ------------------------------------------------------------ |
+| type     | string           | 是   | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 |
+| callback | Callback\<void\> | 否   | 回调函数。                                                   |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let callback1 = () =>{
+	console.log("on connect success");
+}
+tcp.on('connect', callback1);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+tcp.off('connect', callback1);
+tcp.off('connect');
+let callback2 = () =>{
+	console.log("on close success");
+}
+tcp.on('close', callback2);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+tcp.off('close', callback2);
+tcp.off('close');
+```
+
+
+### on\('error'\)
+
+on\(type: 'error', callback: ErrorCallback\): void
+
+订阅TCPSocket连接的error事件。使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型          | 必填 | 说明                                 |
+| -------- | ------------- | ---- | ------------------------------------ |
+| type     | string        | 是   | 订阅的事件类型。'error'：error事件。 |
+| callback | ErrorCallback | 是   | 回调函数。                           |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+tcp.on('error', err => {
+	console.log("on error, err:" + JSON.stringify(err))
+});
+```
+
+
+### off\('error'\)
+
+off\(type: 'error', callback?: ErrorCallback\): void
+
+取消订阅TCPSocket连接的error事件。使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型          | 必填 | 说明                                 |
+| -------- | ------------- | ---- | ------------------------------------ |
+| type     | string        | 是   | 订阅的事件类型。'error'：error事件。 |
+| callback | ErrorCallback | 否   | 回调函数。                           |
+
+**示例：**
+
+```
+let tcp = socket.constructTCPSocketInstance();
+let callback = err =>{
+	console.log("on error, err:" + JSON.stringify(err));
+}
+tcp.on('error', callback);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+tcp.off('error', callback);
+tcp.off('error');
+```
+
+
+## TCPConnectOptions
+
+TCPSocket连接的参数。
+
+| 参数名  | 类型                               | 必填 | 说明                       |
+| ------- | ---------------------------------- | ---- | -------------------------- |
+| address | [NetAddress](#netaddress) | 是   | 绑定的地址以及端口。       |
+| timeout | number                             | 否   | 超时时间，单位毫秒（ms）。 |
+
+## TCPSendOptions
+
+TCPSocket发送请求的参数。
+
+| 参数名   | 类型   | 必填 | 说明                                                         |
+| -------- | ------ | ---- | ------------------------------------------------------------ |
+| data     | string | 是   | 发送的数据。                                                 |
+| encoding | string | 否   | 字符编码(UTF-8，UTF-16BE，UTF-16LE，UTF-16，US-AECII，ISO-8859-1)，默认为UTF-8。 |
+
+## TCPExtraOptions
+
+TCPSocket连接的其他属性。
+
+| 参数名            | 类型    | 必填 | 说明                                                         |
+| ----------------- | ------- | ---- | ------------------------------------------------------------ |
+| keepAlive         | boolean | 否   | 是否保持连接。默认为false。                                  |
+| OOBInline         | boolean | 否   | 是否为OOB内联。默认为false。                                 |
+| TCPNoDelay        | boolean | 否   | TCPSocket连接是否无时延。默认为false。                       |
+| socketLinger      | Object  | 是   | socket是否继续逗留。<br />- on：是否逗留（true：逗留；false：不逗留）。<br />- linger：逗留时长，单位毫秒（ms），取值范围为0~65535。<br />当入参on设置为true时，才需要设置。 |
+| receiveBufferSize | number  | 否   | 接收缓冲区大小（单位：Byte）。                               |
+| sendBufferSize    | number  | 否   | 发送缓冲区大小（单位：Byte）。                               |
+| reuseAddress      | boolean | 否   | 是否重用地址。默认为false。                                  |
+| socketTimeout     | number  | 否   | 套接字超时时间，单位毫秒（ms）。                             |
diff --git a/zh-cn/application-dev/reference/apis/js-apis-webSocket.md b/zh-cn/application-dev/reference/apis/js-apis-webSocket.md
new file mode 100644
index 0000000000000000000000000000000000000000..05d58dddb672a6481209807c4c519b3291951d73
--- /dev/null
+++ b/zh-cn/application-dev/reference/apis/js-apis-webSocket.md
@@ -0,0 +1,588 @@
+# WebSocket连接
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+>
+>当前暂时不支持WebSocket，预计在MR版本支持。
+
+使用WebSocket建立服务器与客户端的双向连接，需要先通过[createWebSocket](#websocketcreatewebsocket)方法创建[WebSocket](#websocket)对象，然后通过[connect](#connect)方法连接到服务器。当连接成功后，客户端会收到[open](#onopen)事件的回调，之后客户端就可以通过[send](#send)方法与服务器进行通信。当服务器发信息给客户端时，客户端会收到[message](#onmessage)事件的回调。当客户端不要此连接时，可以通过调用[close](#close)方法主动断开连接，之后客户端会收到[close](#onclose)事件的回调。
+
+若在上述任一过程中发生错误，客户端会收到[error](#onerror)事件的回调。
+
+
+## 导入模块
+
+```
+import webSocket from '@ohos.net.webSocket';
+```
+
+## 完整示例
+
+```
+import webSocket from '@ohos.net.webSocket';
+
+var defaultIpAddress = "ws://";
+let ws = webSocket.createWebSocket();
+ws.on('open', (err, value) => {
+    console.log("on open, status:" + value.status + ", message:" + value.message);
+    // 当收到on('open')事件时，可以通过send()方法与服务器进行通信
+    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) => {
+    console.log("on message, message:" + value);
+    // 当收到服务器的`bye`消息时（此消息字段仅为示意，具体字段需要与服务器协商），主动断开连接
+    if (value === 'bye') {
+        ws.close((err, value) => {
+            if (!err) {
+                console.log("close success");
+            } else {
+                console.log("close fail, err is " + JSON.stringify(err));
+            }
+        });
+    }
+});
+ws.on('close', (err, value) => {
+    console.log("on close, code is " + value.code + ", reason is " + value.reason);
+});
+ws.on('error', (err) => {
+    console.log("on error, error:" + JSON.stringify(err));
+});
+ws.connect(defaultIpAddress, (err, value) => {
+    if (!err) {
+        console.log("connect success");
+    } else {
+        console.log("connect fail, err:" + JSON.stringify(err));
+    }
+});
+```
+
+## webSocket.createWebSocket
+
+createWebSocket\(\): WebSocket
+
+创建一个WebSocket，里面包括建立连接、关闭连接、发送数据和订阅/取消订阅WebSocket连接的打开事件、接收到服务器消息事件、关闭事件和错误事件。
+
+**返回值：**
+
+| 类型                                | 说明                                                         |
+| :---------------------------------- | :----------------------------------------------------------- |
+| [WebSocket](#websocket) | 返回一个WebSocket对象，里面包括connect、send、close、on和off方法。 |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+```
+
+
+## WebSocket
+
+在调用WebSocket的方法前，需要先通过[webSocket.createWebSocket](#webSocketcreatewebsocket)创建一个WebSocket。
+
+### connect
+
+connect\(url: string, callback: AsyncCallback<boolean\>\): void
+
+根据URL地址，建立一个WebSocket连接，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                     | 必填 | 说明                         |
+| -------- | ------------------------ | ---- | ---------------------------- |
+| url      | string                   | 是   | 建立WebSocket连接的URL地址。 |
+| callback | AsyncCallback\<boolean\> | 是   | 回调函数。                   |
+
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+ws.connect(url, (err, value) => {
+	if (!err) {
+		console.log("connect success");
+	} else {
+		console.log("connect fail, err:" + JSON.stringify(err))
+	}
+});
+```
+
+
+### connect
+
+connect\(url: string, options: WebSocketRequestOptions, callback: AsyncCallback<boolean\>\): void
+
+根据URL地址和header，建立一个WebSocket连接，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                     | 必填 | 说明                                                    |
+| -------- | ------------------------ | ---- | ------------------------------------------------------- |
+| url      | string                   | 是   | 建立WebSocket连接的URL地址。                            |
+| options  | WebSocketRequestOptions  | 是   | 参考[WebSocketRequestOptions](#websocketrequestoptions)。 |
+| callback | AsyncCallback\<boolean\> | 是   | 回调函数。                                              |
+
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+ws.connect(url, {
+	header: {
+		"key": "value",
+		"key2": "value2"
+	}
+}, (err, value) => {
+	if (!err) {
+		console.log("connect success");
+	} else {
+		console.log("connect fail, err:" + JSON.stringify(err))
+	}
+});
+```
+
+
+### connect
+
+connect\(url: string, options?: WebSocketRequestOptions\): Promise<boolean\>
+
+根据URL地址和header，建立一个WebSocket连接，使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                    | 必填 | 说明                                                    |
+| ------- | ----------------------- | ---- | ------------------------------------------------------- |
+| url     | string                  | 是   | 建立WebSocket连接的URL地址。                            |
+| options | WebSocketRequestOptions | 否   | 参考[WebSocketRequestOptions](#websocketrequestoptions)。 |
+
+**返回值：**
+
+| 类型               | 说明                              |
+| :----------------- | :-------------------------------- |
+| Promise\<boolean\> | 以Promise形式返回建立连接的结果。 |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+let promise = ws.connect(url);
+promise.then((value) => {
+	console.log("connect success")
+}).catch((err) => {
+	console.log("connect fail, error:" + JSON.stringify(err))
+});
+```
+
+
+### send
+
+send\(data: string | ArrayBuffer, callback: AsyncCallback<boolean\>\): void
+
+通过WebSocket连接发送数据，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                     | 必填 | 说明         |
+| -------- | ------------------------ | ---- | ------------ |
+| data     | string \| ArrayBuffer <sup>8+</sup> | 是   | 发送的数据。 |
+| callback | AsyncCallback\<boolean\> | 是   | 回调函数。   |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+ws.connect(url, (err, value) => {
+	ws.send("Hello, server!", (err, value) => {
+		if (!err) {
+			console.log("send success");
+		} else {
+			console.log("send fail, err:" + JSON.stringify(err))
+		}
+	});
+});
+```
+
+
+### send
+
+send\(data: string | ArrayBuffer\): Promise<boolean\>
+
+通过WebSocket连接发送数据，使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名 | 类型   | 必填 | 说明         |
+| ------ | ------ | ---- | ------------ |
+| data     | string \| ArrayBuffer <sup>8+</sup> | 是   | 发送的数据。 |
+
+**返回值：**
+
+| 类型               | 说明                              |
+| :----------------- | :-------------------------------- |
+| Promise\<boolean\> | 以Promise形式返回发送数据的结果。 |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+ws.connect(url, (err, value) => {
+	let promise = ws.send("Hello, server!");
+	promise.then((value) => {
+		console.log("send success")
+	}).catch((err) => {
+		console.log("send fail, error:" + JSON.stringify(err))
+	});
+});
+```
+
+
+### close
+
+close\(callback: AsyncCallback<boolean\>\): void
+
+关闭WebSocket连接，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                     | 必填 | 说明       |
+| -------- | ------------------------ | ---- | ---------- |
+| callback | AsyncCallback\<boolean\> | 是   | 回调函数。 |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+ws.close((err, value) => {
+	if (!err) {
+		console.log("close success")
+	} else {
+		console.log("close fail, err is " + JSON.stringify(err))
+	}
+});
+```
+
+
+### close
+
+close\(options: WebSocketCloseOptions, callback: AsyncCallback<boolean\>\): void
+
+根据可选参数code和reason，关闭WebSocket连接，使用callback方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名   | 类型                     | 必填 | 说明                                                  |
+| -------- | ------------------------ | ---- | ----------------------------------------------------- |
+| options  | WebSocketCloseOptions    | 是   | 参考[WebSocketCloseOptions](#websocketcloseoptions)。 |
+| callback | AsyncCallback\<boolean\> | 是   | 回调函数。                                            |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+ws.close({
+	code: 1000,
+	reason: "your reason"
+}, (err, value) => {
+	if (!err) {
+		console.log("close success")
+	} else {
+		console.log("close fail, err is " + JSON.stringify(err))
+	}
+});
+```
+
+
+### close
+
+close\(options?: WebSocketCloseOptions\): Promise<boolean\>
+
+根据可选参数code和reason，关闭WebSocket连接，使用Promise方式作为异步方法。
+
+**需要权限**：ohos.permission.INTERNET
+
+**参数：**
+
+| 参数名  | 类型                  | 必填 | 说明                                                  |
+| ------- | --------------------- | ---- | ----------------------------------------------------- |
+| options | WebSocketCloseOptions | 否   | 参考[WebSocketCloseOptions](#websocketcloseoptions)。 |
+
+**返回值：**
+
+| 类型               | 说明                              |
+| :----------------- | :-------------------------------- |
+| Promise\<boolean\> | 以Promise形式返回关闭连接的结果。 |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let url = "ws://"
+let promise = ws.close({
+	code: 1000,
+	reason: "your reason"
+});
+promise.then((value) => {
+	console.log("close success")
+}).catch((err) => {
+	console.log("close fail, err is " + JSON.stringify(err))
+});
+```
+
+
+### on\('open'\)
+
+on\(type: 'open', callback: AsyncCallback<Object\>\): void
+
+订阅WebSocket的打开事件，使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型                    | 必填 | 说明                          |
+| -------- | ----------------------- | ---- | ----------------------------- |
+| type     | string                  | 是   | 'open'：WebSocket的打开事件。 |
+| callback | AsyncCallback\<Object\> | 是   | 回调函数。                    |
+
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.on('open', (err, value) => {
+	console.log("on open, status:" + value.status + ", message:" + value.message);
+});
+```
+
+
+### off\('open'\)
+
+off\(type: 'open', callback?: AsyncCallback<Object\>\): void
+
+取消订阅WebSocket的打开事件，使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型                    | 必填 | 说明                          |
+| -------- | ----------------------- | ---- | ----------------------------- |
+| type     | string                  | 是   | 'open'：WebSocket的打开事件。 |
+| callback | AsyncCallback\<Object\> | 否   | 回调函数。                    |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+let callback1 = (err, value) => {
+	console.log("on open, status:" + value.status + ", message:" + value.message);
+}
+ws.on('open', callback1);
+// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅
+ws.off('open', callback1);
+```
+
+
+### on\('message'\)
+
+on\(type: 'message', callback: AsyncCallback<string | ArrayBuffer\>\): void
+
+订阅WebSocket的接收到服务器消息事件，使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>AsyncCallback中的数据可以是字符串\(API 6\)或ArrayBuffer\(API 8\)。
+
+**参数：**
+
+| 参数名   | 类型                    | 必填 | 说明                                         |
+| -------- | ----------------------- | ---- | -------------------------------------------- |
+| type     | string                  | 是   | 'message'：WebSocket的接收到服务器消息事件。 |
+| callback | AsyncCallback\<string \| ArrayBuffer <sup>8+</sup>\> | 是   | 回调函数。                                   |
+
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.on('message', (err, value) => {
+	console.log("on message, message:" + value);
+});
+```
+
+
+### off\('message'\)
+
+off\(type: 'message', callback?: AsyncCallback<string | ArrayBuffer\>\): void
+
+取消订阅WebSocket的接收到服务器消息事件，使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>AsyncCallback中的数据可以是字符串\(API 6\)或ArrayBuffer\(API 8\)。
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型                                                | 必填 | 说明                                         |
+| -------- | --------------------------------------------------- | ---- | -------------------------------------------- |
+| type     | string                                              | 是   | 'message'：WebSocket的接收到服务器消息事件。 |
+| callback | AsyncCallback\<string \|ArrayBuffer <sup>8+</sup>\> | 否   | 回调函数。                                   |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.off('message');
+```
+
+
+### on\('close'\)
+
+on\(type: 'close', callback: AsyncCallback<\{ code: number, reason: string \}\>\): void
+
+订阅WebSocket的关闭事件，使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型                                            | 必填 | 说明                           |
+| -------- | ----------------------------------------------- | ---- | ------------------------------ |
+| type     | string                                          | 是   | 'close'：WebSocket的关闭事件。 |
+| callback | AsyncCallback<{ code: number, reason: string }> | 是   | 回调函数。                     |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.on('close', (err, value) => {
+	console.log("on close, code is " + value.code + ", reason is " + value.reason);
+});
+```
+
+
+### off\('close'\)
+
+off\(type: 'close', callback?: AsyncCallback<\{ code: number, reason: string \}\>\): void
+
+取消订阅WebSocket的关闭事件，使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型                                            | 必填 | 说明                           |
+| -------- | ----------------------------------------------- | ---- | ------------------------------ |
+| type     | string                                          | 是   | 'close'：WebSocket的关闭事件。 |
+| callback | AsyncCallback<{ code: number, reason: string }> | 否   | 回调函数。                     |
+
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.off('close');
+```
+
+
+### on\('error'\)
+
+on\(type: 'error', callback: ErrorCallback\): void
+
+订阅WebSocket的Error事件，使用callback方式作为异步方法。
+
+**参数：**
+
+| 参数名   | 类型          | 必填 | 说明                            |
+| -------- | ------------- | ---- | ------------------------------- |
+| type     | string        | 是   | 'error'：WebSocket的Error事件。 |
+| callback | ErrorCallback | 是   | 回调函数。                      |
+
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.on('error', (err) => {
+	console.log("on error, error:" + JSON.stringify(err))
+});
+```
+
+
+### off\('error'\)
+
+off\(type: 'error', callback?: ErrorCallback\): void
+
+取消订阅WebSocket的Error事件，使用callback方式作为异步方法。
+
+>![](public_sys-resources/icon-note.gif) **说明：** 
+>可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。
+
+**参数：**
+
+| 参数名   | 类型          | 必填 | 说明                            |
+| -------- | ------------- | ---- | ------------------------------- |
+| type     | string        | 是   | 'error'：WebSocket的Error事件。 |
+| callback | ErrorCallback | 否   | 回调函数。                      |
+
+**示例：**
+
+```
+let ws = webSocket.createWebSocket();
+ws.off('error');
+```
+
+
+## WebSocketRequestOptions
+
+建立WebSocket连接时，可选参数的类型和说明。
+
+| 参数名 | 类型   | 必填 | 说明                                                         |
+| ------ | ------ | ---- | ------------------------------------------------------------ |
+| header | Object | 否   | 建立WebSocket连接可选参数，代表建立连接时携带的HTTP头信息。参数内容自定义，也可以不指定。 |
+
+
+## WebSocketCloseOptions
+
+关闭WebSocket连接时，可选参数的类型和说明。
+
+| 参数名 | 类型   | 必填 | 说明                                                         |
+| ------ | ------ | ---- | ------------------------------------------------------------ |
+| code   | number | 否   | 错误码，关闭WebSocket连接时的可选参数，可根据实际情况来填。默认值为1000。 |
+| reason | string | 否   | 原因值，关闭WebSocket连接时的可选参数，可根据实际情况来填。默认值为空字符串（""）。 |
+
+## close错误码说明
+
+发送给服务端的错误码可以自行定义，下面的列表仅供参考。
+
+| 值        | 说明               |
+| :-------- | :----------------- |
+| 1000      | 正常关闭           |
+| 1001      | 服务器主动关闭     |
+| 1002      | 协议错误           |
+| 1003      | 无法处理的数据类型 |
+| 1004~1015 | 保留值             |
+