Description: add doc

Signed-off-by: Nzhanghaifeng <zhanghaifeng11@huawei.com>

zh-cn/application-dev/connectivity/Readme-CN.md

@@ -5,6 +5,10 @@
   - [HTTP数据请求](http-request.md)
   - [WebSocket连接](websocket-connection.md)
   - [Socket连接](socket-connection.md)
+  - [策略管理](net-policy-management.md)
+  - [网络共享](net-sharing.md)
+  - [以太网连接](net-ethernet.md)
+  - [网络连接管理](net-connection-manager.md)
 - IPC与RPC通信
   - [IPC与RPC通信概述](ipc-rpc-overview.md)
   - [IPC与RPC通信开发指导](ipc-rpc-development-guideline.md)

zh-cn/application-dev/connectivity/net-connection-manager.md

+# 网络连接管理
+
+## 简介
+网络连接管理提供管理网络一些基础能力，包括WiFi/蜂窝/Ethernet等多网络连接优先级管理、网络质量评估、订阅默认/指定网络连接状态变化、查询网络连接信息、DNS解析等功能。
+
+> **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+## 基本概念
+-  网络生产者：数据网络的提供方，比如WiFi、蜂窝、Ethernet等。
+-  网络消费者：数据网络的使用方，比如应用或系统服务。
+-  网络探测：检测网络有效性，避免将网络从可用网络切换到不可用网络。内容包括绑定网络探测、DNS探测、HTTP探测及HTTPS探测。
+-  网络优选：处理多网络共存时选择最优网络。在网络状态、网络信息及评分发生变化时被触发。
+
+## 约束
+-   开发语言：C++ JS
+-   系统：linux内核
+
+## 场景介绍
+网络连接管理的典型场景有：
+-   接收指定网络的状态变化通知
+-   获取所有注册的网络
+-   根据数据网络查询网络的连接信息
+-   使用对应网络解析域名，获取所有IP
+
+以下分别介绍具体开发方式。
+## 接口说明
+完整的JS API说明以及实例代码请参考：[网络连接管理](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-net-connection.md)。
+
+| 类型 | 接口 | 功能说明 |
+| ---- | ---- | ---- |
+| ohos.net.connection | function getDefaultNet(callback: AsyncCallback\<NetHandle>): void; |获取一个含有默认网络的netId的NetHandle对象，使用callback回调 |
+| ohos.net.connection | function getDefaultNet(): Promise\<NetHandle>; |获取一个含有默认网络的netId的NetHandle对象，使用Promise回调 |
+| ohos.net.connection | function getGlobalHttpProxy<sup>10+</sup>(callback: AsyncCallback\<HttpProxy>): void;| 获取网络的全局代理设置，使用callback回调 |
+| ohos.net.connection | function getGlobalHttpProxy<sup>10+</sup>(): Promise\<HttpProxy>;| 获取网络的全局代理设置，使用Promise回调 |
+| ohos.net.connection | function setGlobalHttpProxy<sup>10+</sup>(httpProxy: HttpProxy, callback: AsyncCallback<void>): void;| 设置网络全局Http代理配置信息，使用callback回调 |
+| ohos.net.connection | function setGlobalHttpProxy<sup>10+</sup>(httpProxy: HttpProxy): Promise<void>;| 设置网络全局Http代理配置信息，使用Promise回调 |
+| ohos.net.connection | function getAppNet<sup>9+</sup>(callback: AsyncCallback\<NetHandle>): void;| 获取一个App绑定的包含了网络netId的NetHandle对象，使用callback回调 |
+| ohos.net.connection | function getAppNet<sup>9+</sup>(): Promise\<NetHandle>;| 获取一个App绑定的包含了网络netId的NetHandle对象，使用Promise回调 |
+| ohos.net.connection | function setAppNet<sup>9+</sup>(netHandle: NetHandle, callback: AsyncCallback\<void>): void;| 绑定App到指定网络，绑定后的App只能通过指定网络访问外网。使用callback回调 |
+| ohos.net.connection | function setAppNet<sup>9+</sup>(netHandle: NetHandle): Promise\<void>;| 绑定App到指定网络，绑定后的App只能通过指定网络访问外网。使用Promise回调 |
+| ohos.net.connection | function getDefaultNetSync<sup>9+</sup>(): NetHandle; |使用同步方法获取默认激活的数据网络。可以使用getNetCapabilities去获取网络的类型、拥有的能力等信息。|
+| ohos.net.connection | function hasDefaultNet(callback: AsyncCallback\<boolean>): void; |查询是否有默认网络，使用callback回调 |
+| ohos.net.connection | function hasDefaultNet(): Promise\<boolean>; |查询是否有默认网络，使用Promise回调 |
+| ohos.net.connection | function getAllNets(callback: AsyncCallback\<Array\<NetHandle>>): void;| 获取所处于连接状态的网络的MetHandle对象列表，使用callback回调 |
+| ohos.net.connection | function getAllNets(): Promise\<Array\<NetHandle>>;| 获取所有处于连接状态的网络的NetHandle对象列表，使用Promise回调 |
+| ohos.net.connection | function getConnectionProperties(netHandle: NetHandle, callback: AsyncCallback\<ConnectionProperties>): void; |查询默认网络的链路信息，使用callback回调 |
+| ohos.net.connection | function getConnectionProperties(netHandle: NetHandle): Promise\<ConnectionProperties>; |查询默认网络的链路信息，使用Promise回调 |
+| ohos.net.connection | function getNetCapabilities(netHandle: NetHandle, callback: AsyncCallback\<NetCapabilities>): void; |查询默认网络的能力集信息，使用callback回调 |
+| ohos.net.connection | function getNetCapabilities(netHandle: NetHandle): Promise\<NetCapabilities>; |查询默认网络的能力集信息，使用Promise回调 |
+| ohos.net.connection | function isDefaultNetMetered<sup>9+</sup>(callback: AsyncCallback<boolean>): void; |检查当前网络上的数据流量使用是否被计量，使用callback方式作为异步方法 |
+| ohos.net.connection | function isDefaultNetMetered<sup>9+</sup>(): Promise<boolean>; |检查当前网络上的数据流量使用是否被计量，使用Promise方式作为异步方法 |
+| ohos.net.connection | function reportNetConnected(netHandle: NetHandle, callback: AsyncCallback\<void>): void;| 向网络管理报告网络处于可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。使用callback回调 |
+| ohos.net.connection | function reportNetConnected(netHandle: NetHandle): Promise\<void>;| 向网络管理报告网络处于可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。使用Promise回调 |
+| ohos.net.connection | function reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback\<void>): void;| 向网络管理报告网络处于不可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。使用callback回调 |
+| ohos.net.connection | function reportNetDisconnected(netHandle: NetHandle): Promise\<void>;| 向网络管理报告网络处于不可用状态，调用此接口说明应用程序认为网络的可用性（ohos.net.connection.NetCap.NET_CAPABILITY_VAILDATED）与网络管理不一致。使用Promise回调 |
+| ohos.net.connection | function getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>): void; |使用对应网络解析域名，获取所有IP，使用callback回调 |
+| ohos.net.connection | function getAddressesByName(host: string): Promise\<Array\<NetAddress>>; |使用默认网络解析域名，获取所有IP，使用Promise回调 |
+| ohos.net.connection | function enableAirplaneMode(callback: AsyncCallback\<void>): void; | 设置网络为飞行模式，使用callback回调 |
+| ohos.net.connection | function enableAirplaneMode(): Promise\<void>;|设置网络为飞行模式，使用Promise回调 |
+| ohos.net.connection | function disableAirplaneMode(callback: AsyncCallback\<void>): void;| 关闭网络飞行模式，使用callback回调 |
+| ohos.net.connection | function disableAirplaneMode(): Promise\<void>;| 关闭网络飞行模式，使用Promise回调 |
+| ohos.net.connection | function createNetConnection(netSpecifier?: NetSpecifier, timeout?: number): NetConnection; | 返回一个NetConnection对象，netSpecifier指定关注的网络的各项特征，timeout是超时时间(单位是毫秒)，netSpecifier是timeout的必要条件，两者都没有则表示关注默认网络 |
+| ohos.net.connection.NetHandle | bindSocket(socketParam: TCPSocket \| UDPSocket, callback: AsyncCallback\<void>): void; | 将TCPSocket或UDPSockett绑定到当前网络，使用callback回调 |
+| ohos.net.connection.NetHandle | bindSocket(socketParam: TCPSocket \| UDPSocket): Promise\<void>;| 将TCPSocket或UDPSockett绑定到当前网络，使用Promise回调 |
+| ohos.net.connection.NetHandle | getAddressesByName(host: string, callback: AsyncCallback\<Array\<NetAddress>>): void; |使用默认网络解析域名，获取所有IP，使用callback回调 |
+| ohos.net.connection.NetHandle | getAddressesByName(host: string): Promise\<Array\<NetAddress>>; |使用对应网络解析域名，获取所有IP，使用Promise回调 |
+| ohos.net.connection.NetHandle | getAddressByName(host: string, callback: AsyncCallback\<NetAddress>): void; |使用对应网络解析域名，获取一个IP，调用callbac |
+| ohos.net.connection.NetHandle | getAddressByName(host: string): Promise\<NetAddress>; |使用对应网络解析域名，获取一个IP，使用Promise回调 |
+| ohos.net.connection.NetConnection | on(type: 'netAvailable', callback: Callback\<NetHandle>): void; |监听收到网络可用的事件 |
+| ohos.net.connection.NetConnection | on(type: 'netCapabilitiesChange', callback: Callback\<{ netHandle: NetHandle, netCap: NetCapabilities }>): void; |监听网络能力变化的事件 |
+| ohos.net.connection.NetConnection | on(type: 'netConnectionPropertiesChange', callback: Callback\<{ netHandle: NetHandle, connectionProperties: ConnectionProperties }>): void; |监听网络连接信息变化的事件 |
+| ohos.net.connection.NetConnection | on(type: 'netBlockStatusChange', callback: Callback<{ netHandle: NetHandle, blocked: boolean }>): void; |订阅网络阻塞状态事件，使用callback方式作为异步方法 |
+| ohos.net.connection.NetConnection | on(type: 'netLost', callback: Callback\<NetHandle>): void; |监听网络丢失的事件 |
+| ohos.net.connection.NetConnection | on(type: 'netUnavailable', callback: Callback\<void>): void; |监听网络不可用的事件 |
+| ohos.net.connection.NetConnection | register(callback: AsyncCallback\<void>): void; |注册默认网络或者createNetConnection中指定的网络的监听 |
+| ohos.net.connection.NetConnection | unregister(callback: AsyncCallback\<void>): void; |注销默认网络或者createNetConnection中指定的网络的监听 |
+
+## 接收指定网络的状态变化通知
+
+### 开发步骤
+
+1. 从@ohos.net.connection.d.ts中导入connection命名空间。
+
+2. 调用createNetConnection方法，指定网络能力、网络类型和超时时间（可选，如不传入代表默认网络；创建不同于默认网络时可通过指定这些参数完成），创建一个NetConnection对象。
+
+3. 调用该对象的on()方法，传入type和callback，订阅关心的事件。
+
+4. 调用该对象的register()方法，订阅指定网络状态变化的通知。
+
+5. 当网络可用时，会收到netAvailable事件的回调；当网络不可用时，会收到netUnavailable事件的回调。
+
+6. 当不使用该网络时，可以调用该对象的unregister()方法，取消订阅。
+
+```js
+   // 引入包名
+   import connection from '@ohos.net.connection'
+
+   let netCap = {
+       // 假设当前默认网络是WiFi，需要创建蜂窝网络连接，可指定网络类型为蜂窝网
+       bearerTypes: [connection.NetBearType.BEARER_CELLULAR],
+       // 指定网络能力为Internet
+       networkCap: [connection.NetCap.NET_CAPABILITY_INTERNET],
+   };
+   let netSpec = {
+       netCapabilities: netCap,
+   };
+
+   // 指定超时时间为10s(默认值为0)
+   let timeout = 10 * 1000;
+
+   // 创建NetConnection对象
+   let conn = connection.createNetConnection(netSpec, timeout);
+
+   // 订阅事件，如果当前指定网络可用，通过on_netAvailable通知用户
+   conn.on('netAvailable', (data=> {
+       console.log("net is available, netId is " + data.netId);
+   }));
+
+   // 订阅事件，如果当前指定网络不可用，通过on_netUnavailable通知用户
+   conn.on('netUnavailable', (data=> {
+       console.log("net is unavailable, netId is " + data.netId);
+   }));
+
+   // 订阅指定网络状态变化的通知
+   conn.register((err, data) => {});
+
+   // 当不使用该网络时，可以调用该对象的unregister()方法，取消订阅
+   conn.unregister((err, data) => {});
+```
+
+##  获取所有注册的网络
+
+###  开发步骤
+
+1. 从@ohos.net.connection.d.ts中导入connection命名空间。
+
+2. 调用getAllNets方法，获取所有处于连接状态的网络列表。
+
+```js
+   // 引入包名
+   import connection from '@ohos.net.connection'
+
+   // 获取所有处于连接状态的网络列表
+   connection.getAllNets((err, data) => {
+       console.log(JSON.stringify(err));
+       console.log(JSON.stringify(data));
+       if (data) {
+           this.netList = data;
+       }
+   })
+```
+
+##  根据数据网络查询网络的能力信息及连接信息
+
+###  开发步骤
+
+1. 从@ohos.net.connection.d.ts中导入connection命名空间。
+
+2. 通过调用getDefaultNet方法，获取默认的数据网络(NetHandle)；或者通过调用getAllNets方法，获取所有处于连接状态的网络列表(Array\<NetHandle>)。
+
+3. 调用getNetCapabilities方法，获取NetHandle对应网络的能力信息。能力信息包含了网络类型(蜂窝网络、Wi-Fi网络、以太网网络等)、网络具体能力等网络信息。
+
+4. 调用getConnectionProperties方法，获取NetHandle对应网络的连接信息。
+
+```js
+   // 引入包名
+   import connection from '@ohos.net.connection'
+
+   // 调用getDefaultNet方法，获取默认的数据网络(NetHandle)
+   connection.getDefaultNet((err, data) => {
+       console.log(JSON.stringify(err));
+       console.log(JSON.stringify(data));
+       if (data) {
+           this.netHandle = data;
+       }
+   })
+
+   // 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息
+   connection.getNetCapabilities(this.netHandle, (err, data) => {
+       console.log(JSON.stringify(err));
+
+       // 获取网络类型(bearerTypes)
+       for (let item of data.bearerTypes) {
+           if (item == 0) {
+               // 蜂窝网
+               console.log(JSON.stringify("BEARER_CELLULAR"));
+           } else if (item == 1) {
+               // Wi-Fi网络
+               console.log(JSON.stringify("BEARER_WIFI"));
+           } else if (item == 3) {
+              // 以太网网络
+               console.log(JSON.stringify("BEARER_ETHERNET"));
+           }
+       }
+
+       // 获取网络具体能力(networkCap)
+       for (let item of data.networkCap) {
+           if (item == 0) {
+               // 表示网络可以访问运营商的MMSC（Multimedia Message Service，多媒体短信服务）发送和接收彩信
+               console.log(JSON.stringify("NET_CAPABILITY_MMS"));
+           } else if (item == 11) {
+               // 表示网络流量未被计费
+               console.log(JSON.stringify("NET_CAPABILITY_NOT_METERED"));
+           } else if (item == 12) {
+               // 表示该网络应具有访问Internet的能力，该能力由网络提供者设置
+               console.log(JSON.stringify("NET_CAPABILITY_INTERNET"));
+           } else if (item == 15) {
+               // 表示网络不使用VPN（Virtual Private Network，虚拟专用网络）
+               console.log(JSON.stringify("NET_CAPABILITY_NOT_VPN"));
+           } else if (item == 16) {
+               // 表示该网络访问Internet的能力被网络管理成功验证，该能力由网络管理模块设置
+               console.log(JSON.stringify("NET_CAPABILITY_VALIDATED"));
+           }
+       }
+   })
+
+   // 获取netHandle对应网络的连接信息。连接信息包含了链路信息、路由信息等
+   connection.getConnectionProperties(this.netHandle, (err, data) => {
+       console.log(JSON.stringify(err));
+       console.log(JSON.stringify(data));
+   })
+
+    // 调用getAllNets,获取所有处于连接状态的网络列表(Array<NetHandle>)
+   connection.getAllNets((err, data) => {
+       console.log(JSON.stringify(err));
+       console.log(JSON.stringify(data));
+       if (data) {
+           this.netList = data;
+       }
+   })
+
+   for (let item of this.netList) {
+      // 循环获取网络列表每个netHandle对应网络的能力信息
+       connection.getNetCapabilities(item, (err, data) => {
+           console.log(JSON.stringify(err));
+           console.log(JSON.stringify(data));
+       })
+
+        // 循环获取网络列表每个netHandle对应的网络的连接信息
+       connection.getConnectionProperties(item, (err, data) => {
+           console.log(JSON.stringify(err));
+           console.log(JSON.stringify(data));
+       })
+   }
+```
+
+##  使用对应网络解析域名，获取所有IP
+
+###  开发步骤
+
+1. 从@ohos.net.connection.d.ts中导入connection命名空间。
+
+2. 调用getAddressesByName方法，使用默认网络解析主机名以获取所有IP地址。
+
+```js
+    // 引入包名
+   import connection from '@ohos.net.connection'
+
+   // 使用默认网络解析主机名以获取所有IP地址
+   connection.getAddressesByName(this.host, (err, data) => {
+        console.log(JSON.stringify(err));
+        console.log(JSON.stringify(data));
+    })
+```

zh-cn/application-dev/connectivity/net-ethernet.md

+# 以太网连接
+
+## 简介
+以太网连接的功能是提供支持设备通过硬件接口，以插入网线的形式访问互联网的能力。
+设备接入网线后，可以获取动态分配的IP地址，xxx等一系列网络属性；也可以通过静态模式，手动配置与获取设备的网络属性。
+
+> **说明：**
+> 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+## 约束
+-   开发语言：C++ JS
+-   系统：linux内核
+
+## 场景介绍
+以太网连接的典型场景有：
+-   DHCP模式，通过动态分配IP地址，子网掩码，Gateway，DNS等一系列网络属性，使能访问网络。
+-   静态模式，通过静态配置IP地址，子网掩码，Gateway，DNS等一系列网络属性，使能访问网络。
+
+以下分别介绍具体开发方式。
+
+## 接口说明
+完整的JS API说明以及实例代码请参考：[以太网连接](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-net-ethernet.md)。
+
+| 类型 | 接口 | 功能说明 |
+| ---- | ---- | ---- |
+| ohos.net.ethernet | function setIfaceConfig(iface: string, ic: InterfaceConfiguration, callback: AsyncCallback\<void>): void | 配置指定以太网的网络属性，iface为网口名称，ic为配置信息，调用callback |
+| ohos.net.ethernet | function setIfaceConfig(iface: string, ic: InterfaceConfiguration): Promise\<boolean>; | 配置指定以太网的网络属性，iface为网口名称，ic为配置信息，返回promise |
+| ohos.net.ethernet | function getIfaceConfig(iface: string, callback: AsyncCallback\<InterfaceConfiguration>): void | 获取指定以太网的网络属性，iface为网口名称，调用callback |
+| ohos.net.ethernet | function getIfaceConfig(iface: string): Promise\<InterfaceConfiguration>; | 获取指定以太网的网络属性，iface为网口名称，返回promise |
+| ohos.net.ethernet | function isIfaceActive(iface: string, callback: AsyncCallback\<number>): void | 判断指定网口是否已激活，iface为网卡名称（无参为是否有激活网口），调用callback |
+| ohos.net.ethernet | function isIfaceActive(iface: string): Promise\<number>; | 判断指定网口是否已激活，iface为网卡名称（无参为是否有激活网口），返回promise |
+| ohos.net.ethernet | function getAllActiveIfaces(callback: AsyncCallback\<Array\<string>>): void; | 获取所有活动的网络接口，调用callback |
+| ohos.net.ethernet | function getAllActiveIfaces(): Promise\<Array\<string>>; | 获取所有活动的网络接口，返回promise |
+
+## 以太网连接-DHCP模式
+
+### 开发步骤
+
+1. 设备通过硬件接口，插入网线。
+2. 从@ohos.net.ethernet中导入ethernet命名空间。
+3. 调用getAllActiveIfaces方法，获取所有激活的有线网卡名称，如：“eth0”，“eth1”。
+4. 用户态通过isIfaceActive方法，来判断网口“eth0”是否已激活。
+5. 用户态通过getIfaceConfig方法，来获取指定网口“eth0”的网络属性，未设置过的以太网络默认为DHCP模式，获取自动分配的网络属性。
+
+```js
+   // 从@ohos.net.ethernet中导入ethernet命名空间
+   import ethernet from '@ohos.net.ethernet'
+
+   // getAllActiveIfaces获取所有活动的网络设备名称
+   ethernet.getAllActiveIfaces((error, data) => {
+       if (error) {
+           console.log("getAllActiveIfaces callback error = " + error);
+       } else {
+           console.log("getAllActiveIfaces callback data.length = " + data.length);
+           for (let i = 0; i < data.length; i++) {
+               console.log("getAllActiveIfaces callback = " + data[i]);
+           }
+       }
+   });
+
+   // isIfaceActive判断指定网口是否已激活
+   ethernet.isIfaceActive("eth0", (error, data) => {
+       if (error) {
+           console.log("isIfaceActive callback error = " + error);
+       } else {
+           console.log("isIfaceActive callback = " + data);
+       }
+   });
+
+   // getIfaceConfig获取指定以太网的网络属性
+   ethernet.getIfaceConfig("eth0", (error, data) => {
+       if (error) {
+           console.log("getIfaceConfig  callback error = " + error);
+       } else {
+           console.log("getIfaceConfig callback mode = " + data.mode);
+           console.log("getIfaceConfig callback ipAddr = " + data.ipAddr);
+           console.log("getIfaceConfig callback routeAddr = " + data.routeAddr);
+           console.log("getIfaceConfig callback gateAddr = " + data.gateAddr);
+           console.log("getIfaceConfig callback maskAddr = " + data.maskAddr);
+           console.log("getIfaceConfig callback dns0Addr = " + data.dns0Addr);
+           console.log("getIfaceConfig callback dns1Addr = " + data.dns1Addr);
+       }
+   });
+```
+## 以太网连接-静态模式
+
+### 开发步骤
+
+1. 设备通过硬件接口，插入网线。
+2. 从@ohos.net.ethernet中导入ethernet命名空间。
+3. 用户态通过getAllActiveIfaces方法，来获取所有活动的网络设备名称，如：“eth0”，“eth1”。
+4. 用户态通过isIfaceActive方法，来判断网口“eth0”是否已激活。
+5. 用户态调用setIfaceConfig方法，来设置指定网口"eth0"为静态模式，手动IP地址，子网掩码，Gateway，DNS等网络属性。
+6. 用户态通过getIfaceConfig方法，来获取指定网口“eth0”的静态网络属性。
+
+```js
+   // 从@ohos.net.ethernet中导入ethernet命名空间
+   import ethernet from '@ohos.net.ethernet'
+
+   // getAllActiveIfaces获取所有活动的网络设备名称
+   ethernet.getAllActiveIfaces((error, data) => {
+       if (error) {
+           console.log("getAllActiveIfaces callback error = " + error);
+       } else {
+           console.log("getAllActiveIfaces callback data.length = " + data.length);
+           for (let i = 0; i < data.length; i++) {
+               console.log("getAllActiveIfaces callback = " + data[i]);
+           }
+       }
+   });
+
+   // isIfaceActive判断指定网口是否已激活
+   ethernet.isIfaceActive("eth0", (error, data) => {
+       if (error) {
+           console.log("isIfaceActive callback error = " + error);
+       } else {
+           console.log("isIfaceActive callback = " + data);
+       }
+   });
+
+   // setIfaceConfig配置指定以太网的网络属性
+   ethernet.setIfaceConfig("eth0", {mode:ethernet.STATIC,ipAddr:"192.168.xx.xx", routeAddr:"192.168.xx.xx",
+       gateAddr:"192.168.xx.xx", maskAddr:"255.255.xx.xx", dnsAddr0:"1.1.xx.xx", dnsAddr1:"2.2.xx.xx"},(error) => {
+       if (error) {
+           console.log("setIfaceConfig callback error = " + error);
+       } else {
+           console.log("setIfaceConfig callback ok ");
+       }
+   });
+
+   // getIfaceConfig获取指定以太网的网络属性
+   ethernet.getIfaceConfig("eth0", (error, data) => {
+       if (error) {
+           console.log("getIfaceConfig  callback error = " + error);
+       } else {
+           console.log("getIfaceConfig callback mode = " + data.mode);
+           console.log("getIfaceConfig callback ipAddr = " + data.ipAddr);
+           console.log("getIfaceConfig callback routeAddr = " + data.routeAddr);
+           console.log("getIfaceConfig callback gateAddr = " + data.gateAddr);
+           console.log("getIfaceConfig callback maskAddr = " + data.maskAddr);
+           console.log("getIfaceConfig callback dns0Addr = " + data.dns0Addr);
+           console.log("getIfaceConfig callback dns1Addr = " + data.dns1Addr);
+       }
+   });
+```

zh-cn/application-dev/connectivity/net-mgmt-overview.md

@@ -5,6 +5,10 @@
 - [HTTP数据请求](http-request.md)：通过HTTP发起一个数据请求。
 - [WebSocket连接](websocket-connection.md)：使用WebSocket建立服务器与客户端的双向连接。
 - [Socket连接](socket-connection.md)：通过Socket进行数据传输。
+- [网络策略管理](net-policy-management.md)：提供一些限制网络的基础能力，包括蜂窝网络策略、休眠/省电模式策略、后台网络策略、重置网络策略等功能。
+- [网络共享](net-sharing.md)：分享设备已有网络给其他连接设备，支持Wi-Fi热点共享、蓝牙共享和USB共享，同时提供网络共享状态、共享流量查询功能。
+- [以太网连接](net-ethernet.md)：以太网连接主要提供有线网络能力，提供设置有线网络的IP地址，子网掩码，网关，DNS等信息。
+- [网络连接管理](net-connection-manager.md)：网络连接管理提供管理网络一些基础能力，包括WiFi/蜂窝/Ethernet等多网络连接优先级管理、网络质量评估、订阅默认/指定网络连接状态变化、查询网络连接信息、DNS解析等功能。
 
 ## 约束与限制
 

zh-cn/application-dev/connectivity/net-sharing.md

+# 网络共享
+
+## 简介
+网络共享管理分享设备已有网络给其他连接设备，支持Wi-Fi热点共享、蓝牙共享和USB共享，同时提供网络共享状态、共享流量查询功能。
+
+> **说明：**
+> 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+## 基本概念
+-   WIFI共享：通过WIFI热点共享网络。
+-   蓝牙共享：通过蓝牙共享网络。
+-   USB共享：通过USB共享网络。
+
+## 约束
+-   开发语言：C++ JS
+-   系统：linux内核
+
+## 场景介绍
+网络共享的典型场景有：
+-   开启网络共享
+-   停止网络共享
+-   获取共享网络的数据流量
+
+以下分别介绍具体开发方式。
+## 接口说明
+完整的JS API说明以及实例代码请参考：[网络共享](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-net-sharing.md)。
+
+| 类型 | 接口 | 功能说明 |
+| ---- | ---- | ---- |
+| ohos.net.sharing | function isSharingSupported(callback: AsyncCallback\<boolean>): void; | 获取当前系统是否支持网络共享，使用callback方式作为异步方法 |
+| ohos.net.sharing | function isSharingSupported(): Promise\<boolean>; | 获取当前系统是否支持网络共享，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function isSharing(callback: AsyncCallback\<boolean>): void; | 获取当前共享状态，使用callback方式作为异步方法 |
+| ohos.net.sharing | function isSharing(): Promise\<boolean>; | 获取当前共享状态，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function startSharing(type: SharingIfaceType, callback: AsyncCallback\<void>): void; | 开启共享，type为共享类型，目前支持Wifi热点、蓝牙、USB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function startSharing(type: SharingIfaceType): Promise\<void>; | 开启共享，type为共享类型，目前支持Wifi热点、蓝牙、USB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function stopSharing(type: SharingIfaceType, callback: AsyncCallback\<void>): void; | 停止指定类型共享，type为共享类型，包括Wifi热点、蓝牙、USB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function stopSharing(type: SharingIfaceType): Promise\<void>; | 停止指定类型共享，type为共享类型，包括Wifi热点、蓝牙、USB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function getStatsRxBytes(callback: AsyncCallback\<number>): void; | 获取共享接收数据量，单位KB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function getStatsRxBytes(): Promise\<number>; | 获取共享接收数据量，单位KB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function getStatsTxBytes(callback: AsyncCallback\<number>): void; | 获取共享发送数据量，单位KB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function getStatsTxBytes(): Promise\<number>; | 获取共享发送数据量，单位KB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function getStatsTotalBytes(callback: AsyncCallback\<number>): void; | 获取共享总数据流量，单位KB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function getStatsTotalBytes(): Promise\<number>; | 获取共享总数据流量，单位KB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function getSharingIfaces(state: SharingIfaceState, callback: AsyncCallback\<Array\<string>>): void; | 获取指定状态的网卡名称，state为状态，包括正在共享、可共享、共享错误，使用callback方式作为异步方法 |
+| ohos.net.sharing | function getSharingIfaces(state: SharingIfaceState): Promise\<Array\<string>>; | 获取指定状态的网卡名称，state为状态，包括正在共享、可共享、共享错误，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function getSharingState(type: SharingIfaceType, callback: AsyncCallback\<SharingIfaceState>): void; | 获取指定类型共享状态，type为类型，目前支持Wifi热点、蓝牙、USB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function getSharingState(type: SharingIfaceType): Promise\<SharingIfaceState>; | 获取指定类型共享状态，type为类型，目前支持Wifi热点、蓝牙、USB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function getSharableRegexes(type: SharingIfaceType, callback: AsyncCallback\<Array\<string>>): void; | 获取与指定类型匹配的网卡正则表达式列表，type为类型，目前支持Wifi热点、蓝牙、USB，使用callback方式作为异步方法 |
+| ohos.net.sharing | function getSharableRegexes(type: SharingIfaceType): Promise\<Array\<string>>; | 获取与指定类型匹配的网卡正则表达式列表，type为类型，目前支持Wifi热点、蓝牙、USB，使用Promise方式作为异步方法 |
+| ohos.net.sharing | function on(type: 'sharingStateChange', callback: Callback\<boolean>): void; | 注册共享状态改变监听，返回网络共享的状态。 |
+| ohos.net.sharing | function off(type: 'sharingStateChange', callback?: Callback\<boolean>): void; | 注销共享状态改变监听，返回网络共享的状态。 |
+| ohos.net.sharing | unction on(type: 'interfaceSharingStateChange', callback: Callback\<{ type: SharingIfaceType, iface: string, state: SharingIfaceState }>): void; | 注册指定网卡共享状态改变监听 |
+| ohos.net.sharing | function off(type: 'interfaceSharingStateChange', callback?: Callback\<{ type: SharingIfaceType, iface: string, state: SharingIfaceState }>): void; | 注销指定网卡共享状态改变监听 |
+| ohos.net.sharing | function on(type: 'sharingUpstreamChange', callback: Callback\<NetHandle>): void; | 注册上行网卡改变监听 |
+| ohos.net.sharing | function off(type: 'sharingUpstreamChange', callback?: Callback\<NetHandle>): void; | 注销上行网卡改变监听 |
+
+## 开启网络共享
+
+### 开发步骤
+
+1. 从@ohos.net.sharing中导入sharing命名空间。
+2. 注册监听共享状态的改变。
+3. 调用startSharing方法，来开启指定类型共享。
+4. 接收到共享状态开启的回调，开启共享成功。
+
+```js
+   // 从@ohos.net.sharing中导入sharing命名空间
+   import sharing from '@ohos.net.sharing'
+
+   // 注册监听共享状态的改变
+   sharing.on('sharingStateChange', (error, data) => {
+       console.log(JSON.stringify(error));
+       console.log(JSON.stringify(data));
+   });
+
+   // 调用startSharing方法，来开启指定类型共享
+   sharing.startSharing(SharingIfaceType.SHARING_WIFI, (error) => {
+       console.log(JSON.stringify(error));
+   });
+```
+
+## 停止网络共享
+
+### 开发步骤
+
+1. 从@ohos.net.sharing中导入sharing命名空间。
+2. 注册监听共享状态的改变。
+3. 调用stopSharing方法，来停止指定类型共享。
+4. 接收到共享状态关闭的回调，停止共享成功。
+
+```js
+   // 从@ohos.net.sharing中导入sharing命名空间
+   import sharing from '@ohos.net.sharing'
+
+   // 注册监听共享状态的改变
+   sharing.on('sharingStateChange', (error, data) => {
+       console.log(JSON.stringify(error));
+       console.log(JSON.stringify(data));
+   });
+
+   // 调用stopSharing方法，来停止指定类型共享
+   sharing.stopSharing(SharingIfaceType.SHARING_WIFI, (error) => {
+       console.log(JSON.stringify(error));
+   });
+```
+
+## 获取共享网络的数据流量
+
+### 开发步骤
+
+1. 从@ohos.net.sharing中导入sharing命名空间。
+2. 调用startSharing方法，来开启指定类型共享。
+3. 调用getStatsTotalBytes方法，来获取共享网络数据量。
+4. 调用stopSharing方法，来停止指定类型共享，共享网络数据量清零。
+
+```js
+   // 从@ohos.net.sharing中导入sharing命名空间
+   import sharing from '@ohos.net.sharing'
+
+   // 调用startSharing方法，来开启指定类型共享
+   sharing.startSharing(SharingIfaceType.SHARING_WIFI, (error) => {
+       console.log(JSON.stringify(error));
+   });
+
+   // 调用getStatsTotalBytes方法，来获取共享网络数据量
+   sharing.getStatsTotalBytes((error, data) => {
+       console.log(JSON.stringify(error));
+       console.log(JSON.stringify(data));
+   });
+
+   // 调用stopSharing方法，来停止指定类型共享，共享网络数据量清零
+   sharing.stopSharing(SharingIfaceType.SHARING_WIFI, (error) => {
+       console.log(JSON.stringify(error));
+   });
+
+   // 再次调用getStatsTotalBytes方法，共享网络数据量已清零
+   sharing.getStatsTotalBytes((error, data) => {
+       console.log(JSON.stringify(error));
+       console.log(JSON.stringify(data));
+   });
+```

zh-cn/application-dev/connectivity/socket-connection.md

 # Socket连接
 
+## 简介
+
+Socket连接主要是通过Socket进行数据传输，支持TCP/UDP/TLS协议。
+
+## 基本概念
+
+- Socket：套接字，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。
+- TCP：传输控制协议(Transmission Control Protocol)。是一种面向连接的、可靠的、基于字节流的传输层通信协议。
+- UDP：用户数据报协议协议(User Datagram Protocol)。是一个简单的面向消息的传输层，不需要连接。
+- TLS：安全传输层协议(Transport Layer Security)。用于在两个通信应用程序之间提供保密性和数据完整性。
 
 ## 场景介绍
 
-应用通过Socket进行数据传输，支持TCP和UDP两种协议。
+应用通过Socket进行数据传输，支持TCP/UDP/TLS协议。主要场景有：
 
+- 应用通过TCP/UDP Socket进行数据传输
+- 应用通过TLS Socket进行加密数据传输
 
 ## 接口说明
 
+完整的JS API说明以及实例代码请参考：[Socket连接](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-socket.md)。
+
 Socket连接主要由socket模块提供。具体接口说明如下表。
 
 | 接口名 | 功能描述 |
@@ -31,8 +45,32 @@ Socket连接主要由socket模块提供。具体接口说明如下表。
 | on(type: 'connect') | 订阅TCPSocket的连接事件（仅TCP支持）。 |
 | off(type: 'connect') | 取消订阅TCPSocket的连接事件（仅TCP支持）。 |
 
+TLS Socket连接主要由tls_socket模块提供。具体接口说明如下表。
 
-## 开发步骤
+| 接口名 | 功能描述 |
+| -------- | -------- |
+| bind() | 绑定IP地址和端口号。 |
+| close(type: 'error') | 关闭连接。 |
+| connect() | 连接到指定的IP地址和端口。 |
+| getCertificate() | 返回表示本地证书的对象。 |
+| getCipherSuite() | 返回包含协商的密码套件信息的列表。 |
+| getProtocol() | 返回包含当前连接协商的SSL/TLS协议版本的字符串。 |
+| getRemoteAddress() | 获取TLSSocket连接的对端地址。 |
+| getRemoteCertificate() | 返回表示对等证书的对象。 |
+| getSignatureAlgorithms() | 在服务器和客户端之间共享的签名算法列表，按优先级降序排列。 |
+| getState() | 获取TLSSocket连接的状态。 |
+| off(type: 'close') | 取消订阅TLSSocket连接的关闭事件。 |
+| off(type: 'error') | 取消订阅TLSSocket连接的Error事件。 |
+| off(type: 'message') | 取消订阅TLSSocket连接的接收消息事件。 |
+| on(type: 'close') | 订阅TLSSocket连接的关闭事件。 |
+| on(type: 'error') | 订阅TLSSocket连接的Error事件。 |
+| on(type: 'message') | 订阅TLSSocket连接的接收消息事件。 |
+| send() | 发送数据。 |
+| setExtraOptions() | 设置TLSSocket连接的其他属性。 |
+
+## 应用TCP/UDP协议进行通信
+
+### 开发步骤
 
 UDP与TCP流程大体类似，下面以TCP为例：
 
@@ -49,13 +87,13 @@ UDP与TCP流程大体类似，下面以TCP为例：
 6. 发送数据。
 
 7. Socket连接使用完毕后，主动关闭。
-   
+
    ```js
    import socket from '@ohos.net.socket'
-   
+
    // 创建一个TCPSocket连接，返回一个TCPSocket对象。
    let tcp = socket.constructTCPSocketInstance();
-   
+
    // 订阅TCPSocket相关的订阅事件
    tcp.on('message', value => {
        console.log("on message")
@@ -73,7 +111,7 @@ UDP与TCP流程大体类似，下面以TCP为例：
    tcp.on('close', () => {
        console.log("on close")
    });
-   
+
    // 绑定本地IP地址和端口。
    let bindAddress = {
        address: '192.168.xx.xx',
@@ -86,6 +124,7 @@ UDP与TCP流程大体类似，下面以TCP为例：
            return;
        }
        console.log('bind success');
+
        // 连接到指定的IP地址和端口。
        let connectAddress = {
            address: '192.168.xx.xx',
@@ -100,6 +139,7 @@ UDP与TCP流程大体类似，下面以TCP为例：
                return;
            }
            console.log('connect success');
+
            // 发送数据
            tcp.send({
                data: 'Hello, server!'
@@ -112,6 +152,7 @@ UDP与TCP流程大体类似，下面以TCP为例：
            })
        });
    });
+
    // 连接使用完毕后，主动关闭。取消相关事件的订阅。
    setTimeout(() => {
        tcp.close((err) => {
@@ -123,8 +164,166 @@ UDP与TCP流程大体类似，下面以TCP为例：
    }, 30 * 1000);
    ```
 
+## 应用通过TLS Socket进行加密数据传输
+
+### 开发步骤
+
+客户端TLS Socket流程：
+
+1. import需要的socket模块。
+
+2. 绑定服务器IP和端口号。
+
+3. 双向认证上传客户端CA证书及数字证书；单向认证上传客户端CA证书。
+
+4. 创建一个TLSSocket连接，返回一个TLSSocket对象。
+
+5. （可选）订阅TLSSocket相关的订阅事件。
+
+6. 发送数据。
+
+7. TLSSocket连接使用完毕后，主动关闭。
+
+```js
+   import socket from '@ohos.net.socket'
+
+   // 创建一个（双向认证）TLS Socket连接，返回一个TLS Socket对象。
+   let tlsTwoWay = socket.constructTLSSocketInstance();
+
+   // 订阅TLS Socket相关的订阅事件
+   tcp.on('message', value => {
+       console.log("on message")
+       let buffer = value.message
+       let dataView = new DataView(buffer)
+       let str = ""
+       for (let i = 0; i < dataView.byteLength; ++i) {
+           str += String.fromCharCode(dataView.getUint8(i))
+       }
+       console.log("on connect received:" + str)
+   });
+   tcp.on('connect', () => {
+       console.log("on connect")
+   });
+   tcp.on('close', () => {
+       console.log("on close")
+   });
+
+   // 绑定本地IP地址和端口。
+   tlsTwoWay.bind({address: '192.168.xxx.xxx', port: xxxx, family: 1}, err => {
+       if (err) {
+           console.log('bind fail');
+           return;
+       }
+       console.log('bind success');
+   });
+
+   // 设置通信过程中使用参数
+   let options = {
+       ALPNProtocols: ["spdy/1", "http/1.1"],
+
+       // 连接到指定的IP地址和端口。
+       address: {
+           address: "192.168.xx.xxx",
+           port: xxxx, // 端口
+           family: 1,
+       },
+
+       // 设置用于通信过程中完成校验的参数。
+       secureOptions: {
+           key: "xxxx",                            // 密钥
+           cert: "xxxx",                           // 数字证书
+           ca: ["xxxx"],                           // CA证书
+           passwd: "xxxx",                         // 生成密钥时的密码
+           protocols: [socket.Protocol.TLSv12],    // 通信协议
+           useRemoteCipherPrefer: true,            // 是否优先使用对端密码套件
+           signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256",    // 签名算法
+           cipherSuite: "AES256-SHA256",           // 密码套件
+       },
+   };
+
+   // 建立连接
+   tlsTwoWay.connect(options, (err, data) => {
+       console.error(err);
+       console.log(data);
+   });
+
+   // 连接使用完毕后，主动关闭。取消相关事件的订阅。
+   tls.close((err) => {
+       if (err) {
+           console.log("close callback error = " + err);
+       } else {
+           console.log("close success");
+       }
+       tls.off('message');
+       tls.off('connect');
+       tls.off('close');
+   });
+
+   // 创建一个（单向认证）TLS Socket连接，返回一个TLS Socket对象。
+   let tlsOneWay = socket.constructTLSSocketInstance(); // One way authentication
+
+   // 订阅TLS Socket相关的订阅事件
+   tcp.on('message', value => {
+       console.log("on message")
+       let buffer = value.message
+       let dataView = new DataView(buffer)
+       let str = ""
+       for (let i = 0;i < dataView.byteLength; ++i) {
+           str += String.fromCharCode(dataView.getUint8(i))
+       }
+       console.log("on connect received:" + str)
+   });
+   tcp.on('connect', () => {
+       console.log("on connect")
+   });
+   tcp.on('close', () => {
+       console.log("on close")
+   });
+
+   // 绑定本地IP地址和端口。
+   tlsOneWay.bind({address: '192.168.xxx.xxx', port: xxxx, family: 1}, err => {
+       if (err) {
+           console.log('bind fail');
+           return;
+       }
+       console.log('bind success');
+   });
+
+   // 设置通信过程中使用参数
+   let oneWayOptions = {
+       address: {
+           address: "192.168.xxx.xxx",
+           port: xxxx,
+           family: 1,
+       },
+       secureOptions: {
+           ca: ["xxxx","xxxx"],            // CA证书
+           cipherSuite: "AES256-SHA256",   // 密码套件
+       },
+   };
+
+   // 建立连接
+   tlsOneWay.connect(oneWayOptions, (err, data) => {
+       console.error(err);
+       console.log(data);
+   });
+
+   // 连接使用完毕后，主动关闭。取消相关事件的订阅。
+   tls.close((err) => {
+       if (err) {
+           console.log("close callback error = " + err);
+       } else {
+           console.log("close success");
+       }
+       tls.off('message');
+       tls.off('connect');
+       tls.off('close');
+   });
+```
+
 ## 相关实例
+
 针对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)
-- [使用TCP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/TcpSocketDemo)
\ No newline at end of file
+- [使用TCP实现与服务端通信（ArkTS）（API9）](https://gitee.com/openharmony/codelabs/tree/master/NetworkManagement/TcpSocketDemo)

zh-cn/application-dev/reference/apis/js-apis-http.md

@@ -440,7 +440,7 @@ request方法回调函数的返回值类型。
 | resultType<sup>9+</sup> | [HttpDataType](#httpdatatype9)             | 是   | 返回值类型。                           |
 | responseCode         | [ResponseCode](#responsecode) \| number      | 是   | 回调函数执行成功时，此字段为[ResponseCode](#responsecode)。若执行失败，错误码将会从AsyncCallback中的err字段返回。错误码参考[Response错误码](#response常用错误码)。 |
 | 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。                                       |
+| cookies<sup>8+</sup> | string                                       | 是   | 服务器返回的 cookies。                                       |
 
 ## http.createHttpResponseCache<sup>9+</sup>
 

zh-cn/application-dev/reference/apis/js-apis-net-ethernet.md

-# @ohos.net.ethernet (以太网连接管理)
+# 以太网连接
 
 以太网连接管理主要提供有线网络能力，提供设置有线网络的IP地址，子网掩码，网关，DNS等信息
 
-> **说明：**
->
+> ![](public_sys-resources/icon-note.gif) **说明：**
 > 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
 
 ## 导入模块
@@ -35,8 +34,8 @@ setIfaceConfig(iface: string, ic: InterfaceConfiguration, callback: AsyncCallbac
 **示例：**
 
 ```js
-ethernet.setIfaceConfig("eth0", {mode:ethernet.STATIC,ipAddr:"192.168.1.123", routeAddr:"192.168.1.1",
-    gateAddr:"192.168.1.1", maskAddr:"255.255.255.0", dnsAddr0:"1.1.1.1", dnsAddr1:"2.2.2.2"},
+ethernet.setIfaceConfig("eth0", {mode:ethernet.STATIC,ipAddr:"192.168.xx.xx", routeAddr:"192.168.xx.xx",
+    gateAddr:"192.168.xx.xx", maskAddr:"255.255.xx.xx", dnsAddr0:"1.1.xx.xx", dnsAddr1:"2.2.xx.xx"},
     (error) => {
         if (error) {
             console.log("setIfaceConfig callback error = " + error);
@@ -74,8 +73,8 @@ setIfaceConfig(iface: string, ic: InterfaceConfiguration): Promise\<void>
 **示例：**
 
 ```js
-ethernet.setIfaceConfig("eth0", {mode:ethernet.STATIC,ipAddr:"192.168.1.123", routeAddr:"192.168.1.1",
-    gateAddr:"192.168.1.1", maskAddr:"255.255.255.0", dnsAddr0:"1.1.1.1", dnsAddr1:"2.2.2.2"}).then(() => {
+ethernet.setIfaceConfig("eth0", {mode:ethernet.STATIC,ipAddr:"192.168.xx.xx", routeAddr:"192.168.xx.xx",
+    gateAddr:"192.168.xx.xx", maskAddr:"255.255.xx.xx", dnsAddr0:"1.1.xx.xx", dnsAddr1:"2.2.xx.xx"}).then(() => {
     console.log("setIfaceConfig promiss ok ");
 }).catch((error) => {
     console.log("setIfaceConfig promiss error = " + error);

zh-cn/application-dev/reference/apis/js-apis-net-sharing.md

 # @ohos.net.sharing (网络共享管理)
 
-网络共享管理分享设备已有网络给其他连接设备，支持Wi-Fi热点共享和蓝牙共享，同时提供网络共享状态、共享流量查询功能。
+网络共享管理分享设备已有网络给其他连接设备，支持Wi-Fi热点共享、蓝牙共享和USB共享，同时提供网络共享状态、共享流量查询功能。
 
 > **说明：**
 >
@@ -789,7 +789,7 @@ sharing.off('sharingUpstreamChange', (error, data) => {
 
 ## SharingIfaceType
 
-网络共享类型（暂不支持USB共享）。
+网络共享类型。
 
 **系统接口**：此接口为系统接口。