1# @ohos.enterprise.bundleManager (Bundle Management) 2 3The **bundleManager** module provides APIs for bundle management, including adding, obtaining, and removing a list of bundles that are allowed to install. 4 5> **NOTE** 6> 7> - The initial APIs of this module are supported since API version 10. Newly added APIs will be marked with a superscript to indicate their earliest API version. 8> 9> - The APIs of this module can be used only in the stage model. 10> 11> - The APIs provided by this module can be called only by a [device administrator application](enterpriseDeviceManagement-overview.md#basic-concepts) that is [enabled](js-apis-enterprise-adminManager.md#adminmanagerenableadmin). 12 13## Modules to Import 14 15```ts 16import bundleManager from '@ohos.enterprise.bundleManager'; 17``` 18 19## bundleManager.addAllowedInstallBundles 20 21addAllowedInstallBundles(admin: Want, appIds: Array\<string>, callback: AsyncCallback<void>): void 22 23Adds the applications that can be installed by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 24 25**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 26 27**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 28 29**System API**: This is a system API. 30 31**Parameters** 32 33| Name | Type | Mandatory | Description | 34| -------- | ---------------------------------------- | ---- | ------------------------------- | 35| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 36| appIds | Array<string> | Yes | IDs of the applications to add. | 37| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 38 39**Error codes** 40 41For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 42 43| ID| Error Message | 44| ------- | ---------------------------------------------------------------------------- | 45| 9200001 | the application is not an administrator of the device. | 46| 9200002 | the administrator application does not have permission to manage the device. | 47 48**Example** 49 50```ts 51import Want from '@ohos.app.ability.Want'; 52let wantTemp: Want = { 53 bundleName: 'com.example.myapplication', 54 abilityName: 'EntryAbility', 55}; 56let appIds: Array<string> = ['com.example.myapplication']; 57 58bundleManager.addAllowedInstallBundles(wantTemp, appIds, (err) => { 59 if (err) { 60 console.error(`Failed to add allowed install bundles. Code is ${err.code}, message is ${err.message}`); 61 return; 62 } 63 console.info('Succeeded in adding allowed install bundles'); 64}); 65``` 66 67## bundleManager.addAllowedInstallBundles 68 69addAllowedInstallBundles(admin: Want, appIds: Array\<string>, userId: number, callback: AsyncCallback<void>): void 70 71Adds the applications that can be installed by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 72 73**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 74 75**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 76 77**System API**: This is a system API. 78 79**Parameters** 80 81| Name | Type | Mandatory | Description | 82| ----- | ----------------------------------- | ---- | ------- | 83| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 84| appIds | Array<string> | Yes | IDs of the applications to add. | 85| userId | number | Yes | User ID, which must be greater than or equal to 0.| 86| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 87 88**Error codes** 89 90For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 91 92| ID| Error Message | 93| ------- | ---------------------------------------------------------------------------- | 94| 9200001 | the application is not an administrator of the device. | 95| 9200002 | the administrator application does not have permission to manage the device. | 96 97**Example** 98 99```ts 100import Want from '@ohos.app.ability.Want'; 101let wantTemp: Want = { 102 bundleName: 'com.example.myapplication', 103 abilityName: 'EntryAbility', 104}; 105let appIds: Array<string> = ['com.example.myapplication']; 106 107bundleManager.addAllowedInstallBundles(wantTemp, appIds, 100, (err) => { 108 if (err) { 109 console.error(`Failed to add allowed install bundles. Code is ${err.code}, message is ${err.message}`); 110 return; 111 } 112 console.info('Succeeded in adding allowed install bundles'); 113}); 114``` 115 116## bundleManager.addAllowedInstallBundles 117 118addAllowedInstallBundles(admin: Want, appIds: Array\<string>, userId?: number): Promise<void> 119 120Adds the applications that can be installed by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 121 122**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 123 124**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 125 126**System API**: This is a system API. 127 128**Parameters** 129 130| Name | Type | Mandatory | Description | 131| ----- | ----------------------------------- | ---- | ------- | 132| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 133| appIds | Array<string> | Yes | IDs of the applications to add. | 134| userId | number | No |User ID, which must be greater than or equal to 0.<br>- If **userId** is passed in, the applications can be installed by the specified user.<br>- If **userId** is not passed in, the applications can be installed by the current user.| 135 136**Return value** 137 138| Type | Description | 139| --------------------- | ------------------------- | 140| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown. | 141 142**Error codes** 143 144For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 145 146| ID| Error Message | 147| ------- | ---------------------------------------------------------------------------- | 148| 9200001 | the application is not an administrator of the device. | 149| 9200002 | the administrator application does not have permission to manage the device. | 150 151**Example** 152 153```ts 154import Want from '@ohos.app.ability.Want'; 155import { BusinessError } from '@ohos.base'; 156let wantTemp: Want = { 157 bundleName: 'com.example.myapplication', 158 abilityName: 'EntryAbility', 159}; 160let appIds: Array<string> = ['com.example.myapplication']; 161 162bundleManager.addAllowedInstallBundles(wantTemp, appIds, 100).then(() => { 163 console.info('Succeeded in adding allowed install bundles'); 164}).catch((err: BusinessError) => { 165 console.error(`Failed to add allowed install bundles. Code is ${err.code}, message is ${err.message}`); 166}); 167``` 168 169## bundleManager.removeAllowedInstallBundles 170 171removeAllowedInstallBundles(admin: Want, appIds: Array\<string>, callback: AsyncCallback<void>): void 172 173Removes the applications that can be installed by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 174 175**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 176 177**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 178 179**System API**: This is a system API. 180 181**Parameters** 182 183| Name | Type | Mandatory | Description | 184| -------- | ---------------------------------------- | ---- | ------------------------------- | 185| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 186| appIds | Array<string> | Yes | IDs of the applications to remove. | 187| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 188 189**Error codes** 190 191For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 192 193| ID| Error Message | 194| ------- | ---------------------------------------------------------------------------- | 195| 9200001 | the application is not an administrator of the device. | 196| 9200002 | the administrator application does not have permission to manage the device. | 197 198**Example** 199 200```ts 201import Want from '@ohos.app.ability.Want'; 202let wantTemp: Want = { 203 bundleName: 'com.example.myapplication', 204 abilityName: 'EntryAbility', 205}; 206let appIds: Array<string> = ['com.example.myapplication']; 207 208bundleManager.removeAllowedInstallBundles(wantTemp, appIds, (err) => { 209 if (err) { 210 console.error(`Failed to remove allowed install bundles. Code is ${err.code}, message is ${err.message}`); 211 return; 212 } 213 console.info('Succeeded in removing allowed install bundles'); 214}); 215``` 216 217## bundleManager.removeAllowedInstallBundles 218 219removeAllowedInstallBundles(admin: Want, appIds: Array\<string>, userId: number, callback: AsyncCallback<void>): void 220 221Removes the applications that can be installed by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 222 223**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 224 225**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 226 227**System API**: This is a system API. 228 229**Parameters** 230 231| Name | Type | Mandatory | Description | 232| ----- | ----------------------------------- | ---- | ------- | 233| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 234| appIds | Array<string> | Yes | IDs of the applications to remove. | 235| userId | number | Yes | User ID, which must be greater than or equal to 0.| 236| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 237 238**Error codes** 239 240For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 241 242| ID| Error Message | 243| ------- | ---------------------------------------------------------------------------- | 244| 9200001 | the application is not an administrator of the device. | 245| 9200002 | the administrator application does not have permission to manage the device. | 246 247**Example** 248 249```ts 250import Want from '@ohos.app.ability.Want'; 251let wantTemp: Want = { 252 bundleName: 'com.example.myapplication', 253 abilityName: 'EntryAbility', 254}; 255let appIds: Array<string> = ['com.example.myapplication']; 256 257bundleManager.removeAllowedInstallBundles(wantTemp, appIds, 100, (err) => { 258 if (err) { 259 console.error(`Failed to remove allowed install bundles. Code is ${err.code}, message is ${err.message}`); 260 return; 261 } 262 console.info('Succeeded in removing allowed install bundles'); 263}); 264``` 265 266## bundleManager.removeAllowedInstallBundles 267 268removeAllowedInstallBundles(admin: Want, appIds: Array\<string>, userId?: number): Promise<void> 269 270Removes the applications that can be installed by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 271 272**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 273 274**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 275 276**System API**: This is a system API. 277 278**Parameters** 279 280| Name | Type | Mandatory | Description | 281| ----- | ----------------------------------- | ---- | ------- | 282| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 283| appIds | Array\<string> | Yes | IDs of the applications to remove. | 284| userId | number | No | User ID, which must be greater than or equal to 0.<br>- If **userId** is passed in, the applications can be installed by the specified user.<br>- If **userId** is not passed in, the applications can be installed by the current user. | 285 286**Return value** 287 288| Type | Description | 289| --------------------- | ------------------------- | 290| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown. | 291 292**Error codes** 293 294For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 295 296| ID| Error Message | 297| ------- | ---------------------------------------------------------------------------- | 298| 9200001 | the application is not an administrator of the device. | 299| 9200002 | the administrator application does not have permission to manage the device. | 300 301**Example** 302 303```ts 304import Want from '@ohos.app.ability.Want'; 305import { BusinessError } from '@ohos.base'; 306let wantTemp: Want = { 307 bundleName: 'com.example.myapplication', 308 abilityName: 'EntryAbility', 309}; 310let appIds: Array<string> = ['com.example.myapplication']; 311 312bundleManager.removeAllowedInstallBundles(wantTemp, appIds, 100).then(() => { 313 console.info('Succeeded in removing allowed install bundles'); 314}).catch((err: BusinessError) => { 315 console.error(`Failed to remove allowed install bundles. Code is ${err.code}, message is ${err.message}`); 316}); 317``` 318 319## bundleManager.getAllowedInstallBundles 320 321getAllowedInstallBundles(admin: Want, callback: AsyncCallback<Array<string>>): void 322 323Obtains the applications that can be installed by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 324 325**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 326 327**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 328 329**System API**: This is a system API. 330 331**Parameters** 332 333| Name | Type | Mandatory | Description | 334| -------- | ---------------------------------------- | ---- | ------------------------------- | 335| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 336| callback | AsyncCallback<Array<string>> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 337 338**Error codes** 339 340For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 341 342| ID| Error Message | 343| ------- | ---------------------------------------------------------------------------- | 344| 9200001 | the application is not an administrator of the device. | 345| 9200002 | the administrator application does not have permission to manage the device. | 346 347**Example** 348 349```ts 350import Want from '@ohos.app.ability.Want'; 351let wantTemp: Want = { 352 bundleName: 'com.example.myapplication', 353 abilityName: 'EntryAbility', 354}; 355 356bundleManager.getAllowedInstallBundles(wantTemp, (err, result) => { 357 if (err) { 358 console.error(`Failed to get allowed install bundles. Code is ${err.code}, message is ${err.message}`); 359 return; 360 } 361 console.info(`Succeeded in getting allowed install bundles, result : ${JSON.stringify(result)}`); 362}); 363``` 364 365## bundleManager.getAllowedInstallBundles 366 367getAllowedInstallBundles(admin: Want, userId: number, callback: AsyncCallback<Array<string>>): void 368 369Obtains the applications that can be installed by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 370 371**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 372 373**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 374 375**System API**: This is a system API. 376 377**Parameters** 378 379| Name | Type | Mandatory | Description | 380| -------- | ---------------------------------------- | ---- | ------------------------------- | 381| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 382| userId | number | Yes | User ID, which must be greater than or equal to 0.| 383| callback | AsyncCallback<Array<string>> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 384 385**Error codes** 386 387For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 388 389| ID| Error Message | 390| ------- | ---------------------------------------------------------------------------- | 391| 9200001 | the application is not an administrator of the device. | 392| 9200002 | the administrator application does not have permission to manage the device. | 393 394**Example** 395 396```ts 397import Want from '@ohos.app.ability.Want'; 398let wantTemp: Want = { 399 bundleName: 'com.example.myapplication', 400 abilityName: 'EntryAbility', 401}; 402 403bundleManager.getAllowedInstallBundles(wantTemp, 100, (err, result) => { 404 if (err) { 405 console.error(`Failed to get allowed install bundles. Code is ${err.code}, message is ${err.message}`); 406 return; 407 } 408 console.info(`Succeeded in getting allowed install bundles, result : ${JSON.stringify(result)}`); 409}); 410``` 411 412## bundleManager.getAllowedInstallBundles 413 414getAllowedInstallBundles(admin: Want, userId?: number): Promise<Array<string>> 415 416Obtains the applications that can be installed by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 417 418**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 419 420**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 421 422**System API**: This is a system API. 423 424**Parameters** 425 426| Name | Type | Mandatory | Description | 427| ----- | ----------------------------------- | ---- | ------- | 428| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application.| 429| userId | number | No | User ID, which must be greater than or equal to 0.<br>- If **userId** is passed in, the applications can be installed by the specified user.<br>- If **userId** is not passed in, the applications can be installed by the current user. | 430 431**Return value** 432 433| Type | Description | 434| --------------------- | ------------------------- | 435| Promise<Array<string>> | Promise used to return the list of the bundles obtained.| 436 437**Error codes** 438 439For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 440 441| ID| Error Message | 442| ------- | ---------------------------------------------------------------------------- | 443| 9200001 | the application is not an administrator of the device. | 444| 9200002 | the administrator application does not have permission to manage the device. | 445 446**Example** 447 448```ts 449import Want from '@ohos.app.ability.Want'; 450import { BusinessError } from '@ohos.base'; 451let wantTemp: Want = { 452 bundleName: 'com.example.myapplication', 453 abilityName: 'EntryAbility', 454}; 455 456bundleManager.getAllowedInstallBundles(wantTemp, 100).then((result) => { 457 console.info(`Succeeded in getting allowed install bundles, result : ${JSON.stringify(result)}`); 458}).catch((err: BusinessError) => { 459 console.error(`Failed to get allowed install bundles. Code is ${err.code}, message is ${err.message}`); 460}); 461``` 462 463## bundleManager.addDisallowedInstallBundles 464 465addDisallowedInstallBundles(admin: Want, appIds: Array\<string>, callback: AsyncCallback<void>): void 466 467Adds the applications that cannot be installed by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 468 469**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 470 471**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 472 473**System API**: This is a system API. 474 475**Parameters** 476 477| Name | Type | Mandatory | Description | 478| -------- | ---------------------------------------- | ---- | ------------------------------- | 479| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 480| appIds | Array<string> | Yes | IDs of the applications to add. | 481| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 482 483**Error codes** 484 485For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 486 487| ID| Error Message | 488| ------- | ---------------------------------------------------------------------------- | 489| 9200001 | the application is not an administrator of the device. | 490| 9200002 | the administrator application does not have permission to manage the device. | 491 492**Example** 493 494```ts 495import Want from '@ohos.app.ability.Want'; 496let wantTemp: Want = { 497 bundleName: 'com.example.myapplication', 498 abilityName: 'EntryAbility', 499}; 500let appIds: Array<string> = ['com.example.myapplication']; 501 502bundleManager.addDisallowedInstallBundles(wantTemp, appIds, (err) => { 503 if (err) { 504 console.error(`Failed to add disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 505 return; 506 } 507 console.info('Succeeded in adding disallowed install bundles'); 508}); 509``` 510 511## bundleManager.addDisallowedInstallBundles 512 513addDisallowedInstallBundles(admin: Want, appIds: Array\<string>, userId: number, callback: AsyncCallback<void>): void 514 515Adds the applications that cannot be installed by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 516 517**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 518 519**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 520 521**System API**: This is a system API. 522 523**Parameters** 524 525| Name | Type | Mandatory | Description | 526| ----- | ----------------------------------- | ---- | ------- | 527| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 528| appIds | Array<string> | Yes | IDs of the applications to add. | 529| userId | number | Yes | User ID, which must be greater than or equal to 0.| 530| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 531 532**Error codes** 533 534For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 535 536| ID| Error Message | 537| ------- | ---------------------------------------------------------------------------- | 538| 9200001 | the application is not an administrator of the device. | 539| 9200002 | the administrator application does not have permission to manage the device. | 540 541**Example** 542 543```ts 544import Want from '@ohos.app.ability.Want'; 545let wantTemp: Want = { 546 bundleName: 'com.example.myapplication', 547 abilityName: 'EntryAbility', 548}; 549let appIds: Array<string> = ['com.example.myapplication']; 550 551bundleManager.addDisallowedInstallBundles(wantTemp, appIds, 100, (err) => { 552 if (err) { 553 console.error(`Failed to add disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 554 return; 555 } 556 console.info('Succeeded in adding disallowed install bundles'); 557}); 558``` 559 560## bundleManager.addDisallowedInstallBundles 561 562addDisallowedInstallBundles(admin: Want, appIds: Array\<string>, userId?: number): Promise<void> 563 564Adds the applications that cannot be installed by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 565 566**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 567 568**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 569 570**System API**: This is a system API. 571 572**Parameters** 573 574| Name | Type | Mandatory | Description | 575| ----- | ----------------------------------- | ---- | ------- | 576| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 577| appIds | Array<string> | Yes | IDs of the applications to add. | 578| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the applications cannot be installed by the specified user.<br> - If **userId** is not passed in, the applications cannot be installed by the current user.| 579 580**Return value** 581 582| Type | Description | 583| --------------------- | ------------------------- | 584| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown. | 585 586**Error codes** 587 588For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 589 590| ID| Error Message | 591| ------- | ---------------------------------------------------------------------------- | 592| 9200001 | the application is not an administrator of the device. | 593| 9200002 | the administrator application does not have permission to manage the device. | 594 595**Example** 596 597```ts 598import Want from '@ohos.app.ability.Want'; 599import { BusinessError } from '@ohos.base'; 600let wantTemp: Want = { 601 bundleName: 'com.example.myapplication', 602 abilityName: 'EntryAbility', 603}; 604let appIds: Array<string> = ['com.example.myapplication']; 605 606bundleManager.addDisallowedInstallBundles(wantTemp, appIds, 100).then(() => { 607 console.info('Succeeded in adding disallowed install bundles'); 608}).catch((err: BusinessError) => { 609 console.error(`Failed to add disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 610}); 611``` 612 613## bundleManager.removeDisallowedInstallBundles 614 615removeDisallowedInstallBundles(admin: Want, appIds: Array\<string>, callback: AsyncCallback<void>): void 616 617Removes the applications that cannot be installed by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 618 619**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 620 621**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 622 623**System API**: This is a system API. 624 625**Parameters** 626 627| Name | Type | Mandatory | Description | 628| -------- | ---------------------------------------- | ---- | ------------------------------- | 629| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 630| appIds | Array<string> | Yes | IDs of the applications to remove. | 631| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 632 633**Error codes** 634 635For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 636 637| ID| Error Message | 638| ------- | ---------------------------------------------------------------------------- | 639| 9200001 | the application is not an administrator of the device. | 640| 9200002 | the administrator application does not have permission to manage the device. | 641 642**Example** 643 644```ts 645import Want from '@ohos.app.ability.Want'; 646let wantTemp: Want = { 647 bundleName: 'com.example.myapplication', 648 abilityName: 'EntryAbility', 649}; 650let appIds: Array<string> = ['com.example.myapplication']; 651 652bundleManager.removeDisallowedInstallBundles(wantTemp, appIds, (err) => { 653 if (err) { 654 console.error(`Failed to remove disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 655 return; 656 } 657 console.info('Succeeded in removing disallowed install bundles'); 658}); 659``` 660 661## bundleManager.removeDisallowedInstallBundles 662 663removeDisallowedInstallBundles(admin: Want, appIds: Array\<string>, userId: number, callback: AsyncCallback<void>): void 664 665Removes the applications that cannot be installed by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 666 667**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 668 669**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 670 671**System API**: This is a system API. 672 673**Parameters** 674 675| Name | Type | Mandatory | Description | 676| ----- | ----------------------------------- | ---- | ------- | 677| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 678| appIds | Array<string> | Yes | IDs of the applications to remove. | 679| userId | number | Yes | User ID, which must be greater than or equal to 0.| 680| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 681 682**Error codes** 683 684For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 685 686| ID| Error Message | 687| ------- | ---------------------------------------------------------------------------- | 688| 9200001 | the application is not an administrator of the device. | 689| 9200002 | the administrator application does not have permission to manage the device. | 690 691**Example** 692 693```ts 694import Want from '@ohos.app.ability.Want'; 695let wantTemp: Want = { 696 bundleName: 'com.example.myapplication', 697 abilityName: 'EntryAbility', 698}; 699let appIds: Array<string> = ['com.example.myapplication']; 700 701bundleManager.removeDisallowedInstallBundles(wantTemp, appIds, 100, (err) => { 702 if (err) { 703 console.error(`Failed to remove disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 704 return; 705 } 706 console.info('Succeeded in removing disallowed install bundles'); 707}); 708``` 709 710## bundleManager.removeDisallowedInstallBundles 711 712removeDisallowedInstallBundles(admin: Want, appIds: Array\<string>, userId?: number): Promise<void> 713 714Removes the applications that cannot be installed by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 715 716**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 717 718**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 719 720**System API**: This is a system API. 721 722**Parameters** 723 724| Name | Type | Mandatory | Description | 725| ----- | ----------------------------------- | ---- | ------- | 726| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 727| appIds | Array\<string> | Yes | IDs of the applications to remove. | 728| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the applications cannot be installed by the specified user.<br> - If **userId** is not passed in, the applications cannot be installed by the current user.| 729 730**Return value** 731 732| Type | Description | 733| --------------------- | ------------------------- | 734| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown. | 735 736**Error codes** 737 738For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 739 740| ID| Error Message | 741| ------- | ---------------------------------------------------------------------------- | 742| 9200001 | the application is not an administrator of the device. | 743| 9200002 | the administrator application does not have permission to manage the device. | 744 745**Example** 746 747```ts 748import Want from '@ohos.app.ability.Want'; 749import { BusinessError } from '@ohos.base'; 750let wantTemp: Want = { 751 bundleName: 'com.example.myapplication', 752 abilityName: 'EntryAbility', 753}; 754let appIds: Array<string> = ['com.example.myapplication']; 755 756bundleManager.removeDisallowedInstallBundles(wantTemp, appIds, 100).then(() => { 757 console.info('Succeeded in removing disallowed install bundles'); 758}).catch((err: BusinessError) => { 759 console.error(`Failed to remove disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 760}); 761``` 762 763## bundleManager.getDisallowedInstallBundles 764 765getDisallowedInstallBundles(admin: Want, callback: AsyncCallback<Array<string>>): void 766 767Obtains the applications that cannot be installed by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 768 769**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 770 771**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 772 773**System API**: This is a system API. 774 775**Parameters** 776 777| Name | Type | Mandatory | Description | 778| -------- | ---------------------------------------- | ---- | ------------------------------- | 779| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 780| callback | AsyncCallback<Array<string>> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 781 782**Error codes** 783 784For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 785 786| ID| Error Message | 787| ------- | ---------------------------------------------------------------------------- | 788| 9200001 | the application is not an administrator of the device. | 789| 9200002 | the administrator application does not have permission to manage the device. | 790 791**Example** 792 793```ts 794import Want from '@ohos.app.ability.Want'; 795let wantTemp: Want = { 796 bundleName: 'com.example.myapplication', 797 abilityName: 'EntryAbility', 798}; 799 800bundleManager.getDisallowedInstallBundles(wantTemp, (err, result) => { 801 if (err) { 802 console.error(`Failed to get disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 803 return; 804 } 805 console.info(`Succeeded in getting disallowed install bundles, result : ${JSON.stringify(result)}`); 806}); 807``` 808 809## bundleManager.getDisallowedInstallBundles 810 811getDisallowedInstallBundles(admin: Want, userId: number, callback: AsyncCallback<Array<string>>): void 812 813Obtains the applications that cannot be installed by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 814 815**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 816 817**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 818 819**System API**: This is a system API. 820 821**Parameters** 822 823| Name | Type | Mandatory | Description | 824| -------- | ---------------------------------------- | ---- | ------------------------------- | 825| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 826| userId | number | Yes | User ID, which must be greater than or equal to 0.| 827| callback | AsyncCallback<Array<string>> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 828 829**Error codes** 830 831For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 832 833| ID| Error Message | 834| ------- | ---------------------------------------------------------------------------- | 835| 9200001 | the application is not an administrator of the device. | 836| 9200002 | the administrator application does not have permission to manage the device. | 837 838**Example** 839 840```ts 841import Want from '@ohos.app.ability.Want'; 842let wantTemp: Want = { 843 bundleName: 'com.example.myapplication', 844 abilityName: 'EntryAbility', 845}; 846 847bundleManager.getDisallowedInstallBundles(wantTemp, 100, (err, result) => { 848 if (err) { 849 console.error(`Failed to get disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 850 return; 851 } 852 console.info(`Succeeded in getting disallowed install bundles, result : ${JSON.stringify(result)}`); 853}); 854``` 855 856## bundleManager.getDisallowedInstallBundles 857 858getDisallowedInstallBundles(admin: Want, userId?: number): Promise<Array<string>> 859 860Obtains the applications that cannot be installed by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 861 862**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 863 864**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 865 866**System API**: This is a system API. 867 868**Parameters** 869 870| Name | Type | Mandatory | Description | 871| ----- | ----------------------------------- | ---- | ------- | 872| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application.| 873| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the applications cannot be installed by the specified user.<br> - If **userId** is not passed in, the applications cannot be installed by the current user.| 874 875**Return value** 876 877| Type | Description | 878| --------------------- | ------------------------- | 879| Promise<Array<string>> | Promise used to return the list of the bundles obtained.| 880 881**Error codes** 882 883For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 884 885| ID| Error Message | 886| ------- | ---------------------------------------------------------------------------- | 887| 9200001 | the application is not an administrator of the device. | 888| 9200002 | the administrator application does not have permission to manage the device. | 889 890**Example** 891 892```ts 893import Want from '@ohos.app.ability.Want'; 894import { BusinessError } from '@ohos.base'; 895let wantTemp: Want = { 896 bundleName: 'com.example.myapplication', 897 abilityName: 'EntryAbility', 898}; 899 900bundleManager.getDisallowedInstallBundles(wantTemp, 100).then((result) => { 901 console.info(`Succeeded in getting disallowed install bundles, result : ${JSON.stringify(result)}`); 902}).catch((err: BusinessError) => { 903 console.error(`Failed to get disallowed install bundles. Code is ${err.code}, message is ${err.message}`); 904}); 905``` 906 907## bundleManager.addDisallowedUninstallBundles 908 909addDisallowedUninstallBundles(admin: Want, appIds: Array\<string>, callback: AsyncCallback<void>): void 910 911Adds the applications that cannot be uninstalled by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 912 913**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 914 915**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 916 917**System API**: This is a system API. 918 919**Parameters** 920 921| Name | Type | Mandatory | Description | 922| -------- | ---------------------------------------- | ---- | ------------------------------- | 923| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 924| appIds | Array<string> | Yes | IDs of the applications to add. | 925| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 926 927**Error codes** 928 929For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 930 931| ID| Error Message | 932| ------- | ---------------------------------------------------------------------------- | 933| 9200001 | the application is not an administrator of the device. | 934| 9200002 | the administrator application does not have permission to manage the device. | 935 936**Example** 937 938```ts 939import Want from '@ohos.app.ability.Want'; 940let wantTemp: Want = { 941 bundleName: 'com.example.myapplication', 942 abilityName: 'EntryAbility', 943}; 944let appIds: Array<string> = ['com.example.myapplication']; 945 946bundleManager.addDisallowedUninstallBundles(wantTemp, appIds, (err) => { 947 if (err) { 948 console.error(`Failed to add disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 949 return; 950 } 951 console.info('Succeeded in adding disallowed uninstall bundles'); 952}); 953``` 954 955## bundleManager.addDisallowedUninstallBundles 956 957addDisallowedUninstallBundles(admin: Want, appIds: Array\<string>, userId: number, callback: AsyncCallback<void>): void 958 959Adds the applications that cannot be uninstalled by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 960 961**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 962 963**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 964 965**System API**: This is a system API. 966 967**Parameters** 968 969| Name | Type | Mandatory | Description | 970| ----- | ----------------------------------- | ---- | ------- | 971| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 972| appIds | Array<string> | Yes | IDs of the applications to add. | 973| userId | number | Yes | User ID, which must be greater than or equal to 0.| 974| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 975 976**Error codes** 977 978For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 979 980| ID| Error Message | 981| ------- | ---------------------------------------------------------------------------- | 982| 9200001 | the application is not an administrator of the device. | 983| 9200002 | the administrator application does not have permission to manage the device. | 984 985**Example** 986 987```ts 988import Want from '@ohos.app.ability.Want'; 989let wantTemp: Want = { 990 bundleName: 'com.example.myapplication', 991 abilityName: 'EntryAbility', 992}; 993let appIds: Array<string> = ['com.example.myapplication']; 994 995bundleManager.addDisallowedUninstallBundles(wantTemp, appIds, 100, (err) => { 996 if (err) { 997 console.error(`Failed to add disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 998 return; 999 } 1000 console.info('Succeeded in adding disallowed uninstall bundles'); 1001}); 1002``` 1003 1004## bundleManager.addDisallowedUninstallBundles 1005 1006addDisallowedUninstallBundles(admin: Want, appIds: Array\<string>, userId?: number): Promise<void> 1007 1008Adds the applications that cannot be uninstalled by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 1009 1010**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1011 1012**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1013 1014**System API**: This is a system API. 1015 1016**Parameters** 1017 1018| Name | Type | Mandatory | Description | 1019| ----- | ----------------------------------- | ---- | ------- | 1020| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1021| appIds | Array<string> | Yes | IDs of the applications to add. | 1022| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the applications cannot be uninstalled by the specified user.<br> - If **userId** is not passed in, the applications cannot be uninstalled by the current user.| 1023 1024**Return value** 1025 1026| Type | Description | 1027| --------------------- | ------------------------- | 1028| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown. | 1029 1030**Error codes** 1031 1032For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1033 1034| ID| Error Message | 1035| ------- | ---------------------------------------------------------------------------- | 1036| 9200001 | the application is not an administrator of the device. | 1037| 9200002 | the administrator application does not have permission to manage the device. | 1038 1039**Example** 1040 1041```ts 1042import Want from '@ohos.app.ability.Want'; 1043import { BusinessError } from '@ohos.base'; 1044let wantTemp: Want = { 1045 bundleName: 'com.example.myapplication', 1046 abilityName: 'EntryAbility', 1047}; 1048let appIds: Array<string> = ['com.example.myapplication']; 1049 1050bundleManager.addDisallowedUninstallBundles(wantTemp, appIds, 100).then(() => { 1051 console.info('Succeeded in adding disallowed uninstall bundles'); 1052}).catch((err: BusinessError) => { 1053 console.error(`Failed to add disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1054}); 1055``` 1056 1057## bundleManager.removeDisallowedUninstallBundles 1058 1059removeDisallowedUninstallBundles(admin: Want, appIds: Array\<string>, callback: AsyncCallback<void>): void 1060 1061Removes the applications that cannot be uninstalled by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 1062 1063**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1064 1065**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1066 1067**System API**: This is a system API. 1068 1069**Parameters** 1070 1071| Name | Type | Mandatory | Description | 1072| -------- | ---------------------------------------- | ---- | ------------------------------- | 1073| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1074| appIds | Array<string> | Yes | IDs of the applications to remove. | 1075| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 1076 1077**Error codes** 1078 1079For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1080 1081| ID| Error Message | 1082| ------- | ---------------------------------------------------------------------------- | 1083| 9200001 | the application is not an administrator of the device. | 1084| 9200002 | the administrator application does not have permission to manage the device. | 1085 1086**Example** 1087 1088```ts 1089import Want from '@ohos.app.ability.Want'; 1090let wantTemp: Want = { 1091 bundleName: 'com.example.myapplication', 1092 abilityName: 'EntryAbility', 1093}; 1094let appIds: Array<string> = ['com.example.myapplication']; 1095 1096bundleManager.removeDisallowedUninstallBundles(wantTemp, appIds, (err) => { 1097 if (err) { 1098 console.error(`Failed to remove disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1099 return; 1100 } 1101 console.info('Succeeded in removing disallowed uninstall bundles'); 1102}); 1103``` 1104 1105## bundleManager.removeDisallowedUninstallBundles 1106 1107removeDisallowedUninstallBundles(admin: Want, appIds: Array\<string>, userId: number, callback: AsyncCallback<void>): void 1108 1109Removes the applications that cannot be uninstalled by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 1110 1111**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1112 1113**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1114 1115**System API**: This is a system API. 1116 1117**Parameters** 1118 1119| Name | Type | Mandatory | Description | 1120| ----- | ----------------------------------- | ---- | ------- | 1121| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1122| appIds | Array<string> | Yes | IDs of the applications to remove. | 1123| userId | number | Yes | User ID, which must be greater than or equal to 0.| 1124| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object.| 1125 1126**Error codes** 1127 1128For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1129 1130| ID| Error Message | 1131| ------- | ---------------------------------------------------------------------------- | 1132| 9200001 | the application is not an administrator of the device. | 1133| 9200002 | the administrator application does not have permission to manage the device. | 1134 1135**Example** 1136 1137```ts 1138import Want from '@ohos.app.ability.Want'; 1139let wantTemp: Want = { 1140 bundleName: 'com.example.myapplication', 1141 abilityName: 'EntryAbility', 1142}; 1143let appIds: Array<string> = ['com.example.myapplication']; 1144 1145bundleManager.removeDisallowedUninstallBundles(wantTemp, appIds, 100, (err) => { 1146 if (err) { 1147 console.error(`Failed to remove disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1148 return; 1149 } 1150 console.info('Succeeded in removing disallowed uninstall bundles'); 1151}); 1152``` 1153 1154## bundleManager.removeDisallowedUninstallBundles 1155 1156removeDisallowedUninstallBundles(admin: Want, appIds: Array\<string>, userId?: number): Promise<void> 1157 1158Removes the applications that cannot be uninstalled by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 1159 1160**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1161 1162**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1163 1164**System API**: This is a system API. 1165 1166**Parameters** 1167 1168| Name | Type | Mandatory | Description | 1169| ----- | ----------------------------------- | ---- | ------- | 1170| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1171| appIds | Array\<string> | Yes | IDs of the applications to remove. | 1172| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the applications cannot be uninstalled by the specified user.<br> - If **userId** is not passed in, the applications cannot be uninstalled by the current user.| 1173 1174**Return value** 1175 1176| Type | Description | 1177| --------------------- | ------------------------- | 1178| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown. | 1179 1180**Error codes** 1181 1182For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1183 1184| ID| Error Message | 1185| ------- | ---------------------------------------------------------------------------- | 1186| 9200001 | the application is not an administrator of the device. | 1187| 9200002 | the administrator application does not have permission to manage the device. | 1188 1189**Example** 1190 1191```ts 1192import Want from '@ohos.app.ability.Want'; 1193import { BusinessError } from '@ohos.base'; 1194let wantTemp: Want = { 1195 bundleName: 'com.example.myapplication', 1196 abilityName: 'EntryAbility', 1197}; 1198let appIds: Array<string> = ['com.example.myapplication']; 1199 1200bundleManager.removeDisallowedUninstallBundles(wantTemp, appIds, 100).then(() => { 1201 console.info('Succeeded in removing disallowed uninstall bundles'); 1202}).catch((err: BusinessError) => { 1203 console.error(`Failed to remove disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1204}); 1205``` 1206 1207## bundleManager.getDisallowedUninstallBundles 1208 1209getDisallowedUninstallBundles(admin: Want, callback: AsyncCallback<Array<string>>): void 1210 1211Obtains the applications that cannot be uninstalled by the current user through the specified device administrator application. This API uses an asynchronous callback to return the result. 1212 1213**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1214 1215**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1216 1217**System API**: This is a system API. 1218 1219**Parameters** 1220 1221| Name | Type | Mandatory | Description | 1222| -------- | ---------------------------------------- | ---- | ------------------------------- | 1223| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1224| callback | AsyncCallback<Array<string>> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1225 1226**Error codes** 1227 1228For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1229 1230| ID| Error Message | 1231| ------- | ---------------------------------------------------------------------------- | 1232| 9200001 | the application is not an administrator of the device. | 1233| 9200002 | the administrator application does not have permission to manage the device. | 1234 1235**Example** 1236 1237```ts 1238import Want from '@ohos.app.ability.Want'; 1239let wantTemp: Want = { 1240 bundleName: 'com.example.myapplication', 1241 abilityName: 'EntryAbility', 1242}; 1243 1244bundleManager.getDisallowedUninstallBundles(wantTemp, (err, result) => { 1245 if (err) { 1246 console.error(`Failed to get disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1247 return; 1248 } 1249 console.info(`Succeeded in getting disallowed uninstall bundles, result : ${JSON.stringify(result)}`); 1250}); 1251``` 1252 1253## bundleManager.getDisallowedUninstallBundles 1254 1255getDisallowedUninstallBundles(admin: Want, userId: number, callback: AsyncCallback<Array<string>>): void 1256 1257Obtains the applications that cannot be uninstalled by the specified user through the specified device administrator application. This API uses an asynchronous callback to return the result. 1258 1259**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1260 1261**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1262 1263**System API**: This is a system API. 1264 1265**Parameters** 1266 1267| Name | Type | Mandatory | Description | 1268| -------- | ---------------------------------------- | ---- | ------------------------------- | 1269| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1270| userId | number | Yes | User ID, which must be greater than or equal to 0.| 1271| callback | AsyncCallback<Array<string>> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1272 1273**Error codes** 1274 1275For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1276 1277| ID| Error Message | 1278| ------- | ---------------------------------------------------------------------------- | 1279| 9200001 | the application is not an administrator of the device. | 1280| 9200002 | the administrator application does not have permission to manage the device. | 1281 1282**Example** 1283 1284```ts 1285import Want from '@ohos.app.ability.Want'; 1286let wantTemp: Want = { 1287 bundleName: 'com.example.myapplication', 1288 abilityName: 'EntryAbility', 1289}; 1290 1291bundleManager.getDisallowedUninstallBundles(wantTemp, 100, (err, result) => { 1292 if (err) { 1293 console.error(`Failed to get disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1294 return; 1295 } 1296 console.info(`Succeeded in getting disallowed uninstall bundles, result : ${JSON.stringify(result)}`); 1297}); 1298``` 1299 1300## bundleManager.getDisallowedUninstallBundles 1301 1302getDisallowedUninstallBundles(admin: Want, userId?: number): Promise<Array<string>> 1303 1304Obtains the applications that cannot be uninstalled by the current or specified user through the specified device administrator application. This API uses a promise to return the result. 1305 1306**Required permissions**: ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY 1307 1308**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1309 1310**System API**: This is a system API. 1311 1312**Parameters** 1313 1314| Name | Type | Mandatory | Description | 1315| ----- | ----------------------------------- | ---- | ------- | 1316| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application.| 1317| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the applications cannot be uninstalled by the specified user.<br> - If **userId** is not passed in, the applications cannot be uninstalled by the current user.| 1318 1319**Return value** 1320 1321| Type | Description | 1322| --------------------- | ------------------------- | 1323| Promise<Array<string>> | Promise used to return the bundle list obtained.| 1324 1325**Error codes** 1326 1327For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1328 1329| ID| Error Message | 1330| ------- | ---------------------------------------------------------------------------- | 1331| 9200001 | the application is not an administrator of the device. | 1332| 9200002 | the administrator application does not have permission to manage the device. | 1333 1334**Example** 1335 1336```ts 1337import Want from '@ohos.app.ability.Want'; 1338import { BusinessError } from '@ohos.base'; 1339let wantTemp: Want = { 1340 bundleName: 'com.example.myapplication', 1341 abilityName: 'EntryAbility', 1342}; 1343 1344bundleManager.getDisallowedUninstallBundles(wantTemp, 100).then((result) => { 1345 console.info(`Succeeded in getting disallowed uninstall bundles, result : ${JSON.stringify(result)}`); 1346}).catch((err: BusinessError) => { 1347 console.error(`Failed to get disallowed uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1348}); 1349``` 1350 1351## bundleManager.uninstall 1352 1353uninstall(admin: Want, bundleName: string, callback: AsyncCallback<void>): void 1354 1355Uninstalls an application of the current user without retaining the bundle data through the specified device administrator application. This API uses an asynchronous callback to return the result. 1356 1357**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1358 1359**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1360 1361**System API**: This is a system API. 1362 1363**Parameters** 1364 1365| Name | Type | Mandatory | Description | 1366| -------- | ---------------------------------------- | ---- | ------------------------------- | 1367| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1368| bundleName | string | Yes | Name of the bundle to uninstall.| 1369| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1370 1371**Error codes** 1372 1373For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1374 1375| ID| Error Message | 1376| ------- | ---------------------------------------------------------------------------- | 1377| 9200001 | the application is not an administrator of the device. | 1378| 9200002 | the administrator application does not have permission to manage the device. | 1379 1380**Example** 1381 1382```ts 1383import Want from '@ohos.app.ability.Want'; 1384let wantTemp: Want = { 1385 bundleName: 'com.example.myapplication', 1386 abilityName: 'EntryAbility', 1387}; 1388 1389bundleManager.uninstall(wantTemp, 'bundleName', (err) => { 1390 if (err) { 1391 console.error(`Failed to uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1392 return; 1393 } 1394 console.info('Succeeded in uninstalling bundles'); 1395}); 1396``` 1397 1398## bundleManager.uninstall 1399 1400uninstall(admin: Want, bundleName: string, userId: number, callback: AsyncCallback<void>): void 1401 1402Uninstalls an application of the specified user without retaining the bundle data through the specified device administrator application. This API uses an asynchronous callback to return the result. 1403 1404**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1405 1406**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1407 1408**System API**: This is a system API. 1409 1410**Parameters** 1411 1412| Name | Type | Mandatory | Description | 1413| -------- | ---------------------------------------- | ---- | ------------------------------- | 1414| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1415| bundleName | string | Yes | Name of the bundle to uninstall.| 1416| userId | number | Yes | User ID, which must be greater than or equal to 0.| 1417| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1418 1419**Error codes** 1420 1421For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1422 1423| ID| Error Message | 1424| ------- | ---------------------------------------------------------------------------- | 1425| 9200001 | the application is not an administrator of the device. | 1426| 9200002 | the administrator application does not have permission to manage the device. | 1427 1428**Example** 1429 1430```ts 1431import Want from '@ohos.app.ability.Want'; 1432let wantTemp: Want = { 1433 bundleName: 'com.example.myapplication', 1434 abilityName: 'EntryAbility', 1435}; 1436 1437bundleManager.uninstall(wantTemp, 'bundleName', 100, (err) => { 1438 if (err) { 1439 console.error(`Failed to uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1440 return; 1441 } 1442 console.info('Succeeded in uninstalling bundles'); 1443}); 1444``` 1445 1446## bundleManager.uninstall 1447 1448uninstall(admin: Want, bundleName: string, isKeepData: boolean, callback: AsyncCallback<void>): void 1449 1450Uninstalls an application of the current user through the specified device administrator application. The **isKeepData** parameter specifies whether to retain the bundle data. This API uses an asynchronous callback to return the result. 1451 1452**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1453 1454**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1455 1456**System API**: This is a system API. 1457 1458**Parameters** 1459 1460| Name | Type | Mandatory | Description | 1461| -------- | ---------------------------------------- | ---- | ------------------------------- | 1462| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1463| bundleName | string | Yes | Name of the bundle to uninstall.| 1464| isKeepData | boolean | Yes | Whether to retain the bundle data. The value **true** means to retain the bundle data; the value **false** means the opposite.| 1465| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1466 1467**Error codes** 1468 1469For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1470 1471| ID| Error Message | 1472| ------- | ---------------------------------------------------------------------------- | 1473| 9200001 | the application is not an administrator of the device. | 1474| 9200002 | the administrator application does not have permission to manage the device. | 1475 1476**Example** 1477 1478```ts 1479import Want from '@ohos.app.ability.Want'; 1480let wantTemp: Want = { 1481 bundleName: 'com.example.myapplication', 1482 abilityName: 'EntryAbility', 1483}; 1484 1485bundleManager.uninstall(wantTemp, 'bundleName', true, (err) => { 1486 if (err) { 1487 console.error(`Failed to uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1488 return; 1489 } 1490 console.info('Succeeded in uninstalling bundles'); 1491}); 1492``` 1493 1494## bundleManager.uninstall 1495 1496uninstall(admin: Want, bundleName: string, userId: number, isKeepData: boolean, callback: AsyncCallback<void>): void 1497 1498Uninstalls an application of the specified user through the specified device administrator application. The **isKeepData** parameter specifies whether to retain the bundle data. This API uses an asynchronous callback to return the result. 1499 1500**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1501 1502**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1503 1504**System API**: This is a system API. 1505 1506**Parameters** 1507 1508| Name | Type | Mandatory | Description | 1509| -------- | ---------------------------------------- | ---- | ------------------------------- | 1510| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1511| bundleName | string | Yes | Name of the bundle to uninstall.| 1512| userId | number | Yes | User ID, which must be greater than or equal to 0.| 1513| isKeepData | boolean | Yes | Whether to retain the bundle data. The value **true** means to retain the bundle data; the value **false** means the opposite.| 1514| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1515 1516**Error codes** 1517 1518For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1519 1520| ID| Error Message | 1521| ------- | ---------------------------------------------------------------------------- | 1522| 9200001 | the application is not an administrator of the device. | 1523| 9200002 | the administrator application does not have permission to manage the device. | 1524 1525**Example** 1526 1527```ts 1528import Want from '@ohos.app.ability.Want'; 1529let wantTemp: Want = { 1530 bundleName: 'com.example.myapplication', 1531 abilityName: 'EntryAbility', 1532}; 1533 1534bundleManager.uninstall(wantTemp, 'bundleName', 100, true, (err) => { 1535 if (err) { 1536 console.error(`Failed to uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1537 return; 1538 } 1539 console.info('Succeeded in uninstalling bundles'); 1540}); 1541``` 1542 1543## bundleManager.uninstall 1544 1545uninstall(admin: Want, bundleName: string, userId?: number, isKeepData?: boolean): Promise<void> 1546 1547Uninstalls an application of the current or specified user through the specified device administrator application. The **isKeepData** parameter specifies whether to retain the bundle data. This API uses a promise to return the result. 1548 1549**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1550 1551**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1552 1553**System API**: This is a system API. 1554 1555**Parameters** 1556 1557| Name | Type | Mandatory | Description | 1558| ----- | ----------------------------------- | ---- | ------- | 1559| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application.| 1560| bundleName | string | Yes | Name of the bundle to uninstall.| 1561| userId | number | No | User ID, which must be greater than or equal to 0.<br> - If **userId** is passed in, the application of the specified user is uninstalled.<br> - If **userId** is not passed in, the application of the current user is uninstalled.| 1562| isKeepData | boolean | No | Whether to retain the bundle data. The value **true** means to retain the bundle data; the value **false** means the opposite.| 1563 1564**Return value** 1565 1566| Type | Description | 1567| --------------------- | ------------------------- | 1568| Promise<void> | Promise that returns no value. An error object will be thrown if the bundle fails to be uninstalled.| 1569 1570**Error codes** 1571 1572For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1573 1574| ID| Error Message | 1575| ------- | ---------------------------------------------------------------------------- | 1576| 9200001 | the application is not an administrator of the device. | 1577| 9200002 | the administrator application does not have permission to manage the device. | 1578 1579**Example** 1580 1581```ts 1582import Want from '@ohos.app.ability.Want'; 1583import { BusinessError } from '@ohos.base'; 1584let wantTemp: Want = { 1585 bundleName: 'com.example.myapplication', 1586 abilityName: 'EntryAbility', 1587}; 1588 1589bundleManager.uninstall(wantTemp, 'bundleName', 100, true).then(() => { 1590 console.info('Succeeded in uninstalling bundles'); 1591}).catch((err: BusinessError) => { 1592 console.error(`Failed to uninstall bundles. Code is ${err.code}, message is ${err.message}`); 1593}); 1594``` 1595 1596## bundleManager.install 1597 1598install(admin: Want, hapFilePaths: Array\<string>, callback: AsyncCallback\<void>): void 1599 1600Installs applications through the specified device administrator application. This API uses an asynchronous callback to return the result. 1601 1602**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1603 1604**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1605 1606**System API**: This is a system API. 1607 1608**Parameters** 1609 1610| Name | Type | Mandatory | Description | 1611| -------- | ---------------------------------------- | ---- | ------------------------------- | 1612| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1613| hapFilePaths | Array\<string> | Yes | Applications to install.| 1614| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1615 1616**Error codes** 1617 1618For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1619 1620| ID| Error Message | 1621| ------- | ---------------------------------------------------------------------------- | 1622| 9200001 | the application is not an administrator of the device. | 1623| 9200002 | the administrator application does not have permission to manage the device. | 1624| 9201002 | the application install failed. | 1625 1626**Example** 1627 1628```ts 1629import Want from '@ohos.app.ability.Want'; 1630let wantTemp: Want = { 1631 bundleName: 'com.example.myapplication', 1632 abilityName: 'EntryAbility', 1633}; 1634let hapFilePaths: Array<string> = ['/data/storage/el2/base/haps/entry/testinstall/ExtensionTest.hap']; 1635 1636bundleManager.install(wantTemp, hapFilePaths, (err) => { 1637 if (err) { 1638 console.error(`Failed to install bundles. Code is ${err.code}, message is ${err.message}`); 1639 return; 1640 } 1641 console.info('Succeeded in installing bundles'); 1642}); 1643``` 1644 1645## bundleManager.install 1646 1647install(admin: Want, hapFilePaths: Array\<string>, installParam: InstallParam, callback: AsyncCallback\<void>): void 1648 1649Installs applications with specified parameters through the specified device administrator application. This API uses an asynchronous callback to return the result. 1650 1651**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1652 1653**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1654 1655**System API**: This is a system API. 1656 1657**Parameters** 1658 1659| Name | Type | Mandatory | Description | 1660| -------- | ---------------------------------------- | ---- | ------------------------------- | 1661| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application. | 1662| hapFilePaths | Array\<string> | Yes | Applications to install.| 1663| installParam | [InstallParam](#installparam) | Yes | Application installation parameters.| 1664| callback | AsyncCallback<void> | Yes | Callback invoked to return the result. If the operation is successful, **err** is **null**. Otherwise, **err** is an error object. | 1665 1666**Error codes** 1667 1668For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1669 1670| ID| Error Message | 1671| ------- | ---------------------------------------------------------------------------- | 1672| 9200001 | the application is not an administrator of the device. | 1673| 9200002 | the administrator application does not have permission to manage the device. | 1674| 9201002 | the application install failed. | 1675 1676**Example** 1677 1678```ts 1679import Want from '@ohos.app.ability.Want'; 1680let wantTemp: Want = { 1681 bundleName: 'com.example.myapplication', 1682 abilityName: 'EntryAbility', 1683}; 1684let hapFilePaths: Array<string> = ['/data/storage/el2/base/haps/entry/testinstall/ExtensionTest.hap']; 1685let installParam: bundleManager.InstallParam = { 1686 userId: 100, 1687 installFlag: 1, 1688}; 1689 1690bundleManager.install(wantTemp, hapFilePaths, installParam, (err) => { 1691 if (err) { 1692 console.error(`Failed to install bundles. Code is ${err.code}, message is ${err.message}`); 1693 return; 1694 } 1695 console.info('Succeeded in installing bundles'); 1696}); 1697``` 1698 1699## bundleManager.install 1700 1701install(admin: Want, hapFilePaths: Array\<string>, installParam?: InstallParam): Promise\<void> 1702 1703Installs applications through the specified device administrator application. This API uses a promise to return the result. 1704 1705**Required permissions**: ohos.permission.ENTERPRISE_INSTALL_BUNDLE 1706 1707**System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1708 1709**System API**: This is a system API. 1710 1711**Parameters** 1712 1713| Name | Type | Mandatory | Description | 1714| ----- | ----------------------------------- | ---- | ------- | 1715| admin | [Want](js-apis-app-ability-want.md) | Yes | Device administrator application.| 1716| hapFilePaths | Array\<string> | Yes | Applications to install.| 1717| installParam | [InstallParam](#installparam) | No | Application installation parameters.| 1718 1719**Return value** 1720 1721| Type | Description | 1722| --------------------- | ------------------------- | 1723| Promise<void> | Promise that returns no value. If the operation fails, an error object will be thrown.| 1724 1725**Error codes** 1726 1727For details about the error codes, see [Enterprise Device Management Error Codes](../errorcodes/errorcode-enterpriseDeviceManager.md). 1728 1729| ID| Error Message | 1730| ------- | ---------------------------------------------------------------------------- | 1731| 9200001 | the application is not an administrator of the device. | 1732| 9200002 | the administrator application does not have permission to manage the device. | 1733| 9201002 | the application install failed. | 1734 1735**Example** 1736 1737```ts 1738import Want from '@ohos.app.ability.Want'; 1739import { BusinessError } from '@ohos.base'; 1740let wantTemp: Want = { 1741 bundleName: 'com.example.myapplication', 1742 abilityName: 'EntryAbility', 1743}; 1744let hapFilePaths: Array<string> = ['/data/storage/el2/base/haps/entry/testinstall/ExtensionTest.hap']; 1745 1746bundleManager.install(wantTemp, hapFilePaths).then(() => { 1747 console.info('Succeeded in installing bundles'); 1748}).catch((err: BusinessError) => { 1749 console.error(`Failed to install bundles. Code is ${err.code}, message is ${err.message}`); 1750}); 1751``` 1752 1753## InstallParam 1754 1755Defines the parameters specified for installing applications. 1756 1757 **System capability**: SystemCapability.Customization.EnterpriseDeviceManager 1758 1759 **System API**: This is a system API. 1760 1761| Name | Type | Mandatory | Description | 1762| ------------------------------ | ------------------------------ | ------------------ | ------------------ | 1763| userId | number | No | User ID, which must be greater than or equal to 0. The default value is the user ID of the caller. | 1764| installFlag | number | No | Installation flag.<br>- **0**: initial installation.<br>- **1**: overwrite installation.<br>- **2**: installation-free.<br>Default value: **0**| 1765