modify osAccount and distributed-account doc

Signed-off-by: Nlibing23 <libing23@huawei.com>

zh-cn/application-dev/reference/apis/js-apis-distributed-account.md

@@ -36,11 +36,74 @@ getDistributedAccountAbility(): DistributedAccountAbility
 
 提供查询和更新分布式帐号登录状态方法(需要先获取分布式帐号的单实例对象)。
 
-### queryOsAccountDistributedInfo
+### getOsAccountDistributedInfo<sup>9+</sup>
+
+getOsAccountDistributedInfo(callback: AsyncCallback&lt;DistributedInfo&gt;): void
+
+获取分布式帐号信息，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**需要权限：** ohos.permission.MANAGE_DISTRIBUTED_ACCOUNTS 或 ohos.permission.GET_DISTRIBUTED_ACCOUNTS 或 ohos.permission.DISTRIBUTED_DATASYNC。
+
+**参数：**
+
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callback | AsyncCallback&lt;[DistributedInfo](#distributedinfo)&gt; | 是 | 获取分布式帐号信息的回调。 |
+
+**示例：**
+  ```js
+  const accountAbility = account_distributedAccount.getDistributedAccountAbility();
+  try {
+    accountAbility.getOsAccountDistributedInfo((err, data) => {
+        console.log("getOsAccountDistributedInfo err: " + JSON.stringify(err));
+        console.log('Query account info name: ' + data.name);
+        console.log('Query account info id: ' + data.id);
+    });
+  } catch (e) {
+    console.log("getOsAccountDistributedInfo exception: " + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountDistributedInfo<sup>9+</sup>
+
+getOsAccountDistributedInfo(): Promise&lt;DistributedInfo&gt;
+
+获取分布式帐号信息，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**需要权限：** ohos.permission.MANAGE_DISTRIBUTED_ACCOUNTS 或 ohos.permission.GET_DISTRIBUTED_ACCOUNTS 或 ohos.permission.DISTRIBUTED_DATASYNC。
+
+**返回值：**
+
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Promise&lt;[DistributedInfo](#distributedinfo)&gt; | Promise实例，用于获取异步返回结果。 |
+
+**示例：**
+  ```js
+  const accountAbility = account_distributedAccount.getDistributedAccountAbility();
+  try {
+    accountAbility.getOsAccountDistributedInfo().then((data) => {
+        console.log('Query account info name: ' + data.name);
+        console.log('Query account info id: ' + data.id);
+    }).catch((err) => {
+        console.log("getOsAccountDistributedInfo err: "  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log("getOsAccountDistributedInfo exception: " + JSON.stringify(e));
+  }
+  ```
+### queryOsAccountDistributedInfo<sup>(deprecated)</sup>
 
 queryOsAccountDistributedInfo(callback: AsyncCallback&lt;DistributedInfo&gt;): void
 
 获取分布式帐号信息，使用callback回调异步返回结果。
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountDistributedInfo](#getosaccountdistributedinfo9)
+>
+> 从 API version 7开始支持。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -62,11 +125,14 @@ queryOsAccountDistributedInfo(callback: AsyncCallback&lt;DistributedInfo&gt;): v
   });
   ```
 
-### queryOsAccountDistributedInfo
+### queryOsAccountDistributedInfo<sup>(deprecated)</sup>
 
 queryOsAccountDistributedInfo(): Promise&lt;DistributedInfo&gt;
 
 获取分布式帐号信息，使用Promise方式异步返回结果。
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountDistributedInfo](#getosaccountdistributedinfo9-1)
+>
+> 从 API version 7开始支持。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -89,11 +155,80 @@ queryOsAccountDistributedInfo(): Promise&lt;DistributedInfo&gt;
   });
   ```
 
-### updateOsAccountDistributedInfo
+### setOsAccountDistributedInfo<sup>9+</sup>
+
+setOsAccountDistributedInfo(accountInfo: DistributedInfo, callback: AsyncCallback&lt;void&gt;): void
+
+更新分布式帐号信息，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**需要权限：** ohos.permission.MANAGE_DISTRIBUTED_ACCOUNTS。
+
+**参数：**
+
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | accountInfo | [DistributedInfo](#distributedinfo) | 是 | 分布式帐号信息。 |
+  | callback | AsyncCallback&lt;void&gt; | 是 | 更新分布式帐号信息的回调。 |
+
+**示例：**
+  ```js
+  const accountAbility = account_distributedAccount.getDistributedAccountAbility();
+  let accountInfo = {id: '12345', name: 'ZhangSan', event: 'Ohos.account.event.LOGIN'};
+  try {
+    accountAbility.setOsAccountDistributedInfo(accountInfo, (err) => {
+        console.log("setOsAccountDistributedInfo err: " + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log("setOsAccountDistributedInfo exception: " + JSON.stringify(e));
+  }
+  ```
+
+### setOsAccountDistributedInfo<sup>9+</sup>
+
+setOsAccountDistributedInfo(accountInfo: DistributedInfo): Promise&lt;void&gt;
+
+更新分布式帐号信息，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**需要权限：** ohos.permission.MANAGE_DISTRIBUTED_ACCOUNTS。
+
+**参数：**
+
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | accountInfo | [DistributedInfo](#distributedinfo) | 是 | 分布式帐户信息。 |
+
+**返回值：**
+
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Promise&lt;void&gt; | Promise实例，用于获取异步返回结果。 |
+
+**示例：**
+  ```js
+  const accountAbility = account_distributedAccount.getDistributedAccountAbility();
+  let accountInfo = {id: '12345', name: 'ZhangSan', event: 'Ohos.account.event.LOGIN'};
+  try {
+    accountAbility.setOsAccountDistributedInfo(accountInfo).then(() => {
+        console.log('setOsAccountDistributedInfo Success');
+    }).catch((err) => {
+        console.log("setOsAccountDistributedInfo err: "  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log("setOsAccountDistributedInfo exception: " + JSON.stringify(e));
+  }
+  ```
+### updateOsAccountDistributedInfo<sup>(deprecated)</sup>
 
 updateOsAccountDistributedInfo(accountInfo: DistributedInfo, callback: AsyncCallback&lt;void&gt;): void
 
 更新分布式帐号信息，使用callback回调异步返回结果。
+> **说明：** 从API version 9开始废弃，建议使用[setOsAccountDistributedInfo](#setosaccountdistributedinfo9)
+>
+> 从 API version 7开始支持。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -115,12 +250,14 @@ updateOsAccountDistributedInfo(accountInfo: DistributedInfo, callback: AsyncCall
   });
   ```
 
-### updateOsAccountDistributedInfo
+### updateOsAccountDistributedInfo<sup>(deprecated)</sup>
 
 updateOsAccountDistributedInfo(accountInfo: DistributedInfo): Promise&lt;void&gt;
 
 更新分布式帐号信息，使用Promise方式异步返回结果。
-
+> **说明：** 从API version 9开始废弃，建议使用[setOsAccountDistributedInfo](#setosaccountdistributedinfo9-1)
+>
+> 从 API version 7开始支持。
 **系统能力：** SystemCapability.Account.OsAccount
 
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS。
@@ -147,8 +284,6 @@ updateOsAccountDistributedInfo(accountInfo: DistributedInfo): Promise&lt;void&gt
       console.log("updateOsAccountDistributedInfo err: "  + JSON.stringify(err));
   });
   ```
-
-
 ## DistributedInfo
 
 提供操作系统帐户的分布式信息。
@@ -160,4 +295,6 @@ updateOsAccountDistributedInfo(accountInfo: DistributedInfo): Promise&lt;void&gt
 | name | string | 是 | 分布式帐号名称，非空字符串。 |
 | id | string | 是 | 分布式帐号UID，非空字符串。 |
 | event | string | 是 | 分布式帐号登录状态，包括登录、登出、Token失效和注销，分别对应以下字符串：<br/>-&nbsp;Ohos.account.event.LOGIN<br/>-&nbsp;Ohos.account.event.LOGOUT<br/>-&nbsp;Ohos.account.event.TOKEN_INVALID<br/>-&nbsp;Ohos.account.event.LOGOFF |
+| nickname<sup>9+</sup> | string | 否 | 分布式帐号的昵称，非空字符串。 |
+| avatar<sup>9+</sup> | string | 否 | 分布式帐号的头像，非空字符串。 |
 | scalableData | object | 否 | 分布式帐号扩展信息，根据业务所需，以k-v形式传递定制化信息。<br/>说明：该参数是预留的可选项，目前查询和更新的方法实现中未使用。 |

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

@@ -70,9 +70,13 @@ activateOsAccount(localId: number, callback: AsyncCallback<void>): void
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.activateOsAccount(localId, (err)=>{
       console.log('activateOsAccount err:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('activateOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
 ### activateOsAccount
@@ -103,19 +107,84 @@ activateOsAccount(localId: number): Promise<void>
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.activateOsAccount(localId).then(() => {
       console.log('activateOsAccount success');
     }).catch((err) => {
       console.log('activateOsAccount err:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('activateOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
-### isMultiOsAccountEnable
+### isMultiOsAccountEnabled<sup>9+</sup>
+
+isMultiOsAccountEnabled(callback: AsyncCallback&lt;boolean&gt;): void
+
+判断是否支持多系统帐号，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                         | 必填 | 说明                                                |
+| -------- | ---------------------------- | ---- | --------------------------------------------------- |
+| callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，支持多系统帐号则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.isMultiOsAccountEnabled((err, isEnabled) => {
+      console.log('isMultiOsAccountEnabled err: ' + JSON.stringify(err));
+      console.log('isMultiOsAccountEnabled isEnabled: ' + isEnabled);
+    });
+  } catch (e) {
+    console.log('isMultiOsAccountEnabled exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isMultiOsAccountEnabled<sup>9+</sup>
+
+isMultiOsAccountEnabled(): Promise&lt;boolean&gt;
+
+判断是否支持多系统帐号，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                   | 说明                                                         |
+| :--------------------- | :----------------------------------------------------------- |
+| Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，支持多系统帐号则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  try {
+    let accountManager = account_osAccount.getAccountManager();
+    accountManager.isMultiOsAccountEnabled().then((isEnabled) => {
+      console.log('isMultiOsAccountEnabled, isEnabled: ' + isEnabled);
+    }).catch((err) => {
+      console.log('isMultiOsAccountEnabled err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('isMultiOsAccountEnabled exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isMultiOsAccountEnable<sup>(deprecated)</sup>
 
 isMultiOsAccountEnable(callback: AsyncCallback&lt;boolean&gt;): void
 
 判断是否支持多系统帐号，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isMultiOsAccountEnabled](#ismultiosaccountenabled9)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -134,12 +203,16 @@ isMultiOsAccountEnable(callback: AsyncCallback&lt;boolean&gt;): void
   });
   ```
 
-### isMultiOsAccountEnable
+### isMultiOsAccountEnable<sup>(deprecated)</sup>
 
 isMultiOsAccountEnable(): Promise&lt;boolean&gt;
 
 判断是否支持多系统帐号，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isMultiOsAccountEnabled](#ismultiosaccountenabled9-1)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **返回值：**
@@ -159,12 +232,86 @@ isMultiOsAccountEnable(): Promise&lt;boolean&gt;
   });
   ```
 
-### isOsAccountActived
+### isOsAccountActivated<sup>9+</sup>
+
+isOsAccountActivated(localId: number, callback: AsyncCallback&lt;boolean&gt;): void
+
+判断指定系统帐号是否处于激活状态，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                         | 必填 | 说明                                              |
+| -------- | ---------------------------- | ---- | ------------------------------------------------- |
+| localId  | number                       | 是   | 系统帐号ID。                                      |
+| callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，处于激活状态则返回true，否则返回false。 |
+
+**示例：** 判断ID为100的系统帐号是否处于激活状态
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let osLocalId = 100;
+  try {
+    accountManager.isOsAccountActivated(osLocalId, (err, isActive)=>{
+      console.log('isOsAccountActivated err:' + JSON.stringify(err));
+      console.log('isOsAccountActivated isActive:' + isActive);
+    });
+  } catch (e) {
+    console.log('isOsAccountActivated exception:' + JSON.stringify(e));
+  }
+  ```
+
+### isOsAccountActivated<sup>9+</sup>
+
+isOsAccountActivated(localId: number): Promise&lt;boolean&gt;
+
+判断指定系统帐号是否处于激活状态，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明         |
+| ------- | ------ | ---- | ------------ |
+| localId | number | 是   | 系统帐号ID。 |
+
+**返回值：**
+
+| 类型                   | 说明                                                         |
+| :--------------------- | :----------------------------------------------------------- |
+| Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，处于激活状态则返回true，否则返回false。 |
+
+**示例：** 判断ID为100的系统帐号是否处于激活状态
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let osLocalId = 100;
+  try {
+    accountManager.isOsAccountActivated(osLocalId).then((isActive) => {
+      console.log('isOsAccountActivated, isActive: ' + isActive);
+    }).catch((err) => {
+      console.log('isOsAccountActivated err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('isOsAccountActivated exception:' + JSON.stringify(e));
+  }
+  ```
+
+### isOsAccountActived<sup>(deprecated)</sup>
 
 isOsAccountActived(localId: number, callback: AsyncCallback&lt;boolean&gt;): void
 
 判断指定系统帐号是否处于激活状态，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃, 建议使用[isOsAccountActivated](#isosaccountactivated9)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -187,12 +334,16 @@ isOsAccountActived(localId: number, callback: AsyncCallback&lt;boolean&gt;): voi
   });
   ```
 
-### isOsAccountActived
+### isOsAccountActived<sup>(deprecated)</sup>
 
 isOsAccountActived(localId: number): Promise&lt;boolean&gt;
 
 判断指定系统帐号是否处于激活状态，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃, 建议使用[isOsAccountActivated](#isosaccountactivated9-1)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -221,12 +372,88 @@ isOsAccountActived(localId: number): Promise&lt;boolean&gt;
   });
   ```
 
-### isOsAccountConstraintEnable
+### isConstraintEnabled<sup>9+</sup>
+
+isConstraintEnabled(localId: number, constraint: string, callback: AsyncCallback&lt;boolean&gt;): void
+
+判断指定系统帐号是否具有指定约束，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名     | 类型                         | 必填 | 说明                                              |
+| ---------- | ---------------------------- | ---- | ------------------------------------------------- |
+| localId    | number                       | 是   | 指定的系统帐号ID。                                |
+| constraint | string                       | 是   | 指定的[约束](#系统帐号约束列表)名称。             |
+| callback   | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，具有指定约束则返回true，否则返回false。 |
+
+**示例：** 判断ID为100的系统帐号是否有禁止使用Wi-Fi的约束
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let localId = 100;
+  try {
+    accountManager.isConstraintEnabled(localId, 'constraint.wifi', (err, isEnabled)=>{
+      console.log('isConstraintEnabled err:' + JSON.stringify(err));
+      console.log('isConstraintEnabled isEnabled:' + isEnabled);
+    });
+  } catch (e) {
+    console.log('isConstraintEnabled exception:' + JSON.stringify(e));
+  }
+  ```
+
+### isConstraintEnabled<sup>9+</sup>
+
+isConstraintEnabled(localId: number, constraint: string): Promise&lt;boolean&gt;
+
+判断指定系统帐号是否具有指定约束，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名     | 类型   | 必填 | 说明                                  |
+| ---------- | ------ | ---- | ------------------------------------- |
+| localId    | number | 是   | 指定的系统帐号ID。                    |
+| constraint | string | 是   | 指定的[约束](#系统帐号约束列表)名称。 |
+
+**返回值：**
+
+| 类型                   | 说明                                                         |
+| :--------------------- | :----------------------------------------------------------- |
+| Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，具有指定约束则返回true，否则返回false。 |
+
+**示例：** 判断ID为100的系统帐号是否有禁止使用Wi-Fi的约束
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let localId = 100;
+  try {
+    accountManager.isConstraintEnabled(localId, 'constraint.wifi').then((isEnabled) => {
+      console.log('isConstraintEnabled, isEnabled: ' + isEnabled);
+    }).catch((err) => {
+      console.log('isConstraintEnabled err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('isConstraintEnabled exception:' + JSON.stringify(e));
+  }
+  ```
+
+### isOsAccountConstraintEnable<sup>(deprecated)</sup>
 
 isOsAccountConstraintEnable(localId: number, constraint: string, callback: AsyncCallback&lt;boolean&gt;): void
 
 判断指定系统帐号是否具有指定约束，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isConstraintEnabled](#isconstraintenabled9)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -250,12 +477,16 @@ isOsAccountConstraintEnable(localId: number, constraint: string, callback: Async
   });
   ```
 
-### isOsAccountConstraintEnable
+### isOsAccountConstraintEnable<sup>(deprecated)</sup>
 
 isOsAccountConstraintEnable(localId: number, constraint: string): Promise&lt;boolean&gt;
 
 判断指定系统帐号是否具有指定约束，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isConstraintEnabled](#isconstraintenabled9-1)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -285,12 +516,73 @@ isOsAccountConstraintEnable(localId: number, constraint: string): Promise&lt;boo
   });
   ```
 
-### isTestOsAccount
+### isTestable<sup>9+</sup>
+
+isTestable(callback: AsyncCallback&lt;boolean&gt;): void
+
+检查当前系统帐号是否为测试帐号，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                         | 必填 | 说明                                            |
+| -------- | ---------------------------- | ---- | ----------------------------------------------- |
+| callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，是测试帐号则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.isTestable((err, isTest) => {
+      console.log('isTestable err: ' + JSON.stringify(err));
+      console.log('isTestable isTest: ' + isTest);
+    });
+  } catch (e) {
+    console.log('isTestable exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isTestable<sup>9+</sup>
+
+isTestable(): Promise&lt;boolean&gt;
+
+检查当前系统帐号是否为测试帐号，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                   | 说明                                                         |
+| :--------------------- | :----------------------------------------------------------- |
+| Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，是测试帐号则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.isTestable().then((isTest) => {
+      console.log('isTestable, isTest: ' + isTest);
+    }).catch((err) => {
+      console.log('isTestable err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('isTestable exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isTestOsAccount<sup>(deprecated)</sup>
 
 isTestOsAccount(callback: AsyncCallback&lt;boolean&gt;): void
 
 检查当前系统帐号是否为测试帐号，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isTestable](#istestable9)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -309,12 +601,16 @@ isTestOsAccount(callback: AsyncCallback&lt;boolean&gt;): void
   });
   ```
 
-### isTestOsAccount
+### isTestOsAccount<sup>(deprecated)</sup>
 
 isTestOsAccount(): Promise&lt;boolean&gt;
 
 检查当前系统帐号是否为测试帐号，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isTestable](#istestable9-1)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **返回值：**
@@ -334,12 +630,114 @@ isTestOsAccount(): Promise&lt;boolean&gt;
   });
   ```
 
-### isOsAccountVerified
+### isVerified<sup>9+</sup>
+
+isVerified(callback: AsyncCallback&lt;boolean&gt;): void
+
+检查当前系统帐号是否已验证，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                         | 必填 | 说明                                        |
+| -------- | ---------------------------- | ---- | ------------------------------------------- |
+| callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，已验证则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.isVerified((err, isVeri) => {
+      console.log('isVerified err: ' + JSON.stringify(err));
+      console.log('isVerified isVeri: ' + isVeri);
+    });
+  } catch (e) {
+    console.log('isVerified exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isVerified<sup>9+</sup>
+
+isOsAccountVerified(localId: number, callback: AsyncCallback&lt;boolean&gt;): void
+
+检查指定系统帐号是否已验证，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                         | 必填 | 说明                                        |
+| -------- | ---------------------------- | ---- | ------------------------------------------- |
+| localId  | number                       | 否   | 指定的系统帐号ID。                          |
+| callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，已验证则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.isVerified((err, isVeri) => {
+      console.log('isVerified err: ' + JSON.stringify(err));
+      console.log('isVerified isVeri: ' + isVeri);
+    });
+  } catch (e) {
+    console.log('isVerified exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isVerified<sup>9+</sup>
+
+isOsAccountVerified(localId?: number): Promise&lt;boolean&gt;
+
+检查指定系统帐号是否已验证，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明               |
+| ------- | ------ | ---- | ------------------ |
+| localId | number | 否   | 指定的系统帐号ID。 |
+
+**返回值：**
+
+| 类型                   | 说明                                                         |
+| :--------------------- | :----------------------------------------------------------- |
+| Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，已验证则返回true，否则返回false。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.isVerified().then((isVeri) => {
+      console.log('isVerified, isVeri: ' + isVeri);
+    }).catch((err) => {
+      console.log('isVerified err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('isVerified exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### isOsAccountVerified<sup>(deprecated)</sup>
 
 isOsAccountVerified(callback: AsyncCallback&lt;boolean&gt;): void
 
 检查当前系统帐号是否已验证，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isVerified](#isverified9)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -358,12 +756,16 @@ isOsAccountVerified(callback: AsyncCallback&lt;boolean&gt;): void
   });
   ```
 
-### isOsAccountVerified
+### isOsAccountVerified<sup>(deprecated)</sup>
 
 isOsAccountVerified(localId: number, callback: AsyncCallback&lt;boolean&gt;): void
 
 检查指定系统帐号是否已验证，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isVerified](#isverified9-1)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -385,12 +787,16 @@ isOsAccountVerified(localId: number, callback: AsyncCallback&lt;boolean&gt;): vo
   });
   ```
 
-### isOsAccountVerified
+### isOsAccountVerified<sup>(deprecated)</sup>
 
 isOsAccountVerified(localId?: number): Promise&lt;boolean&gt;
 
 检查指定系统帐号是否已验证，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[isVerified](#isverified9-2)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -441,11 +847,15 @@ removeOsAccount(localId: number, callback: AsyncCallback&lt;void&gt;): void
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.createOsAccount('testAccountName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo) => {
       accountManager.removeOsAccount(osAccountInfo.localId, (err)=>{
         console.log('removeOsAccount err:' + JSON.stringify(err));
       });
     });
+  } catch (e) {
+    console.log('removeOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
 ### removeOsAccount
@@ -476,6 +886,7 @@ removeOsAccount(localId: number): Promise&lt;void&gt;
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.createOsAccount('testAccountName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo)=>{
       accountManager.removeOsAccount(osAccountInfo.localId).then(() => {
         console.log('removeOsAccount Success');
@@ -483,6 +894,9 @@ removeOsAccount(localId: number): Promise&lt;void&gt;
         console.log('removeOsAccount err: '  + JSON.stringify(err));
       });
     });
+  } catch (e) {
+    console.log('removeOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
 ### setOsAccountConstraints
@@ -511,9 +925,13 @@ setOsAccountConstraints(localId: number, constraints: Array&lt;string&gt;, enabl
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.setOsAccountConstraints(localId, ['constraint.wifi'], true, (err)=>{
       console.log('setOsAccountConstraints err:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setOsAccountConstraints exception:' + JSON.stringify(e));
+  }
   ```
 
 ### setOsAccountConstraints
@@ -547,11 +965,15 @@ setOsAccountConstraints(localId: number, constraints: Array&lt;string&gt;, enabl
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.setOsAccountConstraints(localId, ['constraint.location.set'], false).then(() => {
       console.log('setOsAccountConstraints Success');
     }).catch((err) => {
       console.log('setOsAccountConstraints err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setOsAccountConstraints exception:' + JSON.stringify(e));
+  }
   ```
 
 ### setOsAccountName
@@ -580,9 +1002,13 @@ setOsAccountName(localId: number, localName: string, callback: AsyncCallback&lt;
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
   let newName = 'demoName';
+  try {
     accountManager.setOsAccountName(localId, newName, (err)=>{
       console.debug('setOsAccountName err:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setOsAccountName exception:' + JSON.stringify(e));
+  }
   ```
 
 ### setOsAccountName
@@ -616,19 +1042,88 @@ setOsAccountName(localId: number, localName: string): Promise&lt;void&gt;
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
   let nameLimit = 'demoName';
+  try {
     accountManager.setOsAccountName(localId, nameLimit).then(() => {
       console.log('setOsAccountName Success');
     }).catch((err) => {
       console.log('setOsAccountName err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setOsAccountName exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountCount<sup>9+</sup>
+
+getOsAccountCount(callback: AsyncCallback&lt;number&gt;): void
+
+获取已创建的系统帐号数量，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                        | 必填 | 说明                                       |
+| -------- | --------------------------- | ---- | ------------------------------------------ |
+| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是已创建的系统帐号的数量。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getOsAccountCount((err, accountCnt)=>{
+      console.log('obtains the number of all os accounts created err:' + JSON.stringify(err));
+      console.log('obtains the number of all os accounts created accountCnt:' + accountCnt);
+    });
+  } catch (e) {
+    console.log('obtains the number of all os accounts created exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountCount<sup>9+</sup>
+
+getOsAccountCount(): Promise&lt;number&gt;
+
+获取已创建的系统帐号数量，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是已创建的系统帐号的数量。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getOsAccountCount().then((accountCnt) => {
+      console.log('getOsAccountCount, accountCnt: ' + accountCnt);
+    }).catch((err) => {
+      console.log('getOsAccountCount err: '  + JSON.stringify(err));
+    });
+  } catch(e) {
+    console.log('getOsAccountCount exception: '  + JSON.stringify(e));
+  }
   ```
 
-### getCreatedOsAccountsCount
+### getCreatedOsAccountsCount<sup>(deprecated)</sup>
 
 getCreatedOsAccountsCount(callback: AsyncCallback&lt;number&gt;): void
 
 获取已创建的系统帐号数量，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountCount](#getosaccountcount9)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -649,13 +1144,131 @@ getCreatedOsAccountsCount(callback: AsyncCallback&lt;number&gt;): void
   });
   ```
 
-### getCreatedOsAccountsCount
+### getCreatedOsAccountsCount<sup>(deprecated)</sup>
 
 getCreatedOsAccountsCount(): Promise&lt;number&gt;
 
 获取已创建的系统帐号数量，使用Promise方式异步返回结果。
 
-**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountCount](#getosaccountcount9-1)
+>
+> 从 API version 7开始支持。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是已创建的系统帐号的数量。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  accountManager.getCreatedOsAccountsCount().then((accountCnt) => {
+    console.log('getCreatedOsAccountsCount, accountCnt: ' + accountCnt);
+  }).catch((err) => {
+    console.log('getCreatedOsAccountsCount err: '  + JSON.stringify(err));
+  });
+  ```
+
+### queryOsAccountLocalIdFromProcess<sup>9+</sup>
+
+queryOsAccountLocalIdFromProcess(callback: AsyncCallback&lt;number&gt;): void
+
+获取当前进程所属的系统帐号的帐号ID，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                        | 必填 | 说明                                               |
+| -------- | --------------------------- | ---- | -------------------------------------------------- |
+| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号ID。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.queryOsAccountLocalIdFromProcess((err, accountID) => {
+      console.log('queryOsAccountLocalIdFromProcess err: ' + JSON.stringify(err));
+      console.log('queryOsAccountLocalIdFromProcess accountID: ' + accountID);
+    });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromProcess exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### queryOsAccountLocalIdFromProcess<sup>9+</sup>
+
+queryOsAccountLocalIdFromProcess(): Promise&lt;number&gt;
+
+获取当前进程所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号ID。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.queryOsAccountLocalIdFromProcess().then((accountID) => {
+      console.log('queryOsAccountLocalIdFromProcess, accountID: ' + accountID);
+    }).catch((err) => {
+      console.log('queryOsAccountLocalIdFromProcess err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromProcess exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountLocalIdFromProcess<sup>(deprecated)</sup>
+
+getOsAccountLocalIdFromProcess(callback: AsyncCallback&lt;number&gt;): void
+
+获取当前进程所属的系统帐号的帐号ID，使用callback回调异步返回结果。
+
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromProcess](#queryosaccountlocalidfromprocess9)
+>
+> 从 API version 7开始支持。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                        | 必填 | 说明                                               |
+| -------- | --------------------------- | ---- | -------------------------------------------------- |
+| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号ID。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  accountManager.getOsAccountLocalIdFromProcess((err, accountID) => {
+    console.log('getOsAccountLocalIdFromProcess err: ' + JSON.stringify(err));
+    console.log('getOsAccountLocalIdFromProcess accountID: ' + accountID);
+  });
+  ```
+
+### getOsAccountLocalIdFromProcess<sup>(deprecated)</sup>
+
+getOsAccountLocalIdFromProcess(): Promise&lt;number&gt;
+
+获取当前进程所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
+
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromProcess](#queryosaccountlocalidfromprocess9-1)
+>
+> 从 API version 7开始支持。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -663,74 +1276,95 @@ getCreatedOsAccountsCount(): Promise&lt;number&gt;
 
 | 类型                  | 说明                                                         |
 | :-------------------- | :----------------------------------------------------------- |
-| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是已创建的系统帐号的数量。 |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号ID。 |
 
 **示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.getCreatedOsAccountsCount().then((accountCnt) => {
-    console.log('getCreatedOsAccountsCount, accountCnt: ' + accountCnt);
+  accountManager.getOsAccountLocalIdFromProcess().then((accountID) => {
+    console.log('getOsAccountLocalIdFromProcess, accountID: ' + accountID);
   }).catch((err) => {
-    console.log('getCreatedOsAccountsCount err: '  + JSON.stringify(err));
+    console.log('getOsAccountLocalIdFromProcess err: '  + JSON.stringify(err));
   });
   ```
 
-### getOsAccountLocalIdFromProcess
+### queryOsAccountLocalIdFromUid<sup>9+</sup>
 
-getOsAccountLocalIdFromProcess(callback: AsyncCallback&lt;number&gt;): void
+queryOsAccountLocalIdFromUid(uid: number, callback: AsyncCallback&lt;number&gt;): void
 
-获取当前进程所属的系统帐号的帐号ID，使用callback回调异步返回结果。
+从进程uid中获取该uid所属的系统帐号的帐号ID，使用callback回调异步返回结果。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
 
 | 参数名   | 类型                        | 必填 | 说明                                          |
-| -------- | --------------------------- | ---- | -------------------------------------------------- |
-| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号ID。 |
+| -------- | --------------------------- | ---- | --------------------------------------------- |
+| uid      | number                      | 是   | 进程uid。                                     |
+| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是uid所属的系统帐号的帐号ID。 |
 
-**示例：** 
+**示例：** 查询值为12345678的uid所属的系统帐号的帐号ID
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.getOsAccountLocalIdFromProcess((err, accountID) => {
-    console.log('getOsAccountLocalIdFromProcess err: ' + JSON.stringify(err));
-    console.log('getOsAccountLocalIdFromProcess accountID: ' + accountID);
+  let uid = 12345678;
+  try {
+    accountManager.queryOsAccountLocalIdFromUid(uid, (err, accountID) => {
+      console.log('queryOsAccountLocalIdFromUid err: ' + JSON.stringify(err));
+      console.log('queryOsAccountLocalIdFromUid: ' + accountID);
     });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromUid exception: ' + JSON.stringify(e));
+  }
   ```
 
-### getOsAccountLocalIdFromProcess
+### queryOsAccountLocalIdFromUid<sup>9+</sup>
 
-getOsAccountLocalIdFromProcess(): Promise&lt;number&gt;
+queryOsAccountLocalIdFromUid(uid: number): Promise&lt;number&gt;
 
-获取当前进程所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
+从进程uid中获取该uid所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
+**参数：**
+
+| 参数名 | 类型   | 必填 | 说明      |
+| ------ | ------ | ---- | --------- |
+| uid    | number | 是   | 进程uid。 |
+
 **返回值：**
 
 | 类型                  | 说明                                                         |
 | :-------------------- | :----------------------------------------------------------- |
-| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号ID。 |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是uid所属的系统帐号的帐号ID。 |
 
-**示例：** 
+**示例：** 查询值为12345678的uid所属的系统帐号的帐号ID
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.getOsAccountLocalIdFromProcess().then((accountID) => {
-    console.log('getOsAccountLocalIdFromProcess, accountID: ' + accountID);
+  let uid = 12345678;
+  try {
+    accountManager.queryOsAccountLocalIdFromUid(uid).then((accountID) => {
+      console.log('queryOsAccountLocalIdFromUid: ' + accountID);
     }).catch((err) => {
-    console.log('getOsAccountLocalIdFromProcess err: '  + JSON.stringify(err));
+      console.log('queryOsAccountLocalIdFromUid err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromUid exception: ' + JSON.stringify(e));
+  }
   ```
 
-### getOsAccountLocalIdFromUid
+### getOsAccountLocalIdFromUid<sup>(deprecated)</sup>
 
 getOsAccountLocalIdFromUid(uid: number, callback: AsyncCallback&lt;number&gt;): void
 
 从进程uid中获取该uid所属的系统帐号的帐号ID，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromUid](#queryosaccountlocalidfromuid9)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -751,12 +1385,16 @@ getOsAccountLocalIdFromUid(uid: number, callback: AsyncCallback&lt;number&gt;):
   });
   ```
 
-### getOsAccountLocalIdFromUid
+### getOsAccountLocalIdFromUid<sup>(deprecated)</sup>
 
 getOsAccountLocalIdFromUid(uid: number): Promise&lt;number&gt;
 
 从进程uid中获取该uid所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromUid](#queryosaccountlocalidfromuid9-1)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -783,12 +1421,86 @@ getOsAccountLocalIdFromUid(uid: number): Promise&lt;number&gt;
   });
   ```
 
-### getOsAccountLocalIdFromDomain<sup>8+</sup>
+### queryOsAccountLocalIdFromDomain<sup>9+</sup>
+
+getOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo, callback: AsyncCallback&lt;number&gt;): void
+
+根据域帐号信息，获取与其关联的系统帐号的帐号ID。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.MANAGE_LOCAL_ACCOUNTS or ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名     | 类型                                    | 必填 | 说明                                         |
+| ---------- | --------------------------------------- | ---- | -------------------------------------------- |
+| domainInfo | [DomainAccountInfo](#domainaccountinfo8) | 是   | 域帐号信息。                                 |
+| callback   | AsyncCallback&lt;number&gt;             | 是   | 回调结果，返回的是和域帐号关联的系统帐号ID。 |
+
+**示例：**
+
+  ```js
+  let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.queryOsAccountLocalIdFromDomain(domainInfo, (err, accountID) => {
+      console.log('queryOsAccountLocalIdFromDomain: ' + JSON.stringify(err));
+      console.log('queryOsAccountLocalIdFromDomain: ' + accountID);
+    });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromDomain: ' + JSON.stringify(e));
+  }
+  ```
+
+### queryOsAccountLocalIdFromDomain<sup>9+</sup>
+
+queryOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo): Promise&lt;number&gt;
+
+根据域帐号信息，获取与其关联的系统帐号的帐号ID，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.MANAGE_LOCAL_ACCOUNTS or ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名     | 类型                                    | 必填 | 说明         |
+| ---------- | --------------------------------------- | ---- | ------------ |
+| domainInfo | [DomainAccountInfo](#domainaccountinfo8) | 是   | 域帐号信息。 |
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是和域帐号关联的系统帐号ID。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
+  try {
+    accountManager.queryOsAccountLocalIdFromDomain(domainInfo).then((accountID) => {
+      console.log('queryOsAccountLocalIdFromDomain: ' + accountID);
+    }).catch((err) => {
+      console.log('queryOsAccountLocalIdFromDomain err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromDomain exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountLocalIdFromDomain<sup>(deprecated)</sup>
 
 getOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo, callback: AsyncCallback&lt;number&gt;): void
 
 根据域帐号信息，获取与其关联的系统帐号的帐号ID。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromDomain](#queryosaccountlocalidfromdomain9)
+>
+> 从 API version 8开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -811,12 +1523,16 @@ getOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo, callback: AsyncCall
   });
   ```
 
-### getOsAccountLocalIdFromDomain<sup>8+</sup>
+### getOsAccountLocalIdFromDomain<sup>(deprecated)</sup>
 
 getOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo): Promise&lt;number&gt;
 
 根据域帐号信息，获取与其关联的系统帐号的帐号ID，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromDomain](#queryosaccountlocalidfromdomain9-1)
+>
+> 从 API version 8开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -865,10 +1581,14 @@ queryMaxOsAccountNumber(callback: AsyncCallback&lt;number&gt;): void
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.queryMaxOsAccountNumber((err, maxCnt)=>{
       console.log('queryMaxOsAccountNumber err:' + JSON.stringify(err));
       console.log('queryMaxOsAccountNumber maxCnt:' + maxCnt);
     });
+  } catch (e) {
+    console.log('queryMaxOsAccountNumber exception:' + JSON.stringify(e));
+  }
   ```
 
 ### queryMaxOsAccountNumber
@@ -891,19 +1611,97 @@ queryMaxOsAccountNumber(): Promise&lt;number&gt;
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.queryMaxOsAccountNumber().then((maxCnt) => {
       console.log('queryMaxOsAccountNumber, maxCnt: ' + maxCnt);
     }).catch((err) => {
       console.log('queryMaxOsAccountNumber err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('queryMaxOsAccountNumber exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountConstraints<sup>9+</sup>
+
+getOsAccountConstraints(localId: number, callback: AsyncCallback&lt;Array&lt;string&gt;&gt;): void
+
+获取指定系统帐号的全部约束，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                                     | 必填 | 说明                                                         |
+| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ |
+| localId  | number                                   | 是   | 系统帐号ID。                                                 |
+| callback | AsyncCallback&lt;Array&lt;string&gt;&gt; | 是   | 回调结果，返回的是该系统帐号的全部[约束](#系统帐号约束列表)。 |
+
+**示例：** 获取ID为100的系统帐号的全部约束
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let localId = 100;
+  try {
+    accountManager.getOsAccountConstraints(localId, (err, constraints)=>{
+      console.log('getOsAccountConstraints err:' + JSON.stringify(err));
+      console.log('getOsAccountConstraints:' + JSON.stringify(constraints));
+    });
+  } catch (e) {
+    console.log('getOsAccountConstraints exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountConstraints<sup>9+</sup>
+
+getOsAccountConstraints(localId: number): Promise&lt;Array&lt;string&gt;&gt;
+
+获取指定系统帐号的全部约束，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明         |
+| ------- | ------ | ---- | ------------ |
+| localId | number | 是   | 系统帐号ID。 |
+
+**返回值：**
+
+| 类型                               | 说明                                                         |
+| :--------------------------------- | :----------------------------------------------------------- |
+| Promise&lt;Array&lt;string&gt;&gt; | Promise实例，用于获取异步返回结果，返回的是该系统帐号的全部[约束](#系统帐号约束列表)。 |
+
+**示例：** 获取ID为100的系统帐号的全部约束
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let localId = 100;
+  try {
+    accountManager.getOsAccountConstraints(localId).then((constraints) => {
+      console.log('getOsAccountConstraints, constraints: ' + constraints);
+    }).catch((err) => {
+      console.log('getOsAccountConstraints err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('getOsAccountConstraints exception:' + JSON.stringify(e));
+  }
   ```
 
-### getOsAccountAllConstraints
+### getOsAccountAllConstraints<sup>(deprecated)</sup>
 
 getOsAccountAllConstraints(localId: number, callback: AsyncCallback&lt;Array&lt;string&gt;&gt;): void
 
 获取指定系统帐号的全部约束，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountConstraints](#getosaccountconstraints9)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -926,10 +1724,14 @@ getOsAccountAllConstraints(localId: number, callback: AsyncCallback&lt;Array&lt;
   });
   ```
 
-### getOsAccountAllConstraints
+### getOsAccountAllConstraints<sup>(deprecated)</sup>
 
 getOsAccountAllConstraints(localId: number): Promise&lt;Array&lt;string&gt;&gt;
 
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountConstraints](#getosaccountconstraints9-1)
+>
+> 从 API version 7开始支持。
+
 获取指定系统帐号的全部约束，使用Promise方式异步返回结果。
 
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
@@ -982,10 +1784,14 @@ queryAllCreatedOsAccounts(callback: AsyncCallback&lt;Array&lt;OsAccountInfo&gt;&
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.queryAllCreatedOsAccounts((err, accountArr)=>{
       console.log('queryAllCreatedOsAccounts err:' + JSON.stringify(err));
       console.log('queryAllCreatedOsAccounts accountArr:' + JSON.stringify(accountArr));
     });
+  } catch (e) {
+    console.log('queryAllCreatedOsAccounts exception:' + JSON.stringify(e));
+  }
   ```
 
 ### queryAllCreatedOsAccounts
@@ -1010,19 +1816,87 @@ queryAllCreatedOsAccounts(): Promise&lt;Array&lt;OsAccountInfo&gt;&gt;
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.queryAllCreatedOsAccounts().then((accountArr) => {
       console.log('queryAllCreatedOsAccounts, accountArr: ' + JSON.stringify(accountArr));
     }).catch((err) => {
       console.log('queryAllCreatedOsAccounts err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('queryAllCreatedOsAccounts exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getActivatedOsAccountIds<sup>9+</sup>
+
+getActivatedOsAccountIds(callback: AsyncCallback&lt;Array&lt;number&gt;&gt;): void
+
+查询当前处于激活状态的系统帐号的ID列表，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                                     | 必填 | 说明                                                   |
+| -------- | ---------------------------------------- | ---- | ------------------------------------------------------ |
+| callback | AsyncCallback&lt;Array&lt;number&gt;&gt; | 是   | 回调结果，返回的是当前处于激活状态的系统帐号的ID列表。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getActivatedOsAccountIds((err, idArray)=>{
+      console.log('getActivatedOsAccountIds err:' + JSON.stringify(err));
+      console.log('getActivatedOsAccountIds idArray length:' + idArray.length);
+      for(let i=0;i<idArray.length;i++) {
+        console.info('activated os account id: ' + idArray[i]);
+      }
+    });
+  } catch (e) {
+    console.log('getActivatedOsAccountIds exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getActivatedOsAccountIds<sup>9+</sup>
+
+getActivatedOsAccountIds(): Promise&lt;Array&lt;number&gt;&gt;
+
+查询当前处于激活状态的系统帐号的ID列表，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                               | 说明                                                         |
+| :--------------------------------- | :----------------------------------------------------------- |
+| Promise&lt;Array&lt;number&gt;&gt; | Promise实例，用于获取异步返回结果，返回的是当前处于激活状态的系统帐号的ID列表。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getActivatedOsAccountIds().then((idArray) => {
+      console.log('getActivatedOsAccountIds, idArray: ' + idArray);
+    }).catch((err) => {
+      console.log('getActivatedOsAccountIds err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('getActivatedOsAccountIds exception:' + JSON.stringify(e));
+  }
   ```
 
-### queryActivatedOsAccountIds<sup>8+</sup>
+### queryActivatedOsAccountIds<sup>(deprecated)</sup>
 
 queryActivatedOsAccountIds(callback: AsyncCallback&lt;Array&lt;number&gt;&gt;): void
 
 查询当前处于激活状态的系统帐号的ID列表，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getActivatedOsAccountIds](#getactivatedosaccountids9)
+>
+> 从 API version 8开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -1044,10 +1918,14 @@ queryActivatedOsAccountIds(callback: AsyncCallback&lt;Array&lt;number&gt;&gt;):
   });
   ```
 
-### queryActivatedOsAccountIds<sup>8+</sup>
+### queryActivatedOsAccountIds<sup>(deprecated)</sup>
 
 queryActivatedOsAccountIds(): Promise&lt;Array&lt;number&gt;&gt;
 
+> **说明：** 从API version 9开始废弃，建议使用[getActivatedOsAccountIds](#getactivatedosaccountids9-1)
+>
+> 从 API version 8开始支持。
+
 查询当前处于激活状态的系统帐号的ID列表，使用Promise方式异步返回结果。
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -1093,10 +1971,14 @@ createOsAccount(localName: string, type: OsAccountType, callback: AsyncCallback&
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.createOsAccount('testName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo)=>{
       console.log('createOsAccount err:' + JSON.stringify(err));
       console.log('createOsAccount osAccountInfo:' + JSON.stringify(osAccountInfo));
     });
+  } catch (e) {
+    console.log('createOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
 ### createOsAccount
@@ -1128,11 +2010,15 @@ createOsAccount(localName: string, type: OsAccountType): Promise&lt;OsAccountInf
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.createOsAccount('testAccountName', account_osAccount.OsAccountType.NORMAL).then((accountInfo) => {
       console.log('createOsAccount, accountInfo: ' + JSON.stringify(accountInfo));
     }).catch((err) => {
       console.log('createOsAccount err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('createOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
 ### createOsAccountForDomain<sup>8+</sup>
@@ -1160,10 +2046,14 @@ createOsAccountForDomain(type: OsAccountType, domainInfo: DomainAccountInfo, cal
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
+  try {
     accountManager.createOsAccountForDomain(account_osAccount.OsAccountType.NORMAL, domainInfo, (err, osAccountInfo)=>{
       console.log('createOsAccountForDomain err:' + JSON.stringify(err));
       console.log('createOsAccountForDomain osAccountInfo:' + JSON.stringify(osAccountInfo));
     });
+  } catch (e) {
+    console.log('createOsAccountForDomain exception:' + JSON.stringify(e));
+  }
   ```
 
 ### createOsAccountForDomain<sup>8+</sup>
@@ -1178,37 +2068,106 @@ createOsAccountForDomain(type: OsAccountType, domainInfo: DomainAccountInfo): Pr
 
 **系统能力：** SystemCapability.Account.OsAccount
 
-**参数：**
+**参数：**
+
+| 参数名     | 类型                                    | 必填 | 说明                   |
+| ---------- | --------------------------------------- | ---- | ---------------------- |
+| type       | [OsAccountType](#osaccounttype)         | 是   | 创建的系统帐号的类型。 |
+| domainInfo | [DomainAccountInfo](#domainaccountinfo8) | 是   | 域帐号信息。           |
+
+**返回值：**
+
+| 类型                                           | 说明                                                         |
+| :--------------------------------------------- | :----------------------------------------------------------- |
+| Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是新创建的系统帐号的信息。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
+  try {
+    accountManager.createOsAccountForDomain(account_osAccount.OsAccountType.NORMAL, domainInfo).then((accountInfo) => {
+      console.log('createOsAccountForDomain, account info: ' + JSON.stringify(accountInfo));
+    }).catch((err) => {
+      console.log('createOsAccountForDomain err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('createOsAccountForDomain exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getCurrentOsAccount<sup>9+</sup>
+
+getCurrentOsAccount(callback: AsyncCallback&lt;OsAccountInfo&gt;): void
+
+查询当前进程所属的系统帐号的信息，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                                                 | 必填 | 说明                                           |
+| -------- | ---------------------------------------------------- | ---- | ---------------------------------------------- |
+| callback | AsyncCallback&lt;[OsAccountInfo](#osaccountinfo)&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号信息。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getCurrentOsAccount((err, curAccountInfo)=>{
+      console.log('getCurrentOsAccount err:' + JSON.stringify(err));
+      console.log('getCurrentOsAccount curAccountInfo:' + JSON.stringify(curAccountInfo));
+    });
+  } catch (e) {
+    console.log('getCurrentOsAccount exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getCurrentOsAccount<sup>9+</sup>
+
+getCurrentOsAccount(): Promise&lt;OsAccountInfo&gt;
+
+查询当前进程所属的系统帐号的信息，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
 
-| 参数名     | 类型                                    | 必填 | 说明                   |
-| ---------- | --------------------------------------- | ---- | ---------------------- |
-| type       | [OsAccountType](#osaccounttype)         | 是   | 创建的系统帐号的类型。 |
-| domainInfo | [DomainAccountInfo](#domainaccountinfo8) | 是   | 域帐号信息。           |
+**系统能力：** SystemCapability.Account.OsAccount
 
 **返回值：**
 
 | 类型                                           | 说明                                                         |
 | :--------------------------------------------- | :----------------------------------------------------------- |
-| Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是新创建的系统帐号的信息。 |
+| Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号信息。 |
 
 **示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
-  accountManager.createOsAccountForDomain(account_osAccount.OsAccountType.NORMAL, domainInfo).then((accountInfo) => {
-    console.log('createOsAccountForDomain, account info: ' + JSON.stringify(accountInfo));
+  try {
+    accountManager.getCurrentOsAccount().then((accountInfo) => {
+      console.log('getCurrentOsAccount, accountInfo: ' + JSON.stringify(accountInfo));
     }).catch((err) => {
-    console.log('createOsAccountForDomain err: '  + JSON.stringify(err));
+      console.log('getCurrentOsAccount err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('getCurrentOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 
-### queryCurrentOsAccount
+### queryCurrentOsAccount<sup>(deprecated)</sup>
 
 queryCurrentOsAccount(callback: AsyncCallback&lt;OsAccountInfo&gt;): void
 
 查询当前进程所属的系统帐号的信息，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getCurrentOsAccount](#getcurrentosaccount9)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -1229,12 +2188,16 @@ queryCurrentOsAccount(callback: AsyncCallback&lt;OsAccountInfo&gt;): void
   });
   ```
 
-### queryCurrentOsAccount
+### queryCurrentOsAccount<sup>(deprecated)</sup>
 
 queryCurrentOsAccount(): Promise&lt;OsAccountInfo&gt;
 
 查询当前进程所属的系统帐号的信息，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getCurrentOsAccount](#getcurrentosaccount9-1)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -1280,10 +2243,14 @@ queryOsAccountById(localId: number, callback: AsyncCallback&lt;OsAccountInfo&gt;
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.queryOsAccountById(localId, (err, accountInfo)=>{
       console.log('queryOsAccountById err:' + JSON.stringify(err));
       console.log('queryOsAccountById accountInfo:' + JSON.stringify(accountInfo));
     });
+  } catch (e) {
+    console.log('queryOsAccountById exception:' + JSON.stringify(e));
+  }
   ```
 
 ### queryOsAccountById
@@ -1315,19 +2282,84 @@ queryOsAccountById(localId: number): Promise&lt;OsAccountInfo&gt;
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.queryOsAccountById(localId).then((accountInfo) => {
       console.log('queryOsAccountById, accountInfo: ' + JSON.stringify(accountInfo));
     }).catch((err) => {
       console.log('queryOsAccountById err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('queryOsAccountById exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountType<sup>9+</sup>
+
+getOsAccountType(callback: AsyncCallback&lt;OsAccountType&gt;): void
+
+查询当前进程所属的系统帐号的帐号类型，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                                                 | 必填 | 说明                                                 |
+| -------- | ---------------------------------------------------- | ---- | ---------------------------------------------------- |
+| callback | AsyncCallback&lt;[OsAccountType](#osaccounttype)&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号类型。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getOsAccountType((err, accountType) => {
+      console.log('getOsAccountType err: ' + JSON.stringify(err));
+      console.log('getOsAccountType accountType: ' + accountType);
+    });
+  } catch (e) {
+    console.log('getOsAccountType exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### getOsAccountType<sup>9+</sup>
+
+getOsAccountType(): Promise&lt;OsAccountType&gt;
+
+查询当前进程所属的系统帐号的帐号类型，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                                           | 说明                                                         |
+| :--------------------------------------------- | :----------------------------------------------------------- |
+| Promise&lt;[OsAccountType](#osaccounttype)&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号类型。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getOsAccountType().then((accountType) => {
+      console.log('getOsAccountType, accountType: ' + accountType);
+    }).catch((err) => {
+      console.log('getOsAccountType err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('getOsAccountType exception: ' + JSON.stringify(e));
+  }
   ```
 
-### getOsAccountTypeFromProcess
+### getOsAccountTypeFromProcess<sup>(deprecated)</sup>
 
 getOsAccountTypeFromProcess(callback: AsyncCallback&lt;OsAccountType&gt;): void
 
 查询当前进程所属的系统帐号的帐号类型，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountType](#getosaccounttype9)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -1346,12 +2378,16 @@ getOsAccountTypeFromProcess(callback: AsyncCallback&lt;OsAccountType&gt;): void
   });
   ```
 
-### getOsAccountTypeFromProcess
+### getOsAccountTypeFromProcess<sup>(deprecated)</sup>
 
 getOsAccountTypeFromProcess(): Promise&lt;OsAccountType&gt;
 
 查询当前进程所属的系统帐号的帐号类型，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountType](#getosaccounttype9-1)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **返回值：**
@@ -1371,12 +2407,77 @@ getOsAccountTypeFromProcess(): Promise&lt;OsAccountType&gt;
   });
   ```
 
-### getDistributedVirtualDeviceId
+### queryDistributedVirtualDeviceId<sup>9+</sup>
+
+queryDistributedVirtualDeviceId(callback: AsyncCallback&lt;string&gt;): void
+
+获取分布式虚拟设备ID，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS or ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                        | 必填 | 说明                                 |
+| -------- | --------------------------- | ---- | ------------------------------------ |
+| callback | AsyncCallback&lt;string&gt; | 是   | 回调结果，返回的是分布式虚拟设备ID。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.queryDistributedVirtualDeviceId((err, virtualID) => {
+      console.log('queryDistributedVirtualDeviceId err: ' + JSON.stringify(err));
+      console.log('queryDistributedVirtualDeviceId virtualID: ' + virtualID);
+    });
+  } catch (e) {
+    console.log('queryDistributedVirtualDeviceId exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### queryDistributedVirtualDeviceId<sup>9+</sup>
+
+queryDistributedVirtualDeviceId(): Promise&lt;string&gt;
+
+获取分布式虚拟设备ID，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;string&gt; | Promise实例，用于获取异步返回结果，返回的是分布式虚拟设备ID。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.queryDistributedVirtualDeviceId().then((virtualID) => {
+      console.log('queryDistributedVirtualDeviceId, virtualID: ' + virtualID);
+    }).catch((err) => {
+      console.log('queryDistributedVirtualDeviceId err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('queryDistributedVirtualDeviceId exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### getDistributedVirtualDeviceId<sup>(deprecated)</sup>
 
 getDistributedVirtualDeviceId(callback: AsyncCallback&lt;string&gt;): void
 
 获取分布式虚拟设备ID，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryDistributedVirtualDeviceId](#querydistributedvirtualdeviceid9)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 或 ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -1397,12 +2498,16 @@ getDistributedVirtualDeviceId(callback: AsyncCallback&lt;string&gt;): void
   });
   ```
 
-### getDistributedVirtualDeviceId
+### getDistributedVirtualDeviceId<sup>(deprecated)</sup>
 
 getDistributedVirtualDeviceId(): Promise&lt;string&gt;
 
 获取分布式虚拟设备ID，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryDistributedVirtualDeviceId](#querydistributedvirtualdeviceid9-1)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 或 ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -1448,10 +2553,14 @@ getOsAccountProfilePhoto(localId: number, callback: AsyncCallback&lt;string&gt;)
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.getOsAccountProfilePhoto(localId, (err, photo)=>{
       console.log('getOsAccountProfilePhoto err:' + JSON.stringify(err));
       console.log('get photo:' + photo + ' by localId: ' + localId);
     });
+  } catch (e) {
+    console.log('getOsAccountProfilePhoto exception:' + JSON.stringify(e));
+  }
   ```
 
 ### getOsAccountProfilePhoto
@@ -1483,11 +2592,15 @@ getOsAccountProfilePhoto(localId: number): Promise&lt;string&gt;
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
+  try {
     accountManager.getOsAccountProfilePhoto(localId).then((photo) => {
       console.log('getOsAccountProfilePhoto: ' + photo);
     }).catch((err) => {
       console.log('getOsAccountProfilePhoto err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('getOsAccountProfilePhoto exception:' + JSON.stringify(e));
+  }
   ```
 
 ### setOsAccountProfilePhoto
@@ -1519,9 +2632,13 @@ setOsAccountProfilePhoto(localId: number, photo: string, callback: AsyncCallback
   'Cxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACwSURBVDhPvZLBDYMwDEV/ugsXRjAT0EHCOuFIBwkbdIRewi6unbiAyoGgSn1SFH85+Y'+
   'q/4ljARW62X+LHS8uIzjm4dXUYF+utzBikB52Jo5e5iEPKqpACk7R9NM2RvWm5tIkD2czLCUFNKLD6IjdMHFHDzws285MgGrT0xCtp3WOKHo'+
   '+7q0mP0DZW9pNmoEFUzrQjp5cCnaen2kSJXLFD8ghbXyZCMQf/8e8Ns1XVAG/XAgqKzVnJFAAAAABJRU5ErkJggg=='
+  try {
     accountManager.setOsAccountProfilePhoto(localId, photo, (err)=>{
       console.log('setOsAccountProfilePhoto err:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setOsAccountProfilePhoto exception:' + JSON.stringify(e));
+  }
   ```
 
 ### setOsAccountProfilePhoto
@@ -1558,19 +2675,93 @@ setOsAccountProfilePhoto(localId: number, photo: string): Promise&lt;void&gt;
   'Cxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACwSURBVDhPvZLBDYMwDEV/ugsXRjAT0EHCOuFIBwkbdIRewi6unbiAyoGgSn1SFH85+Y'+
   'q/4ljARW62X+LHS8uIzjm4dXUYF+utzBikB52Jo5e5iEPKqpACk7R9NM2RvWm5tIkD2czLCUFNKLD6IjdMHFHDzws285MgGrT0xCtp3WOKHo'+
   '+7q0mP0DZW9pNmoEFUzrQjp5cCnaen2kSJXLFD8ghbXyZCMQf/8e8Ns1XVAG/XAgqKzVnJFAAAAABJRU5ErkJggg=='
+  try {
     accountManager.setOsAccountProfilePhoto(localId, photo).then(() => {
       console.log('setOsAccountProfilePhoto success');
     }).catch((err) => {
       console.log('setOsAccountProfilePhoto err: '  + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setOsAccountProfilePhoto exception:' + JSON.stringify(e));
+  }
+  ```
+
+### queryOsAccountLocalIdBySerialNumber<sup>9+</sup>
+
+queryOsAccountLocalIdBySerialNumber(serialNumber: number, callback: AsyncCallback&lt;number&gt;): void
+
+通过SN码查询与其关联的系统帐号的帐号ID，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名       | 类型                        | 必填 | 说明                                             |
+| ------------ | --------------------------- | ---- | ------------------------------------------------ |
+| serialNumber | number                      | 是   | 帐号SN码。                                       |
+| callback     | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是与SN码关联的系统帐号的帐号ID。 |
+
+**示例：** 查询与SN码12345关联的系统帐号的ID
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let serialNumber = 12345;
+  try {
+    accountManager.queryOsAccountLocalIdBySerialNumber(serialNumber, (err, localId)=>{
+      console.log('ger localId err:' + JSON.stringify(err));
+      console.log('get localId:' + localId + ' by serialNumber: ' + serialNumber);
+    });
+  } catch (e) {
+    console.log('ger localId exception:' + JSON.stringify(e));
+  }
+  ```
+
+### queryOsAccountLocalIdBySerialNumber<sup>9+</sup>
+
+queryOsAccountLocalIdBySerialNumber(serialNumber: number): Promise&lt;number&gt;
+
+通过SN码查询与其关联的系统帐号的帐号ID，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名       | 类型   | 必填 | 说明       |
+| ------------ | ------ | ---- | ---------- |
+| serialNumber | number | 是   | 帐号SN码。 |
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是与SN码关联的系统帐号的帐号ID。 |
+
+**示例：** 查询与SN码12345关联的系统帐号的ID
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let serialNumber = 12345;
+  try {
+    accountManager.queryOsAccountLocalIdBySerialNumber(serialNumber).then((localId) => {
+      console.log('queryOsAccountLocalIdBySerialNumber localId: ' + localId);
+    }).catch((err) => {
+      console.log('queryOsAccountLocalIdBySerialNumber err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdBySerialNumber exception: '  + JSON.stringify(e));
+  }
   ```
 
-### getOsAccountLocalIdBySerialNumber<sup>8+</sup>
+### getOsAccountLocalIdBySerialNumber<sup>(deprecated)</sup>
 
 getOsAccountLocalIdBySerialNumber(serialNumber: number, callback: AsyncCallback&lt;number&gt;): void
 
 通过SN码查询与其关联的系统帐号的帐号ID，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdBySerialNumber](#queryosaccountlocalidbyserialnumber9)
+>
+> 从 API version 8开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -1591,12 +2782,16 @@ getOsAccountLocalIdBySerialNumber(serialNumber: number, callback: AsyncCallback&
   });
   ```
 
-### getOsAccountLocalIdBySerialNumber<sup>8+</sup>
+### getOsAccountLocalIdBySerialNumber<sup>(deprecated)</sup>
 
 getOsAccountLocalIdBySerialNumber(serialNumber: number): Promise&lt;number&gt;
 
 通过SN码查询与其关联的系统帐号的帐号ID，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdBySerialNumber](#queryosaccountlocalidbyserialnumber9-1)
+>
+> 从 API version 8开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -1623,12 +2818,82 @@ getOsAccountLocalIdBySerialNumber(serialNumber: number): Promise&lt;number&gt;
   });
   ```
 
-### getSerialNumberByOsAccountLocalId<sup>8+</sup>
+### querySerialNumberByOsAccountLocalId<sup>9+</sup>
+
+querySerialNumberByOsAccountLocalId(localId: number, callback: AsyncCallback&lt;number&gt;): void
+
+通过系统帐号ID获取与该系统帐号关联的SN码，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                        | 必填 | 说明                                       |
+| -------- | --------------------------- | ---- | ------------------------------------------ |
+| localId  | number                      | 是   | 系统帐号ID。                               |
+| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是与该系统帐号关联的SN码。 |
+
+**示例：** 获取ID为100的系统帐号关联的SN码
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let localId = 100;
+  try {
+    accountManager.querySerialNumberByOsAccountLocalId(localId, (err, serialNumber)=>{
+      console.log('ger serialNumber err:' + JSON.stringify(err));
+      console.log('get serialNumber:' + serialNumber + ' by localId: ' + localId);
+    });
+  } catch (e) {
+    console.log('ger serialNumber exception:' + JSON.stringify(e));
+  }
+  ```
+
+### querySerialNumberByOsAccountLocalId<sup>9+</sup>
+
+querySerialNumberByOsAccountLocalId(localId: number): Promise&lt;number&gt;
+
+通过系统帐号ID获取与该系统帐号关联的SN码，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明         |
+| ------- | ------ | ---- | ------------ |
+| localId | number | 是   | 系统帐号ID。 |
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是与该系统帐号关联的SN码。 |
+
+**示例：** 获取ID为100的系统帐号关联的SN码
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let localId = 100;
+  try {
+    accountManager.querySerialNumberByOsAccountLocalId(localId).then((serialNumber) => {
+      console.log('querySerialNumberByOsAccountLocalId serialNumber: ' + serialNumber);
+    }).catch((err) => {
+      console.log('querySerialNumberByOsAccountLocalId err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('querySerialNumberByOsAccountLocalId exception:' + JSON.stringify(e));
+  }
+  ```
+
+### getSerialNumberByOsAccountLocalId<sup>(deprecated)</sup>
 
 getSerialNumberByOsAccountLocalId(localId: number, callback: AsyncCallback&lt;number&gt;): void
 
 通过系统帐号ID获取与该系统帐号关联的SN码，使用callback回调异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[querySerialNumberByOsAccountLocalId](#queryserialnumberbyosaccountlocalid9)
+>
+> 从 API version 8开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -1649,12 +2914,16 @@ getSerialNumberByOsAccountLocalId(localId: number, callback: AsyncCallback&lt;nu
   });
   ```
 
-### getSerialNumberByOsAccountLocalId<sup>8+</sup>
+### getSerialNumberByOsAccountLocalId<sup>(deprecated)</sup>
 
 getSerialNumberByOsAccountLocalId(localId: number): Promise&lt;number&gt;
 
 通过系统帐号ID获取与该系统帐号关联的SN码，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[querySerialNumberByOsAccountLocalId](#queryserialnumberbyosaccountlocalid9-1)
+>
+> 从 API version 8开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
@@ -1708,7 +2977,11 @@ on(type: 'activate' | 'activating', name: string, callback: Callback&lt;number&g
   function onCallback(receiveLocalId){
     console.log('receive localId:' + receiveLocalId);
   }
+  try {
     accountManager.on('activating', 'osAccountOnOffNameA', onCallback);
+  } catch (e) {
+    console.log('receive localId exception:' + JSON.stringify(e));
+  }
   ```
 
 ### off
@@ -1738,7 +3011,11 @@ off(type: 'activate' | 'activating', name: string, callback?: Callback&lt;number
   function offCallback(){
     console.log('off enter')
   }
+  try {
     accountManager.off('activating', 'osAccountOnOffNameA', offCallback);
+  } catch (e) {
+    console.log('off exception:' + JSON.stringify(e));
+  }
   ```
 
 ### getBundleIdFromUid<sup>9+</sup>
@@ -1763,10 +3040,14 @@ getBundleIdFromUid(uid: number, callback: AsyncCallback&lt;number&gt;): void;
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let testUid = 1000000;
+  try {
     accountManager.getBundleIdFromUid(testUid, (err, bundleId) => {
       console.info('getBundleIdFromUid errInfo:' + JSON.stringify(err));
       console.info('getBundleIdFromUid bundleId:' + JSON.stringify(bundleId));
     });
+  } catch (e) {
+    console.info('getBundleIdFromUid exception:' + JSON.stringify(e));
+  }
   ```
 ### getBundleIdFromUid<sup>9+</sup>
 
@@ -1795,11 +3076,15 @@ getBundleIdFromUid(uid: number): Promise&lt;number&gt;;
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let testUid = 1000000;
+  try {
     accountManager.getBundleIdFromUid(testUid).then((result) => {
       console.info('getBundleIdFromUid bundleId:' + JSON.stringify(result));
     }).catch((err)=>{
       console.info('getBundleIdFromUid errInfo:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.info('getBundleIdFromUid exception:' + JSON.stringify(e));
+  }
   ```
 
 ### isMainOsAccount<sup>9+</sup>
@@ -1810,7 +3095,7 @@ isMainOsAccount(callback: AsyncCallback&lt;boolean&gt;): void;
 
 此接口为系统接口，三方应用不支持调用。
 
-**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -1824,10 +3109,14 @@ isMainOsAccount(callback: AsyncCallback&lt;boolean&gt;): void;
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.isMainOsAccount((err,result)=>{
       console.info('isMainOsAccount errInfo:' + JSON.stringify(err));
       console.info('isMainOsAccount result:' + JSON.stringify(result));
     });
+  } catch (e) {
+    console.info('isMainOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 ### isMainOsAccount<sup>9+</sup>
 
@@ -1837,7 +3126,7 @@ isMainOsAccount(): Promise&lt;boolean&gt;;
 
 此接口为系统接口，三方应用不支持调用。
 
-**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -1851,11 +3140,15 @@ isMainOsAccount(): Promise&lt;boolean&gt;;
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.isMainOsAccount().then((result) => {
       console.info('isMainOsAccount result:' + JSON.stringify(result));
     }).catch((err)=>{
       console.info('isMainOsAccount errInfo:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.info('isMainOsAccount exception:' + JSON.stringify(e));
+  }
   ```
 ### queryOsAccountConstraintSourceTypes<sup>9+</sup>
 
@@ -1865,7 +3158,7 @@ queryOsAccountConstraintSourceTypes(localId: number, constraint: string, callbac
 
 此接口为系统接口，三方应用不支持调用。
 
-**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -1881,10 +3174,14 @@ queryOsAccountConstraintSourceTypes(localId: number, constraint: string, callbac
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.queryOsAccountConstraintSourceTypes(100, 'constraint.wifi',(err,sourceTypeInfos)=>{
       console.info('queryOsAccountConstraintSourceType errInfo:' + JSON.stringify(err));
       console.info('queryOsAccountConstraintSourceType sourceTypeInfos:' + JSON.stringify(sourceTypeInfos));
     });
+  } catch (e) {
+    console.info('queryOsAccountConstraintSourceType exception:' + JSON.stringify(e));
+  }
   ```
 
 ### queryOsAccountConstraintSourceTypes<sup>9+</sup>
@@ -1895,7 +3192,7 @@ queryOsAccountConstraintSourceTypes(localId: number, constraint: string): Promis
 
 此接口为系统接口，三方应用不支持调用。
 
-**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -1916,11 +3213,15 @@ queryOsAccountConstraintSourceTypes(localId: number, constraint: string): Promis
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
+  try {
     accountManager.queryOsAccountConstraintSourceTypes(100, 'constraint.wifi').then((result) => {
       console.info('queryOsAccountConstraintSourceType sourceTypeInfos:' + JSON.stringify(result));
     }).catch((err)=>{
       console.info('queryOsAccountConstraintSourceType errInfo:' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.info('queryOsAccountConstraintSourceType exception:' + JSON.stringify(e));
+  }
   ```
 
 ## UserAuth<sup>8+</sup>
@@ -1998,8 +3299,12 @@ getAvailableStatus(authType: AuthType, authTrustLevel: AuthTrustLevel): number;
   let userAuth = new account_osAccount.UserAuth();
   let authType = account_osAccount.AuthType.PIN;
   let authTrustLevel = account_osAccount.AuthTrustLevel.ATL1;
+  try {
     let status = userAuth.getAvailableStatus(authType, authTrustLevel);
     console.log('getAvailableStatus status = ' + status);
+  } catch (e) {
+    console.log('getAvailableStatus exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### getProperty<sup>8+</sup>
@@ -2033,10 +3338,14 @@ getProperty(request: GetPropertyRequest, callback: AsyncCallback&lt;ExecutorProp
     authType: account_osAccount.AuthType.PIN,
     keys: keys
   };
+  try {
     userAuth.getProperty(request, (err, result) => {
       console.log('getProperty err = ' + JSON.stringify(err));
       console.log('getProperty result = ' + JSON.stringify(result));
     });
+  } catch (e) {
+    console.log('getProperty exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### getProperty<sup>8+</sup>
@@ -2075,11 +3384,15 @@ getProperty(request: GetPropertyRequest): Promise&lt;ExecutorProperty&gt;;
     authType: account_osAccount.AuthType.PIN,
     keys: keys
   };
+  try {
     userAuth.getProperty(request).then((result) => {
       console.log('getProperty result = ' + JSON.stringify(result));
     }).catch((err) => {
       console.log('getProperty error = ' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('getProperty exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### setProperty<sup>8+</sup>
@@ -2109,10 +3422,14 @@ setProperty(request: SetPropertyRequest, callback: AsyncCallback&lt;number&gt;):
     key: account_osAccount.SetPropertyType.INIT_ALGORITHM,
     setInfo: new Uint8Array([0])
   };
+  try {
     userAuth.setProperty(request, (err, result) => {
         console.log('setProperty error = ' + JSON.stringify(err));
         console.log('setProperty result = ' + JSON.stringify(result));
     });
+  } catch (e) {
+    console.log('setProperty exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### setProperty<sup>8+</sup>
@@ -2147,11 +3464,15 @@ setProperty(request: SetPropertyRequest): Promise&lt;number&gt;;
     key: account_osAccount.SetPropertyType.INIT_ALGORITHM,
     setInfo: new Uint8Array([0])
   };
+  try {
     userAuth.setProperty(request).then((result) => {
       console.log('setProperty result = ' + JSON.stringify(result));
     }).catch((err) => {
       console.log('setProperty error = ' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('setProperty exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### auth<sup>8+</sup>
@@ -2188,12 +3509,16 @@ auth(challenge: Uint8Array, authType: AuthType, authTrustLevel: AuthTrustLevel,
   let challenge = new Uint8Array([0]);
   let authType = account_osAccount.AuthType.PIN;
   let authTrustLevel = account_osAccount.AuthTrustLevel.ATL1;
+  try {
     userAuth.auth(challenge, authType, authTrustLevel, {
       onResult: function(result,extraInfo){
           console.log('auth result = ' + result);
           console.log('auth extraInfo = ' + JSON.stringify(extraInfo));
       }
     });
+  } catch (e) {
+    console.log('auth exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### authUser<sup>8+</sup>
@@ -2232,17 +3557,21 @@ authUser(userId: number, challenge: Uint8Array, authType: AuthType, authTrustLev
   let challenge = new Uint8Array([0]);
   let authType = account_osAccount.AuthType.PIN;
   let authTrustLevel = account_osAccount.AuthTrustLevel.ATL1;
+  try {
     userAuth.authUser(userID, challenge, authType, authTrustLevel, {
       onResult: function(result,extraInfo){
           console.log('authUser result = ' + result);
           console.log('authUser extraInfo = ' + JSON.stringify(extraInfo));
       }
     });
+  } catch (e) {
+    console.log('authUser exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### cancelAuth<sup>8+</sup>
 
-cancelAuth(contextID: Uint8Array): number;
+cancelAuth(contextID: Uint8Array): void;
 
 取消特定的认证。
 
@@ -2258,12 +3587,6 @@ cancelAuth(contextID: Uint8Array): number;
 | ----------| ---------- | ---- | ------------------------------------------ |
 | contextID | Uint8Array | 是   | 指示身份验证上下文ID，此ID动态生成没有具体值。 |
 
-**返回值：**
-
-| 类型   | 说明                                                       |
-| :----- | :-------------------------------------------------------- |
-| number | 返回一个[数字](#resultcode8)，指示取消是否成功。 |
-
 **示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
@@ -2275,8 +3598,11 @@ cancelAuth(contextID: Uint8Array): number;
       console.log('auth extraInfo = ' + JSON.stringify(extraInfo));
     }
   });
-  let result = userAuth.cancelAuth(contextID);
-  console.log('cancelAuth result = ' + result);
+  try {
+    userAuth.cancelAuth(contextID);
+  } catch (e) {
+    console.log('cancelAuth exception = ' + JSON.stringify(e));
+  }
   ```
 
 ## PINAuth<sup>8+</sup>
@@ -2300,7 +3626,7 @@ constructor()
   let pinAuth = new account_osAccount.PINAuth();
   ```
 
-### registerInputer
+### registerInputer<sup>8+</sup>
 
 registerInputer(inputer: IInputer): boolean;
 
@@ -2328,15 +3654,19 @@ registerInputer(inputer: IInputer): boolean;
   ```js
   let pinAuth = new account_osAccount.PINAuth();
   let password = new Uint8Array([0, 0, 0, 0, 0]);
+  try {
     let result = pinAuth.registerInputer({
         onGetData: (pinSubType, callback) => {
           callback.onSetData(pinSubType, password);
         }
     });
     console.log('registerInputer result = ' + result);
+  } catch (e) {
+    console.log('registerInputer exception = ' + JSON.stringify(e));
+  }
   ```
 
-### unregisterInputer
+### unregisterInputer<sup>8+</sup>
 
 unregisterInputer(): void;
 
@@ -2396,10 +3726,14 @@ openSession(callback: AsyncCallback&lt;Uint8Array&gt;): void;
 **示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
+  try {
     userIDM.openSession((err, challenge) => {
         console.log('openSession error = ' + JSON.stringify(err));
         console.log('openSession challenge = ' + JSON.stringify(challenge));
     });
+  } catch (e) {
+    console.log('openSession exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### openSession<sup>8+</sup>
@@ -2423,11 +3757,15 @@ openSession(): Promise&lt;Uint8Array&gt;;
 **示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
+  try {
     userIDM.openSession().then((challenge) => {
         console.info('openSession challenge = ' + JSON.stringify(challenge));
     }).catch((err) => {
         console.info('openSession error = ' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('openSession exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### addCredential<sup>8+</sup>
@@ -2465,12 +3803,16 @@ addCredential(credentialInfo: CredentialInfo, callback: IIdmCallback): void;
   };
   let userIDM = new account_osAccount.UserIdentityManager();
   userIDM.openSession((err, challenge) => {
+    try {
     userIDM.addCredential(credentialInfo, {
       onResult: (result, extraInfo) => {
         console.log('updateCredential result = ' + result);
         console.log('updateCredential extraInfo = ' + extraInfo);
       }
     });
+    } catch (e) {
+      console.log('updateCredential exception = ' + JSON.stringify(e));
+    }
   });
   ```
 
@@ -2516,12 +3858,16 @@ updateCredential(credentialInfo: CredentialInfo, callback: IIdmCallback): void;
           return;
         }
         credentialInfo.token = extraInfo.token;
+        try {
           userIDM.updateCredential(credentialInfo, {
             onResult: (result, extraInfo) => {
                 console.log('updateCredential result = ' + result);
                 console.log('updateCredential extraInfo = ' + extraInfo);
             }
           });
+        } catch (e) {
+          console.log('updateCredential exception = ' + JSON.stringify(e));
+        }
       }
     });
   });
@@ -2547,7 +3893,7 @@ closeSession(): void;
 
 ### cancel<sup>8+</sup>
 
-cancel(challenge: Uint8Array): number;
+cancel(challenge: Uint8Array): void;
 
 根据挑战值取消条目。
 
@@ -2563,18 +3909,16 @@ cancel(challenge: Uint8Array): number;
 | -------- | ----------- | ---- | ----- |
 | challenge | Uint8Array | 是   | 挑战值。 |
 
-**返回值：**
-
-| 类型   | 说明                                                       |
-| :----- | :-------------------------------------------------------- |
-| number | 返回一个[数字](#resultcode8)，指示取消是否成功。 |
 
 **示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
   let challenge = new Uint8Array([0]);
-  let result = userIDM.cancel(challenge);
-  console.log('cancel result: ' + result);
+  try {
+    userIDM.cancel(challenge);
+  } catch(err) {
+    console.log("cancel err:" + JSON.stringify(err));
+  }
   ```
 
 ### delUser<sup>8+</sup>
@@ -2600,12 +3944,16 @@ delUser(token: Uint8Array, callback: IIdmCallback): void;
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
   let token = new Uint8Array([0]);
+  try {
     userIDM.delUser(token, {
       onResult: (result, extraInfo) => {
         console.log('delUser result = ' + result);
         console.log('delUser extraInfo = ' + JSON.stringify(extraInfo));
       }
     });
+  } catch (e) {
+    console.log('delUser exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### delCred<sup>8+</sup>
@@ -2633,12 +3981,16 @@ delCred(credentialId: Uint8Array, token: Uint8Array, callback: IIdmCallback): vo
   let userIDM = new account_osAccount.UserIdentityManager();
   let credentialId = new Uint8Array([0]);
   let token = new Uint8Array([0]);
+  try {
     userIDM.delCred(credentialId, token, {
       onResult: (result, extraInfo) => {
           console.log('delCred result = ' + result);
           console.log('delCred extraInfo = ' + JSON.stringify(extraInfo));
       }
     });
+  } catch (e) {
+    console.log('delCred exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### getAuthInfo<sup>8+</sup>
@@ -2663,10 +4015,14 @@ getAuthInfo(callback: AsyncCallback&lt;Array&lt;EnrolledCredInfo&gt;&gt;): void;
 **示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
+  try {
     userIDM.getAuthInfo((err, result) => {
       console.log('getAuthInfo err = ' + JSON.stringify(err));
       console.log('getAuthInfo result = ' + JSON.stringify(result));
     });
+  } catch (e) {
+    console.log('getAuthInfo exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### getAuthInfo<sup>8+</sup>
@@ -2691,10 +4047,14 @@ getAuthInfo(authType: AuthType, callback: AsyncCallback&lt;Array&lt;EnrolledCred
 **示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
+  try {
     userIDM.getAuthInfo(account_osAccount.AuthType.PIN, (err, result) => {
       console.log('getAuthInfo err = ' + JSON.stringify(err));
       console.log('getAuthInfo result = ' + JSON.stringify(result));
     });
+  } catch (e) {
+    console.log('getAuthInfo exception = ' + JSON.stringify(e));
+  }
   ```
 
 ### getAuthInfo<sup>8+</sup>
@@ -2724,11 +4084,15 @@ getAuthInfo(authType?: AuthType): Promise&lt;Array&lt;EnrolledCredInfo&gt;&gt;;
 **示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
+  try {
     userIDM.getAuthInfo(account_osAccount.AuthType.PIN).then((result) => {
       console.log('getAuthInfo result = ' + JSON.stringify(result))
     }).catch((err) => {
       console.log('getAuthInfo error = ' + JSON.stringify(err));
     });
+  } catch (e) {
+    console.log('getAuthInfo exception = ' + JSON.stringify(e));
+  }
   ```
 
 ## IInputData<sup>8+</sup>