!10403 api异常处理的OS账号和分布式账号docs修改

Merge pull request !10403 from libing23/master

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
 
@@ -55,18 +118,21 @@ queryOsAccountDistributedInfo(callback: AsyncCallback&lt;DistributedInfo&gt;): v
 **示例：**
   ```js
   const accountAbility = account_distributedAccount.getDistributedAccountAbility();
-  accountAbility.queryOsAccountDistributedInfo((err, data) => { 
+  accountAbility.queryOsAccountDistributedInfo((err, data) => {
       console.log("queryOsAccountDistributedInfo err: " + JSON.stringify(err));
       console.log('Query account info name: ' + data.name);
       console.log('Query account info id: ' + data.id);
   });
   ```
 
-### queryOsAccountDistributedInfo
+### queryOsAccountDistributedInfo<sup>(deprecated)</sup>
 
 queryOsAccountDistributedInfo(): Promise&lt;DistributedInfo&gt;
 
 获取分布式帐号信息，使用Promise方式异步返回结果。
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountDistributedInfo](#getosaccountdistributedinfo9-1)
+>
+> 从 API version 7开始支持。
 
 **系统能力：** SystemCapability.Account.OsAccount
 
@@ -81,7 +147,7 @@ queryOsAccountDistributedInfo(): Promise&lt;DistributedInfo&gt;
 **示例：**
   ```js
   const accountAbility = account_distributedAccount.getDistributedAccountAbility();
-  accountAbility.queryOsAccountDistributedInfo().then((data) => { 
+  accountAbility.queryOsAccountDistributedInfo().then((data) => {
       console.log('Query account info name: ' + data.name);
       console.log('Query account info id: ' + data.id);
   }).catch((err) => {
@@ -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
 
@@ -110,17 +245,19 @@ updateOsAccountDistributedInfo(accountInfo: DistributedInfo, callback: AsyncCall
   ```js
   const accountAbility = account_distributedAccount.getDistributedAccountAbility();
   let accountInfo = {id: '12345', name: 'ZhangSan', event: 'Ohos.account.event.LOGIN'};
-  accountAbility.updateOsAccountDistributedInfo(accountInfo, (err) => { 
+  accountAbility.updateOsAccountDistributedInfo(accountInfo, (err) => {
       console.log("queryOsAccountDistributedInfo err: " + JSON.stringify(err));
   });
   ```
 
-### 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

@@ -26,7 +26,7 @@ getAccountManager(): AccountManager
 | --------------------------------- | ------------------------ |
 | [AccountManager](#accountmanager) | 获取系统帐号能力的实例。 |
 
-**示例：** 
+**示例：**
   ```js
   let accountManager = account_osAccount.getAccountManager();
   ```
@@ -70,9 +70,13 @@ activateOsAccount(localId: number, callback: AsyncCallback<void>): void
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
-  accountManager.activateOsAccount(localId, (err)=>{
-    console.log('activateOsAccount err:' + JSON.stringify(err));
-  });
+  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;
-  accountManager.activateOsAccount(localId).then(() => {
-    console.log('activateOsAccount success');
-  }).catch((err) => {
-    console.log('activateOsAccount err:' + JSON.stringify(err));
-  });
+  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));
+  }
+  ```
+
+### 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));
+  }
   ```
 
-### isMultiOsAccountEnable
+### 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
 
 **参数：**
@@ -124,7 +193,7 @@ isMultiOsAccountEnable(callback: AsyncCallback&lt;boolean&gt;): void
 | -------- | ---------------------------- | ---- | --------------------------------------------------- |
 | callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，支持多系统帐号则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
 
 **返回值：**
@@ -148,7 +221,7 @@ isMultiOsAccountEnable(): Promise&lt;boolean&gt;
 | :--------------------- | :----------------------------------------------------------- |
 | Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，支持多系统帐号则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
 
 **参数：**
@@ -299,7 +591,7 @@ isTestOsAccount(callback: AsyncCallback&lt;boolean&gt;): void
 | -------- | ---------------------------- | ---- | ----------------------------------------------- |
 | callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，是测试帐号则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
 
 **返回值：**
@@ -323,7 +619,7 @@ isTestOsAccount(): Promise&lt;boolean&gt;
 | :--------------------- | :----------------------------------------------------------- |
 | Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，是测试帐号则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
 
 **参数：**
@@ -348,7 +746,7 @@ isOsAccountVerified(callback: AsyncCallback&lt;boolean&gt;): void
 | -------- | ---------------------------- | ---- | ------------------------------------------- |
 | callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，已验证则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
@@ -375,7 +777,7 @@ isOsAccountVerified(localId: number, callback: AsyncCallback&lt;boolean&gt;): vo
 | localId  | number                       | 否   | 指定的系统帐号ID。                          |
 | callback | AsyncCallback&lt;boolean&gt; | 是   | 回调结果，已验证则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
@@ -407,7 +813,7 @@ isOsAccountVerified(localId?: number): Promise&lt;boolean&gt;
 | :--------------------- | :----------------------------------------------------------- |
 | Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，已验证则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -437,15 +843,19 @@ removeOsAccount(localId: number, callback: AsyncCallback&lt;void&gt;): void
 | localId  | number                    | 是   | 要删除的系统帐号ID。 |
 | callback | AsyncCallback&lt;void&gt; | 是   | 回调结果。           |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.createOsAccount('testAccountName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo) => {
-    accountManager.removeOsAccount(osAccountInfo.localId, (err)=>{
-      console.log('removeOsAccount err:' + JSON.stringify(err));
+  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
@@ -472,17 +882,21 @@ removeOsAccount(localId: number): Promise&lt;void&gt;
 | :------------------ | :---------------------------------- |
 | Promise&lt;void&gt; | Promise实例，用于获取异步返回结果。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.createOsAccount('testAccountName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo)=>{
-    accountManager.removeOsAccount(osAccountInfo.localId).then(() => {
-      console.log('removeOsAccount Success');
-    }).catch(() => {
-      console.log('removeOsAccount err: '  + JSON.stringify(err));
+  try {
+    accountManager.createOsAccount('testAccountName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo)=>{
+      accountManager.removeOsAccount(osAccountInfo.localId).then(() => {
+        console.log('removeOsAccount Success');
+      }).catch(() => {
+        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;
-  accountManager.setOsAccountConstraints(localId, ['constraint.wifi'], true, (err)=>{
-    console.log('setOsAccountConstraints err:' + JSON.stringify(err));
-  });
+  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;
-  accountManager.setOsAccountConstraints(localId, ['constraint.location.set'], false).then(() => {
-    console.log('setOsAccountConstraints Success');
-  }).catch((err) => {
-    console.log('setOsAccountConstraints err: '  + JSON.stringify(err));
-  });
+  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';
-  accountManager.setOsAccountName(localId, newName, (err)=>{
-    console.debug('setOsAccountName err:' + JSON.stringify(err));
-  });
+  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';
-  accountManager.setOsAccountName(localId, nameLimit).then(() => {
-    console.log('setOsAccountName Success');
-  }).catch((err) => {
-    console.log('setOsAccountName err: '  + JSON.stringify(err));
-  });
+  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));
+  }
   ```
 
-### getCreatedOsAccountsCount
+### 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<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
@@ -639,7 +1134,7 @@ getCreatedOsAccountsCount(callback: AsyncCallback&lt;number&gt;): void
 | -------- | --------------------------- | ---- | ------------------------------------------ |
 | callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是已创建的系统帐号的数量。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -649,12 +1144,16 @@ getCreatedOsAccountsCount(callback: AsyncCallback&lt;number&gt;): void
   });
   ```
 
-### getCreatedOsAccountsCount
+### getCreatedOsAccountsCount<sup>(deprecated)</sup>
 
 getCreatedOsAccountsCount(): Promise&lt;number&gt;
 
 获取已创建的系统帐号数量，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountCount](#getosaccountcount9-1)
+>
+> 从 API version 7开始支持。
+
 **需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
@@ -665,7 +1164,7 @@ getCreatedOsAccountsCount(): Promise&lt;number&gt;
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是已创建的系统帐号的数量。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -676,12 +1175,73 @@ getCreatedOsAccountsCount(): Promise&lt;number&gt;
   });
   ```
 
-### getOsAccountLocalIdFromProcess
+### 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
 
 **参数：**
@@ -690,7 +1250,7 @@ getOsAccountLocalIdFromProcess(callback: AsyncCallback&lt;number&gt;): void
 | -------- | --------------------------- | ---- | -------------------------------------------------- |
 | callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -700,12 +1260,16 @@ getOsAccountLocalIdFromProcess(callback: AsyncCallback&lt;number&gt;): void
   });
   ```
 
-### getOsAccountLocalIdFromProcess
+### getOsAccountLocalIdFromProcess<sup>(deprecated)</sup>
 
 getOsAccountLocalIdFromProcess(): Promise&lt;number&gt;
 
 获取当前进程所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
 
+> **说明：** 从API version 9开始废弃，建议使用[queryOsAccountLocalIdFromProcess](#queryosaccountlocalidfromprocess9-1)
+>
+> 从 API version 7开始支持。
+
 **系统能力：** SystemCapability.Account.OsAccount
 
 **返回值：**
@@ -714,7 +1278,7 @@ getOsAccountLocalIdFromProcess(): Promise&lt;number&gt;
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -725,12 +1289,82 @@ getOsAccountLocalIdFromProcess(): Promise&lt;number&gt;
   });
   ```
 
-### getOsAccountLocalIdFromUid
+### queryOsAccountLocalIdFromUid<sup>9+</sup>
+
+queryOsAccountLocalIdFromUid(uid: number, callback: AsyncCallback&lt;number&gt;): void
+
+从进程uid中获取该uid所属的系统帐号的帐号ID，使用callback回调异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                        | 必填 | 说明                                          |
+| -------- | --------------------------- | ---- | --------------------------------------------- |
+| uid      | number                      | 是   | 进程uid。                                     |
+| callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是uid所属的系统帐号的帐号ID。 |
+
+**示例：** 查询值为12345678的uid所属的系统帐号的帐号ID
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  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));
+  }
+  ```
+
+### queryOsAccountLocalIdFromUid<sup>9+</sup>
+
+queryOsAccountLocalIdFromUid(uid: number): Promise&lt;number&gt;
+
+从进程uid中获取该uid所属的系统帐号的帐号ID，使用Promise方式异步返回结果。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名 | 类型   | 必填 | 说明      |
+| ------ | ------ | ---- | --------- |
+| uid    | number | 是   | 进程uid。 |
+
+**返回值：**
+
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是uid所属的系统帐号的帐号ID。 |
+
+**示例：** 查询值为12345678的uid所属的系统帐号的帐号ID
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  let uid = 12345678;
+  try {
+    accountManager.queryOsAccountLocalIdFromUid(uid).then((accountID) => {
+      console.log('queryOsAccountLocalIdFromUid: ' + accountID);
+    }).catch((err) => {
+      console.log('queryOsAccountLocalIdFromUid err: '  + JSON.stringify(err));
+    });
+  } catch (e) {
+    console.log('queryOsAccountLocalIdFromUid exception: ' + JSON.stringify(e));
+  }
+  ```
+
+### 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
@@ -800,7 +1512,7 @@ getOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo, callback: AsyncCall
 | domainInfo | [DomainAccountInfo](#domainaccountinfo8) | 是   | 域帐号信息。                                 |
 | callback   | AsyncCallback&lt;number&gt;             | 是   | 回调结果，返回的是和域帐号关联的系统帐号ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
@@ -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
@@ -833,7 +1549,7 @@ getOsAccountLocalIdFromDomain(domainInfo: DomainAccountInfo): Promise&lt;number&
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是和域帐号关联的系统帐号ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -861,14 +1577,18 @@ queryMaxOsAccountNumber(callback: AsyncCallback&lt;number&gt;): void
 | -------- | --------------------------- | ---- | ------------------------------------------------ |
 | callback | AsyncCallback&lt;number&gt; | 是   | 回调结果，返回的是允许创建的系统帐号的最大数量。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.queryMaxOsAccountNumber((err, maxCnt)=>{
-    console.log('queryMaxOsAccountNumber err:' + JSON.stringify(err));
-    console.log('queryMaxOsAccountNumber maxCnt:' + maxCnt);
-  });
+  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
@@ -887,23 +1607,101 @@ queryMaxOsAccountNumber(): Promise&lt;number&gt;
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是允许创建的系统帐号的最大数量。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.queryMaxOsAccountNumber().then((maxCnt) => {
-    console.log('queryMaxOsAccountNumber, maxCnt: ' + maxCnt);
-  }).catch((err) => {
-    console.log('queryMaxOsAccountNumber err: '  + JSON.stringify(err));
-  });
+  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
@@ -978,14 +1780,18 @@ queryAllCreatedOsAccounts(callback: AsyncCallback&lt;Array&lt;OsAccountInfo&gt;&
 | -------- | ------------------------------------------------------------ | ---- | -------------------------------------------------- |
 | callback | AsyncCallback&lt;Array&lt;[OsAccountInfo](#osaccountinfo)&gt;&gt; | 是   | 回调结果，返回的是已创建的所有系统帐号的信息列表。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.queryAllCreatedOsAccounts((err, accountArr)=>{
-    console.log('queryAllCreatedOsAccounts err:' + JSON.stringify(err));
-    console.log('queryAllCreatedOsAccounts accountArr:' + JSON.stringify(accountArr));
-  });
+  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
@@ -1006,23 +1812,91 @@ queryAllCreatedOsAccounts(): Promise&lt;Array&lt;OsAccountInfo&gt;&gt;
 | :---------------------------------------------------------- | :----------------------------------------------------------- |
 | Promise&lt;Array&lt;[OsAccountInfo](#osaccountinfo)&gt;&gt; | Promise实例，用于获取异步返回结果，返回的是已创建的所有系统帐号的信息列表。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.queryAllCreatedOsAccounts().then((accountArr) => {
-    console.log('queryAllCreatedOsAccounts, accountArr: ' + JSON.stringify(accountArr));
-  }).catch((err) => {
-    console.log('queryAllCreatedOsAccounts err: '  + JSON.stringify(err));
-  });
+  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
 
 **参数：**
@@ -1031,7 +1905,7 @@ queryActivatedOsAccountIds(callback: AsyncCallback&lt;Array&lt;number&gt;&gt;):
 | -------- | ---------------------------------------- | ---- | ------------------------------------------------------ |
 | callback | AsyncCallback&lt;Array&lt;number&gt;&gt; | 是   | 回调结果，返回的是当前处于激活状态的系统帐号的ID列表。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
@@ -1058,7 +1936,7 @@ queryActivatedOsAccountIds(): Promise&lt;Array&lt;number&gt;&gt;
 | :--------------------------------- | :----------------------------------------------------------- |
 | Promise&lt;Array&lt;number&gt;&gt; | Promise实例，用于获取异步返回结果，返回的是当前处于激活状态的系统帐号的ID列表。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -1089,14 +1967,18 @@ createOsAccount(localName: string, type: OsAccountType, callback: AsyncCallback&
 | type      | [OsAccountType](#osaccounttype)                      | 是   | 创建的系统帐号的类型。                     |
 | callback  | AsyncCallback&lt;[OsAccountInfo](#osaccountinfo)&gt; | 是   | 回调结果，返回的是新创建的系统帐号的信息。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.createOsAccount('testName', account_osAccount.OsAccountType.NORMAL, (err, osAccountInfo)=>{
-    console.log('createOsAccount err:' + JSON.stringify(err));
-    console.log('createOsAccount osAccountInfo:' + JSON.stringify(osAccountInfo));
-  });
+  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
@@ -1124,15 +2006,19 @@ createOsAccount(localName: string, type: OsAccountType): Promise&lt;OsAccountInf
 | :--------------------------------------------- | :----------------------------------------------------------- |
 | Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是新创建的系统帐号的信息。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  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));
-  });
+  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>
@@ -1155,15 +2041,19 @@ createOsAccountForDomain(type: OsAccountType, domainInfo: DomainAccountInfo, cal
 | domainInfo | [DomainAccountInfo](#domainaccountinfo8)              | 是   | 域帐号信息。                               |
 | callback   | AsyncCallback&lt;[OsAccountInfo](#osaccountinfo)&gt; | 是   | 回调结果，返回的是新创建的系统帐号的信息。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let domainInfo = {domain: 'testDomain', accountName: 'testAccountName'};
-  accountManager.createOsAccountForDomain(account_osAccount.OsAccountType.NORMAL, domainInfo, (err, osAccountInfo)=>{
-    console.log('createOsAccountForDomain err:' + JSON.stringify(err));
-    console.log('createOsAccountForDomain osAccountInfo:' + JSON.stringify(osAccountInfo));
-  });
+  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>
@@ -1191,24 +2081,93 @@ createOsAccountForDomain(type: OsAccountType, domainInfo: DomainAccountInfo): Pr
 | :--------------------------------------------- | :----------------------------------------------------------- |
 | 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));
-  }).catch((err) => {
-    console.log('createOsAccountForDomain err: '  + JSON.stringify(err));
-  });
+  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
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                                           | 说明                                                         |
+| :--------------------------------------------- | :----------------------------------------------------------- |
+| Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号信息。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  try {
+    accountManager.getCurrentOsAccount().then((accountInfo) => {
+      console.log('getCurrentOsAccount, accountInfo: ' + JSON.stringify(accountInfo));
+    }).catch((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
@@ -1219,7 +2178,7 @@ queryCurrentOsAccount(callback: AsyncCallback&lt;OsAccountInfo&gt;): void
 | -------- | ---------------------------------------------------- | ---- | ---------------------------------------------- |
 | callback | AsyncCallback&lt;[OsAccountInfo](#osaccountinfo)&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号信息。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
@@ -1245,7 +2208,7 @@ queryCurrentOsAccount(): Promise&lt;OsAccountInfo&gt;
 | :--------------------------------------------- | :----------------------------------------------------------- |
 | Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号信息。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -1280,10 +2243,14 @@ queryOsAccountById(localId: number, callback: AsyncCallback&lt;OsAccountInfo&gt;
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
-  accountManager.queryOsAccountById(localId, (err, accountInfo)=>{
-    console.log('queryOsAccountById err:' + JSON.stringify(err));
-    console.log('queryOsAccountById accountInfo:' + JSON.stringify(accountInfo));
-  });
+  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
@@ -1310,73 +2277,207 @@ queryOsAccountById(localId: number): Promise&lt;OsAccountInfo&gt;
 | :--------------------------------------------- | :----------------------------------------------------------- |
 | Promise&lt;[OsAccountInfo](#osaccountinfo)&gt; | Promise实例，用于获取异步返回结果，返回的是查到的系统帐号的信息。 |
 
-**示例：** 查询ID为100的系统帐号信息
+**示例：** 查询ID为100的系统帐号信息
+
+  ```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<sup>(deprecated)</sup>
+
+getOsAccountTypeFromProcess(callback: AsyncCallback&lt;OsAccountType&gt;): void
+
+查询当前进程所属的系统帐号的帐号类型，使用callback回调异步返回结果。
+
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountType](#getosaccounttype9)
+>
+> 从 API version 7开始支持。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**参数：**
+
+| 参数名   | 类型                                                 | 必填 | 说明                                                 |
+| -------- | ---------------------------------------------------- | ---- | ---------------------------------------------------- |
+| callback | AsyncCallback&lt;[OsAccountType](#osaccounttype)&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号类型。 |
+
+**示例：**
+
+  ```js
+  let accountManager = account_osAccount.getAccountManager();
+  accountManager.getOsAccountTypeFromProcess((err, accountType) => {
+    console.log('getOsAccountTypeFromProcess err: ' + JSON.stringify(err));
+    console.log('getOsAccountTypeFromProcess accountType: ' + accountType);
+  });
+  ```
+
+### getOsAccountTypeFromProcess<sup>(deprecated)</sup>
+
+getOsAccountTypeFromProcess(): Promise&lt;OsAccountType&gt;
+
+查询当前进程所属的系统帐号的帐号类型，使用Promise方式异步返回结果。
+
+> **说明：** 从API version 9开始废弃，建议使用[getOsAccountType](#getosaccounttype9-1)
+>
+> 从 API version 7开始支持。
+
+**系统能力：** SystemCapability.Account.OsAccount
+
+**返回值：**
+
+| 类型                                           | 说明                                                         |
+| :--------------------------------------------- | :----------------------------------------------------------- |
+| Promise&lt;[OsAccountType](#osaccounttype)&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号类型。 |
+
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  let localId = 100;
-  accountManager.queryOsAccountById(localId).then((accountInfo) => {
-    console.log('queryOsAccountById, accountInfo: ' + JSON.stringify(accountInfo));
+  accountManager.getOsAccountTypeFromProcess().then((accountType) => {
+    console.log('getOsAccountTypeFromProcess, accountType: ' + accountType);
   }).catch((err) => {
-    console.log('queryOsAccountById err: '  + JSON.stringify(err));
+    console.log('getOsAccountTypeFromProcess err: '  + JSON.stringify(err));
   });
   ```
 
-### getOsAccountTypeFromProcess
+### queryDistributedVirtualDeviceId<sup>9+</sup>
 
-getOsAccountTypeFromProcess(callback: AsyncCallback&lt;OsAccountType&gt;): void
+queryDistributedVirtualDeviceId(callback: AsyncCallback&lt;string&gt;): void
 
-查询当前进程所属的系统帐号的帐号类型，使用callback回调异步返回结果。
+获取分布式虚拟设备ID，使用callback回调异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS or ohos.permission.GET_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
 
 **参数：**
 
-| 参数名   | 类型                                                 | 必填 | 说明                                                 |
-| -------- | ---------------------------------------------------- | ---- | ---------------------------------------------------- |
-| callback | AsyncCallback&lt;[OsAccountType](#osaccounttype)&gt; | 是   | 回调结果，返回的是当前进程所属的系统帐号的帐号类型。 |
+| 参数名   | 类型                        | 必填 | 说明                                 |
+| -------- | --------------------------- | ---- | ------------------------------------ |
+| callback | AsyncCallback&lt;string&gt; | 是   | 回调结果，返回的是分布式虚拟设备ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.getOsAccountTypeFromProcess((err, accountType) => {
-    console.log('getOsAccountTypeFromProcess err: ' + JSON.stringify(err));
-    console.log('getOsAccountTypeFromProcess accountType: ' + accountType);
-  });
+  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));
+  }
   ```
 
-### getOsAccountTypeFromProcess
+### queryDistributedVirtualDeviceId<sup>9+</sup>
 
-getOsAccountTypeFromProcess(): Promise&lt;OsAccountType&gt;
+queryDistributedVirtualDeviceId(): Promise&lt;string&gt;
 
-查询当前进程所属的系统帐号的帐号类型，使用Promise方式异步返回结果。
+获取分布式虚拟设备ID，使用Promise方式异步返回结果。
+
+**需要权限：** ohos.permission.MANAGE_LOCAL_ACCOUNTS 或 ohos.permission.GET_LOCAL_ACCOUNTS
 
 **系统能力：** SystemCapability.Account.OsAccount
 
 **返回值：**
 
-| 类型                                           | 说明                                                         |
-| :--------------------------------------------- | :----------------------------------------------------------- |
-| Promise&lt;[OsAccountType](#osaccounttype)&gt; | Promise实例，用于获取异步返回结果，返回的是当前进程所属的系统帐号的帐号类型。 |
+| 类型                  | 说明                                                         |
+| :-------------------- | :----------------------------------------------------------- |
+| Promise&lt;string&gt; | Promise实例，用于获取异步返回结果，返回的是分布式虚拟设备ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.getOsAccountTypeFromProcess().then((accountType) => {
-    console.log('getOsAccountTypeFromProcess, accountType: ' + accountType);
-  }).catch((err) => {
-    console.log('getOsAccountTypeFromProcess err: '  + JSON.stringify(err));
-  });
+  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
+### 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
@@ -1387,7 +2488,7 @@ getDistributedVirtualDeviceId(callback: AsyncCallback&lt;string&gt;): void
 | -------- | --------------------------- | ---- | ------------------------------------ |
 | callback | AsyncCallback&lt;string&gt; | 是   | 回调结果，返回的是分布式虚拟设备ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -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
@@ -1413,7 +2518,7 @@ getDistributedVirtualDeviceId(): Promise&lt;string&gt;
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;string&gt; | Promise实例，用于获取异步返回结果，返回的是分布式虚拟设备ID。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
@@ -1448,10 +2553,14 @@ getOsAccountProfilePhoto(localId: number, callback: AsyncCallback&lt;string&gt;)
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let localId = 100;
-  accountManager.getOsAccountProfilePhoto(localId, (err, photo)=>{
-    console.log('getOsAccountProfilePhoto err:' + JSON.stringify(err));
-    console.log('get photo:' + photo + ' by localId: ' + localId);
-  });
+  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;
-  accountManager.getOsAccountProfilePhoto(localId).then((photo) => {
-    console.log('getOsAccountProfilePhoto: ' + photo);
-  }).catch((err) => {
-    console.log('getOsAccountProfilePhoto err: '  + JSON.stringify(err));
-  });
+  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=='
-  accountManager.setOsAccountProfilePhoto(localId, photo, (err)=>{
-    console.log('setOsAccountProfilePhoto err:' + JSON.stringify(err));
-  });
+  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=='
-  accountManager.setOsAccountProfilePhoto(localId, photo).then(() => {
-    console.log('setOsAccountProfilePhoto success');
-  }).catch((err) => {
-    console.log('setOsAccountProfilePhoto err: '  + JSON.stringify(err));
-  });
+  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
 
 **参数：**
@@ -1701,14 +2970,18 @@ on(type: 'activate' | 'activating', name: string, callback: Callback&lt;number&g
 | name     | string                     | 是   | 订阅名称，可自定义，要求非空且长度不超过1024字节。           |
 | callback | Callback&lt;number&gt;     | 是   | 订阅系统帐号变动信息的回调，表示当前事件对应的系统帐号ID。   |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
   function onCallback(receiveLocalId){
     console.log('receive localId:' + receiveLocalId);
   }
-  accountManager.on('activating', 'osAccountOnOffNameA', onCallback);
+  try {
+    accountManager.on('activating', 'osAccountOnOffNameA', onCallback);
+  } catch (e) {
+    console.log('receive localId exception:' + JSON.stringify(e));
+  }
   ```
 
 ### off
@@ -1731,14 +3004,18 @@ off(type: 'activate' | 'activating', name: string, callback?: Callback&lt;number
 | name     | string                     | 是   | 订阅名称，可自定义，，要求非空且长度不超过1024字节，需要与订阅接口传入的值保持一致。 |
 | callback | Callback&lt;number&gt;     | 否   | 取消订阅系统帐号变化的回调，默认返回0。                      |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
   function offCallback(){
     console.log('off enter')
   }
-  accountManager.off('activating', 'osAccountOnOffNameA', offCallback);
+  try {
+    accountManager.off('activating', 'osAccountOnOffNameA', offCallback);
+  } catch (e) {
+    console.log('off exception:' + JSON.stringify(e));
+  }
   ```
 
 ### getBundleIdFromUid<sup>9+</sup>
@@ -1758,15 +3035,19 @@ getBundleIdFromUid(uid: number, callback: AsyncCallback&lt;number&gt;): void;
 | uid     | number | 是   |  进程uid。 |
 | callback | AsyncCallback&lt;number&gt;     | 是   | 回调结果，返回的是与uid对应的bundleId。                      |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let testUid = 1000000;
-  accountManager.getBundleIdFromUid(testUid, (err, bundleId) => {
-    console.info('getBundleIdFromUid errInfo:' + JSON.stringify(err));
-    console.info('getBundleIdFromUid bundleId:' + JSON.stringify(bundleId));
-  });
+  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>
 
@@ -1790,16 +3071,20 @@ getBundleIdFromUid(uid: number): Promise&lt;number&gt;;
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回的是与uid对应的bundleId。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
   let testUid = 1000000;
-  accountManager.getBundleIdFromUid(testUid).then((result) => {
-    console.info('getBundleIdFromUid bundleId:' + JSON.stringify(result));
-  }).catch((err)=>{
-    console.info('getBundleIdFromUid errInfo:' + JSON.stringify(err));
-  });
+  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
 
@@ -1820,14 +3105,18 @@ isMainOsAccount(callback: AsyncCallback&lt;boolean&gt;): void;
 | -------- | -------------------------- | ---- | ------------------------------------------------------------ |
 | callback | AsyncCallback&lt;boolean&gt;     | 是   | 回调结果，返回的是当前进程是否处于主用户，是则返回true，否则返回false。                      |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.isMainOsAccount((err,result)=>{
-    console.info('isMainOsAccount errInfo:' + JSON.stringify(err));
-    console.info('isMainOsAccount result:' + JSON.stringify(result));
-  });
+  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
 
@@ -1847,15 +3136,19 @@ isMainOsAccount(): Promise&lt;boolean&gt;;
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;boolean&gt; | Promise实例，用于获取异步返回结果，回调结果，返回的是当前进程是否处于主用户，是则返回true，否则返回false。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.isMainOsAccount().then((result) => {
-    console.info('isMainOsAccount result:' + JSON.stringify(result));
-  }).catch((err)=>{
-    console.info('isMainOsAccount errInfo:' + JSON.stringify(err));
-  });
+  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
 
@@ -1877,14 +3170,18 @@ queryOsAccountConstraintSourceTypes(localId: number, constraint: string, callbac
 | constraint     | string | 是   |  要查询的[约束](#系统帐号约束列表)名称 |
 | callback | AsyncCallback&lt;Array&lt;[ConstraintSourceTypeInfo](#constraintsourcetypeinfo)&gt;&gt;     | 是   | 回调结果，返回的是指定系统帐号的指定[约束](#系统帐号约束列表)来源信息。                      |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.queryOsAccountConstraintSourceTypes(100, 'constraint.wifi',(err,sourceTypeInfos)=>{
-    console.info('queryOsAccountConstraintSourceType errInfo:' + JSON.stringify(err));
-    console.info('queryOsAccountConstraintSourceType sourceTypeInfos:' + JSON.stringify(sourceTypeInfos));
-  });
+  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
 
@@ -1912,15 +3209,19 @@ queryOsAccountConstraintSourceTypes(localId: number, constraint: string): Promis
 | :-------------------- | :----------------------------------------------------------- |
 | Promise&lt;Array&lt;[ConstraintSourceTypeInfo](#constraintsourcetypeinfo)&gt;&gt; | Promise实例，用于获取异步返回结果，返回的是指定系统帐号的指定[约束](#系统帐号约束列表)来源信息。 |
 
-**示例：** 
+**示例：**
 
   ```js
   let accountManager = account_osAccount.getAccountManager();
-  accountManager.queryOsAccountConstraintSourceTypes(100, 'constraint.wifi').then((result) => {
-    console.info('queryOsAccountConstraintSourceType sourceTypeInfos:' + JSON.stringify(result));
-  }).catch((err)=>{
-    console.info('queryOsAccountConstraintSourceType errInfo:' + JSON.stringify(err));
-  });
+  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;
-  let status = userAuth.getAvailableStatus(authType, authTrustLevel);
-  console.log('getAvailableStatus status = ' + status);
+  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>
@@ -2021,7 +3326,7 @@ getProperty(request: GetPropertyRequest, callback: AsyncCallback&lt;ExecutorProp
 | request  | [GetPropertyRequest](#getpropertyrequest8)                  | 是   | 请求信息，包括认证类型和属性类型列表。 |
 | callback | AsyncCallback&lt;[ExecutorProperty](#executorproperty8)&gt; | 是   | 回调结果，返回的是调用者属性。        |
 
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let keys = [
@@ -2033,10 +3338,14 @@ getProperty(request: GetPropertyRequest, callback: AsyncCallback&lt;ExecutorProp
     authType: account_osAccount.AuthType.PIN,
     keys: keys
   };
-  userAuth.getProperty(request, (err, result) => {
-    console.log('getProperty err = ' + JSON.stringify(err));
-    console.log('getProperty result = ' + JSON.stringify(result));
-  });
+  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>
@@ -2063,7 +3372,7 @@ getProperty(request: GetPropertyRequest): Promise&lt;ExecutorProperty&gt;;
 | :---------------------------------------------------------------- | :-------------------------------------------------- |
 | Promise&lt;[ExecutorProperty](#executorproperty8)&gt; | Promise实例，用于获取异步返回结果，返回的是调用者属性。 |
 
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let keys = [
@@ -2075,11 +3384,15 @@ getProperty(request: GetPropertyRequest): Promise&lt;ExecutorProperty&gt;;
     authType: account_osAccount.AuthType.PIN,
     keys: keys
   };
-  userAuth.getProperty(request).then((result) => {
-    console.log('getProperty result = ' + JSON.stringify(result));
-  }).catch((err) => {
-    console.log('getProperty error = ' + JSON.stringify(err));
-  });
+  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>
@@ -2101,7 +3414,7 @@ setProperty(request: SetPropertyRequest, callback: AsyncCallback&lt;number&gt;):
 | request  | [SetPropertyRequest](#setpropertyrequest8)| 是   | 请求信息，包括认证类型和要设置的密钥值。                                   |
 | callback | AsyncCallback&lt;number&gt;                           | 是   | 回调结果，返回一个[数值](#resultcode8)，指示属性设置是否成功。 |
 
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let request = {
@@ -2109,10 +3422,14 @@ setProperty(request: SetPropertyRequest, callback: AsyncCallback&lt;number&gt;):
     key: account_osAccount.SetPropertyType.INIT_ALGORITHM,
     setInfo: new Uint8Array([0])
   };
-  userAuth.setProperty(request, (err, result) => {
-      console.log('setProperty error = ' + JSON.stringify(err));
-      console.log('setProperty result = ' + JSON.stringify(result));
-  });
+  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>
@@ -2139,7 +3456,7 @@ setProperty(request: SetPropertyRequest): Promise&lt;number&gt;;
 | :-------------------- | :-------------------------------------------------------------------------------------------- |
 | Promise&lt;number&gt; | Promise实例，用于获取异步返回结果，返回一个[数值](#resultcode8)，指示属性设置是否成功。 |
 
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let request = {
@@ -2147,11 +3464,15 @@ setProperty(request: SetPropertyRequest): Promise&lt;number&gt;;
     key: account_osAccount.SetPropertyType.INIT_ALGORITHM,
     setInfo: new Uint8Array([0])
   };
-  userAuth.setProperty(request).then((result) => {
-    console.log('setProperty result = ' + JSON.stringify(result));
-  }).catch((err) => {
-    console.log('setProperty error = ' + JSON.stringify(err));
-  });
+  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>
@@ -2182,18 +3503,22 @@ auth(challenge: Uint8Array, authType: AuthType, authTrustLevel: AuthTrustLevel,
 | :--------- | :----------------- |
 | Uint8Array | 返回取消的上下文ID。 |
 
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let challenge = new Uint8Array([0]);
   let authType = account_osAccount.AuthType.PIN;
   let authTrustLevel = account_osAccount.AuthTrustLevel.ATL1;
-  userAuth.auth(challenge, authType, authTrustLevel, {
-    onResult: function(result,extraInfo){
-        console.log('auth result = ' + result);
-        console.log('auth extraInfo = ' + JSON.stringify(extraInfo));
-    }
-  });
+  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>
@@ -2225,24 +3550,28 @@ authUser(userId: number, challenge: Uint8Array, authType: AuthType, authTrustLev
 | :--------- | :----------------- |
 | Uint8Array | 返回取消的上下文ID。 |
 
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let userID = 100;
   let challenge = new Uint8Array([0]);
   let authType = account_osAccount.AuthType.PIN;
   let authTrustLevel = account_osAccount.AuthTrustLevel.ATL1;
-  userAuth.authUser(userID, challenge, authType, authTrustLevel, {
-    onResult: function(result,extraInfo){
-        console.log('authUser result = ' + result);
-        console.log('authUser extraInfo = ' + JSON.stringify(extraInfo));
-    }
-  });
+  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,13 +3587,7 @@ cancelAuth(contextID: Uint8Array): number;
 | ----------| ---------- | ---- | ------------------------------------------ |
 | contextID | Uint8Array | 是   | 指示身份验证上下文ID，此ID动态生成没有具体值。 |
 
-**返回值：**
-
-| 类型   | 说明                                                       |
-| :----- | :-------------------------------------------------------- |
-| number | 返回一个[数字](#resultcode8)，指示取消是否成功。 |
-
-**示例：** 
+**示例：**
   ```js
   let userAuth = new account_osAccount.UserAuth();
   let pinAuth = new account_osAccount.PINAuth();
@@ -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;
 
@@ -2324,19 +3650,23 @@ registerInputer(inputer: IInputer): boolean;
 | :------ | :-------------------------------------------- |
 | boolean | 返回布尔值，true表示注册成功，false表示注册失败。 |
 
-**示例：** 
+**示例：**
   ```js
   let pinAuth = new account_osAccount.PINAuth();
   let password = new Uint8Array([0, 0, 0, 0, 0]);
-  let result = pinAuth.registerInputer({
-      onGetData: (pinSubType, callback) => {
-        callback.onSetData(pinSubType, password);
-      }
-  });
-  console.log('registerInputer result = ' + result);
+  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;
 
@@ -2348,7 +3678,7 @@ unregisterInputer(): void;
 
 **需要权限：** ohos.permission.ACCESS_PIN_AUTH
 
-**示例：** 
+**示例：**
   ```js
   let pinAuth = new account_osAccount.PINAuth();
   pinAuth.unregisterInputer();
@@ -2393,13 +3723,17 @@ openSession(callback: AsyncCallback&lt;Uint8Array&gt;): void;
 | -------- | -------------------------------- | ---- | -------------------------------- |
 | callback | AsyncCallback&lt;Uint8Array&gt;  | 是   | 回调结果，返回的是挑战值，非0即成功，为0则失败。|
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
-  userIDM.openSession((err, challenge) => {
-      console.log('openSession error = ' + JSON.stringify(err));
-      console.log('openSession challenge = ' + JSON.stringify(challenge));
-  });
+  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>
@@ -2420,14 +3754,18 @@ openSession(): Promise&lt;Uint8Array&gt;;
 | :------------------------ | :------------------------------------------------------- |
 | Promise&lt;Uint8Array&gt; | Promise实例，用于获取异步返回结果，返回的是挑战值，非0即成功，为0则失败。|
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
-  userIDM.openSession().then((challenge) => {
-      console.info('openSession challenge = ' + JSON.stringify(challenge));
-  }).catch((err) => {
-      console.info('openSession error = ' + JSON.stringify(err));
-  });
+  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>
@@ -2449,7 +3787,7 @@ addCredential(credentialInfo: CredentialInfo, callback: IIdmCallback): void;
 | credentialInfo  | [CredentialInfo](#credentialinfo8)   | 是  | 指示凭据信息。                      |
 | callback        | [IIdmCallback](#iidmcallback8)       | 是  | 回调结果，返回的是结果和获取信息。  |
 
-**示例：** 
+**示例：**
   ```js
   let password = new Uint8Array([0, 0, 0, 0, 0, 0]);
   let pinAuth = new account_osAccount.PINAuth();
@@ -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));
+    }
   });
   ```
 
@@ -2493,7 +3835,7 @@ updateCredential(credentialInfo: CredentialInfo, callback: IIdmCallback): void;
 | credentialInfo  | [CredentialInfo](#credentialinfo8)    | 是  | 指示凭据信息。                    |
 | callback        | [IIdmCallback](#iidmcallback8)        | 是  | 回调结果，返回的是结果和获取信息。  |
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
   let userAuth = new account_osAccount.UserAuth();
@@ -2516,12 +3858,16 @@ updateCredential(credentialInfo: CredentialInfo, callback: IIdmCallback): void;
           return;
         }
         credentialInfo.token = extraInfo.token;
-        userIDM.updateCredential(credentialInfo, {
-          onResult: (result, extraInfo) => {
-              console.log('updateCredential result = ' + result);
-              console.log('updateCredential extraInfo = ' + extraInfo);
-          }
-        });
+        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));
+        }
       }
     });
   });
@@ -2539,7 +3885,7 @@ closeSession(): void;
 
 **需要权限：** ohos.permission.MANAGE_USER_IDM
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
   userIDM.closeSession();
@@ -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>
@@ -2596,16 +3940,20 @@ delUser(token: Uint8Array, callback: IIdmCallback): void;
 | token    | Uint8Array                                 | 是  | 身份验证令牌。             |
 | callback | [IIdmCallback](#iidmcallback8) | 是  | 回调结果，返回的是删除结果。|
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
   let token = new Uint8Array([0]);
-  userIDM.delUser(token, {
-    onResult: (result, extraInfo) => {
-      console.log('delUser result = ' + result);
-      console.log('delUser extraInfo = ' + JSON.stringify(extraInfo));
-    }
-  });
+  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>
@@ -2628,17 +3976,21 @@ delCred(credentialId: Uint8Array, token: Uint8Array, callback: IIdmCallback): vo
 | token           | Uint8Array                                      | 是  | 身份验证令牌。              |
 | callback        | [IIdmCallback](#iidmcallback8)      | 是  | 回调结果，返回的是删除结果。 |
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
   let credentialId = new Uint8Array([0]);
   let token = new Uint8Array([0]);
-  userIDM.delCred(credentialId, token, {
-    onResult: (result, extraInfo) => {
-        console.log('delCred result = ' + result);
-        console.log('delCred extraInfo = ' + JSON.stringify(extraInfo));
-    }
-  });
+  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>
@@ -2660,13 +4012,17 @@ getAuthInfo(callback: AsyncCallback&lt;Array&lt;EnrolledCredInfo&gt;&gt;): void;
 | callback | AsyncCallback&lt;Array&lt;[EnrolledCredInfo](#enrolledcredinfo8)&gt;&gt; | 是   | 回调结果，返回的是当前用户指定类型的所有已注册凭据信息。|
 
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
-  userIDM.getAuthInfo((err, result) => {
-    console.log('getAuthInfo err = ' + JSON.stringify(err));
-    console.log('getAuthInfo result = ' + JSON.stringify(result));
-  });
+  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>
@@ -2688,13 +4044,17 @@ getAuthInfo(authType: AuthType, callback: AsyncCallback&lt;Array&lt;EnrolledCred
 | authType | [AuthType](#authtype8) | 是   | 认证类型。                                          |
 | callback | AsyncCallback&lt;Array&lt;[EnrolledCredInfo](#enrolledcredinfo8)&gt;&gt; | 是   | 回调结果，返回的是当前用户指定类型的所有已注册凭据信息。|
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
-  userIDM.getAuthInfo(account_osAccount.AuthType.PIN, (err, result) => {
-    console.log('getAuthInfo err = ' + JSON.stringify(err));
-    console.log('getAuthInfo result = ' + JSON.stringify(result));
-  });
+  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>
@@ -2721,14 +4081,18 @@ getAuthInfo(authType?: AuthType): Promise&lt;Array&lt;EnrolledCredInfo&gt;&gt;;
 | :------------------------------------------- | :------------------------------------------------------------------------ |
 | Promise&lt;Array&lt;[EnrolledCredInfo](#enrolledcredinfo8)&gt;&gt; | Promise实例，用于获取异步返回结果，返回的是当前用户指定类型的所有已注册凭据信息。|
 
-**示例：** 
+**示例：**
   ```js
   let userIDM = new account_osAccount.UserIdentityManager();
-  userIDM.getAuthInfo(account_osAccount.AuthType.PIN).then((result) => {
-    console.log('getAuthInfo result = ' + JSON.stringify(result))
-  }).catch((err) => {
-    console.log('getAuthInfo error = ' + JSON.stringify(err));
-  });
+  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>
@@ -2754,7 +4118,7 @@ onSetData: (pinSubType: AuthSubType, data: Uint8Array) => void;
 | pinSubType | [AuthSubType](#authsubtype8) | 是   | 用于认证的凭据子类型。                            |
 | data       | Uint8Array                               | 是   | 要设置的数据是凭据，用来在认证、添加、修改凭据操作。 |
 
-**示例：** 
+**示例：**
   ```js
   let password = new Uint8Array([0, 0, 0, 0, 0, 0]);
   let passwordNumber = new Uint8Array([1, 2, 3, 4]);
@@ -2791,7 +4155,7 @@ onGetData: (pinSubType: AuthSubType, callback: IInputData) => void;
 | ---------- | --------------------------------------- | ---- | --------------- |
 | callback   | [IInputData](#iinputdata8)  | 是   | 指示密码数据回调。|
 
-**示例：** 
+**示例：**
   ```js
   let password = new Uint8Array([0, 0, 0, 0, 0, 0]);
   let passwordNumber = new Uint8Array([1, 2, 3, 4]);
@@ -2832,7 +4196,7 @@ onResult: (result: number, extraInfo: AuthResult) => void;
 | result    | number                                   | 是   | 表示身份认证结果代码。|
 | extraInfo | [AuthResult](#authresult8)  | 是   | 表示不同情况下的具体信息，如果认证通过，则在extrainfo中返回认证令牌，如果身份验证失败，则在extrainfo中返回剩余的身份验证时间，如果身份验证执行器被锁定，冻结时间将在extrainfo中返回。|
 
-**示例：** 
+**示例：**
   ```js
   let authCallback = {
     onResult: (result, extraInfo) => {
@@ -2860,7 +4224,7 @@ onAcquireInfo?: (module: number, acquire: number, extraInfo: any) => void;
 | acquire   | number  | 是   | 指示不同身份验证执行器的tip代码。|
 | extraInfo | any     | 是   | 保留参数。                     |
 
-**示例：** 
+**示例：**
   ```js
   let authCallback = {
     onResult: (result, extraInfo) => {
@@ -2898,7 +4262,7 @@ onResult: (result: number, extraInfo: RequestResult) => void;
 | result    | number                                  | 是   | 表示身份认证结果代码。    |
 | extraInfo | [AuthResult](#authresult8)  | 是   | 针对不同情况传递具体信息。|
 
-**示例：** 
+**示例：**
   ```js
   let idmCallback = {
     onResult: (result, extraInfo) => {
@@ -2926,7 +4290,7 @@ onAcquireInfo?: (module: number, acquire: number, extraInfo: any) => void;
 | acquire   | number  | 是   | 指示不同身份验证执行器的tip代码。|
 | extraInfo | any     | 是   | 保留参数。                     |
 
-**示例：** 
+**示例：**
   ```js
   let idmCallback = {
     onResult: (result, extraInfo) => {