1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.os.storage; 18 19 import android.content.pm.IPackageMoveObserver; 20 import android.os.Binder; 21 import android.os.IBinder; 22 import android.os.IInterface; 23 import android.os.Parcel; 24 import android.os.RemoteException; 25 26 /** 27 * WARNING! Update IMountService.h and IMountService.cpp if you change this 28 * file. In particular, the ordering of the methods below must match the 29 * _TRANSACTION enum in IMountService.cpp 30 * 31 * @hide - Applications should use android.os.storage.StorageManager to access 32 * storage functions. 33 */ 34 public interface IMountService extends IInterface { 35 /** Local-side IPC implementation stub class. */ 36 public static abstract class Stub extends Binder implements IMountService { 37 private static class Proxy implements IMountService { 38 private final IBinder mRemote; 39 Proxy(IBinder remote)40 Proxy(IBinder remote) { 41 mRemote = remote; 42 } 43 asBinder()44 public IBinder asBinder() { 45 return mRemote; 46 } 47 getInterfaceDescriptor()48 public String getInterfaceDescriptor() { 49 return DESCRIPTOR; 50 } 51 52 /** 53 * Registers an IMountServiceListener for receiving async 54 * notifications. 55 */ registerListener(IMountServiceListener listener)56 public void registerListener(IMountServiceListener listener) throws RemoteException { 57 Parcel _data = Parcel.obtain(); 58 Parcel _reply = Parcel.obtain(); 59 try { 60 _data.writeInterfaceToken(DESCRIPTOR); 61 _data.writeStrongBinder((listener != null ? listener.asBinder() : null)); 62 mRemote.transact(Stub.TRANSACTION_registerListener, _data, _reply, 0); 63 _reply.readException(); 64 } finally { 65 _reply.recycle(); 66 _data.recycle(); 67 } 68 } 69 70 /** 71 * Unregisters an IMountServiceListener 72 */ unregisterListener(IMountServiceListener listener)73 public void unregisterListener(IMountServiceListener listener) throws RemoteException { 74 Parcel _data = Parcel.obtain(); 75 Parcel _reply = Parcel.obtain(); 76 try { 77 _data.writeInterfaceToken(DESCRIPTOR); 78 _data.writeStrongBinder((listener != null ? listener.asBinder() : null)); 79 mRemote.transact(Stub.TRANSACTION_unregisterListener, _data, _reply, 0); 80 _reply.readException(); 81 } finally { 82 _reply.recycle(); 83 _data.recycle(); 84 } 85 } 86 87 /** 88 * Returns true if a USB mass storage host is connected 89 */ isUsbMassStorageConnected()90 public boolean isUsbMassStorageConnected() throws RemoteException { 91 Parcel _data = Parcel.obtain(); 92 Parcel _reply = Parcel.obtain(); 93 boolean _result; 94 try { 95 _data.writeInterfaceToken(DESCRIPTOR); 96 mRemote.transact(Stub.TRANSACTION_isUsbMassStorageConnected, _data, _reply, 0); 97 _reply.readException(); 98 _result = 0 != _reply.readInt(); 99 } finally { 100 _reply.recycle(); 101 _data.recycle(); 102 } 103 return _result; 104 } 105 106 /** 107 * Enables / disables USB mass storage. The caller should check 108 * actual status of enabling/disabling USB mass storage via 109 * StorageEventListener. 110 */ setUsbMassStorageEnabled(boolean enable)111 public void setUsbMassStorageEnabled(boolean enable) throws RemoteException { 112 Parcel _data = Parcel.obtain(); 113 Parcel _reply = Parcel.obtain(); 114 try { 115 _data.writeInterfaceToken(DESCRIPTOR); 116 _data.writeInt((enable ? 1 : 0)); 117 mRemote.transact(Stub.TRANSACTION_setUsbMassStorageEnabled, _data, _reply, 0); 118 _reply.readException(); 119 } finally { 120 _reply.recycle(); 121 _data.recycle(); 122 } 123 } 124 125 /** 126 * Returns true if a USB mass storage host is enabled (media is 127 * shared) 128 */ isUsbMassStorageEnabled()129 public boolean isUsbMassStorageEnabled() throws RemoteException { 130 Parcel _data = Parcel.obtain(); 131 Parcel _reply = Parcel.obtain(); 132 boolean _result; 133 try { 134 _data.writeInterfaceToken(DESCRIPTOR); 135 mRemote.transact(Stub.TRANSACTION_isUsbMassStorageEnabled, _data, _reply, 0); 136 _reply.readException(); 137 _result = 0 != _reply.readInt(); 138 } finally { 139 _reply.recycle(); 140 _data.recycle(); 141 } 142 return _result; 143 } 144 145 /** 146 * Mount external storage at given mount point. Returns an int 147 * consistent with MountServiceResultCode 148 */ mountVolume(String mountPoint)149 public int mountVolume(String mountPoint) throws RemoteException { 150 Parcel _data = Parcel.obtain(); 151 Parcel _reply = Parcel.obtain(); 152 int _result; 153 try { 154 _data.writeInterfaceToken(DESCRIPTOR); 155 _data.writeString(mountPoint); 156 mRemote.transact(Stub.TRANSACTION_mountVolume, _data, _reply, 0); 157 _reply.readException(); 158 _result = _reply.readInt(); 159 } finally { 160 _reply.recycle(); 161 _data.recycle(); 162 } 163 return _result; 164 } 165 166 /** 167 * Safely unmount external storage at given mount point. The unmount 168 * is an asynchronous operation. Applications should register 169 * StorageEventListener for storage related status changes. 170 */ unmountVolume(String mountPoint, boolean force, boolean removeEncryption)171 public void unmountVolume(String mountPoint, boolean force, boolean removeEncryption) 172 throws RemoteException { 173 Parcel _data = Parcel.obtain(); 174 Parcel _reply = Parcel.obtain(); 175 try { 176 _data.writeInterfaceToken(DESCRIPTOR); 177 _data.writeString(mountPoint); 178 _data.writeInt((force ? 1 : 0)); 179 _data.writeInt((removeEncryption ? 1 : 0)); 180 mRemote.transact(Stub.TRANSACTION_unmountVolume, _data, _reply, 0); 181 _reply.readException(); 182 } finally { 183 _reply.recycle(); 184 _data.recycle(); 185 } 186 } 187 188 /** 189 * Format external storage given a mount point. Returns an int 190 * consistent with MountServiceResultCode 191 */ formatVolume(String mountPoint)192 public int formatVolume(String mountPoint) throws RemoteException { 193 Parcel _data = Parcel.obtain(); 194 Parcel _reply = Parcel.obtain(); 195 int _result; 196 try { 197 _data.writeInterfaceToken(DESCRIPTOR); 198 _data.writeString(mountPoint); 199 mRemote.transact(Stub.TRANSACTION_formatVolume, _data, _reply, 0); 200 _reply.readException(); 201 _result = _reply.readInt(); 202 } finally { 203 _reply.recycle(); 204 _data.recycle(); 205 } 206 return _result; 207 } 208 209 /** 210 * Returns an array of pids with open files on the specified path. 211 */ getStorageUsers(String path)212 public int[] getStorageUsers(String path) throws RemoteException { 213 Parcel _data = Parcel.obtain(); 214 Parcel _reply = Parcel.obtain(); 215 int[] _result; 216 try { 217 _data.writeInterfaceToken(DESCRIPTOR); 218 _data.writeString(path); 219 mRemote.transact(Stub.TRANSACTION_getStorageUsers, _data, _reply, 0); 220 _reply.readException(); 221 _result = _reply.createIntArray(); 222 } finally { 223 _reply.recycle(); 224 _data.recycle(); 225 } 226 return _result; 227 } 228 229 /** 230 * Gets the state of a volume via its mountpoint. 231 */ getVolumeState(String mountPoint)232 public String getVolumeState(String mountPoint) throws RemoteException { 233 Parcel _data = Parcel.obtain(); 234 Parcel _reply = Parcel.obtain(); 235 String _result; 236 try { 237 _data.writeInterfaceToken(DESCRIPTOR); 238 _data.writeString(mountPoint); 239 mRemote.transact(Stub.TRANSACTION_getVolumeState, _data, _reply, 0); 240 _reply.readException(); 241 _result = _reply.readString(); 242 } finally { 243 _reply.recycle(); 244 _data.recycle(); 245 } 246 return _result; 247 } 248 249 /* 250 * Creates a secure container with the specified parameters. Returns 251 * an int consistent with MountServiceResultCode 252 */ createSecureContainer(String id, int sizeMb, String fstype, String key, int ownerUid, boolean external)253 public int createSecureContainer(String id, int sizeMb, String fstype, String key, 254 int ownerUid, boolean external) throws RemoteException { 255 Parcel _data = Parcel.obtain(); 256 Parcel _reply = Parcel.obtain(); 257 int _result; 258 try { 259 _data.writeInterfaceToken(DESCRIPTOR); 260 _data.writeString(id); 261 _data.writeInt(sizeMb); 262 _data.writeString(fstype); 263 _data.writeString(key); 264 _data.writeInt(ownerUid); 265 _data.writeInt(external ? 1 : 0); 266 mRemote.transact(Stub.TRANSACTION_createSecureContainer, _data, _reply, 0); 267 _reply.readException(); 268 _result = _reply.readInt(); 269 } finally { 270 _reply.recycle(); 271 _data.recycle(); 272 } 273 return _result; 274 } 275 276 /* 277 * Destroy a secure container, and free up all resources associated 278 * with it. NOTE: Ensure all references are released prior to 279 * deleting. Returns an int consistent with MountServiceResultCode 280 */ destroySecureContainer(String id, boolean force)281 public int destroySecureContainer(String id, boolean force) throws RemoteException { 282 Parcel _data = Parcel.obtain(); 283 Parcel _reply = Parcel.obtain(); 284 int _result; 285 try { 286 _data.writeInterfaceToken(DESCRIPTOR); 287 _data.writeString(id); 288 _data.writeInt((force ? 1 : 0)); 289 mRemote.transact(Stub.TRANSACTION_destroySecureContainer, _data, _reply, 0); 290 _reply.readException(); 291 _result = _reply.readInt(); 292 } finally { 293 _reply.recycle(); 294 _data.recycle(); 295 } 296 return _result; 297 } 298 299 /* 300 * Finalize a container which has just been created and populated. 301 * After finalization, the container is immutable. Returns an int 302 * consistent with MountServiceResultCode 303 */ finalizeSecureContainer(String id)304 public int finalizeSecureContainer(String id) throws RemoteException { 305 Parcel _data = Parcel.obtain(); 306 Parcel _reply = Parcel.obtain(); 307 int _result; 308 try { 309 _data.writeInterfaceToken(DESCRIPTOR); 310 _data.writeString(id); 311 mRemote.transact(Stub.TRANSACTION_finalizeSecureContainer, _data, _reply, 0); 312 _reply.readException(); 313 _result = _reply.readInt(); 314 } finally { 315 _reply.recycle(); 316 _data.recycle(); 317 } 318 return _result; 319 } 320 321 /* 322 * Mount a secure container with the specified key and owner UID. 323 * Returns an int consistent with MountServiceResultCode 324 */ mountSecureContainer(String id, String key, int ownerUid, boolean readOnly)325 public int mountSecureContainer(String id, String key, int ownerUid, boolean readOnly) 326 throws RemoteException { 327 Parcel _data = Parcel.obtain(); 328 Parcel _reply = Parcel.obtain(); 329 int _result; 330 try { 331 _data.writeInterfaceToken(DESCRIPTOR); 332 _data.writeString(id); 333 _data.writeString(key); 334 _data.writeInt(ownerUid); 335 _data.writeInt(readOnly ? 1 : 0); 336 mRemote.transact(Stub.TRANSACTION_mountSecureContainer, _data, _reply, 0); 337 _reply.readException(); 338 _result = _reply.readInt(); 339 } finally { 340 _reply.recycle(); 341 _data.recycle(); 342 } 343 return _result; 344 } 345 346 /* 347 * Unount a secure container. Returns an int consistent with 348 * MountServiceResultCode 349 */ unmountSecureContainer(String id, boolean force)350 public int unmountSecureContainer(String id, boolean force) throws RemoteException { 351 Parcel _data = Parcel.obtain(); 352 Parcel _reply = Parcel.obtain(); 353 int _result; 354 try { 355 _data.writeInterfaceToken(DESCRIPTOR); 356 _data.writeString(id); 357 _data.writeInt((force ? 1 : 0)); 358 mRemote.transact(Stub.TRANSACTION_unmountSecureContainer, _data, _reply, 0); 359 _reply.readException(); 360 _result = _reply.readInt(); 361 } finally { 362 _reply.recycle(); 363 _data.recycle(); 364 } 365 return _result; 366 } 367 368 /* 369 * Returns true if the specified container is mounted 370 */ isSecureContainerMounted(String id)371 public boolean isSecureContainerMounted(String id) throws RemoteException { 372 Parcel _data = Parcel.obtain(); 373 Parcel _reply = Parcel.obtain(); 374 boolean _result; 375 try { 376 _data.writeInterfaceToken(DESCRIPTOR); 377 _data.writeString(id); 378 mRemote.transact(Stub.TRANSACTION_isSecureContainerMounted, _data, _reply, 0); 379 _reply.readException(); 380 _result = 0 != _reply.readInt(); 381 } finally { 382 _reply.recycle(); 383 _data.recycle(); 384 } 385 return _result; 386 } 387 388 /* 389 * Rename an unmounted secure container. Returns an int consistent 390 * with MountServiceResultCode 391 */ renameSecureContainer(String oldId, String newId)392 public int renameSecureContainer(String oldId, String newId) throws RemoteException { 393 Parcel _data = Parcel.obtain(); 394 Parcel _reply = Parcel.obtain(); 395 int _result; 396 try { 397 _data.writeInterfaceToken(DESCRIPTOR); 398 _data.writeString(oldId); 399 _data.writeString(newId); 400 mRemote.transact(Stub.TRANSACTION_renameSecureContainer, _data, _reply, 0); 401 _reply.readException(); 402 _result = _reply.readInt(); 403 } finally { 404 _reply.recycle(); 405 _data.recycle(); 406 } 407 return _result; 408 } 409 410 /* 411 * Returns the filesystem path of a mounted secure container. 412 */ getSecureContainerPath(String id)413 public String getSecureContainerPath(String id) throws RemoteException { 414 Parcel _data = Parcel.obtain(); 415 Parcel _reply = Parcel.obtain(); 416 String _result; 417 try { 418 _data.writeInterfaceToken(DESCRIPTOR); 419 _data.writeString(id); 420 mRemote.transact(Stub.TRANSACTION_getSecureContainerPath, _data, _reply, 0); 421 _reply.readException(); 422 _result = _reply.readString(); 423 } finally { 424 _reply.recycle(); 425 _data.recycle(); 426 } 427 return _result; 428 } 429 430 /** 431 * Gets an Array of currently known secure container IDs 432 */ getSecureContainerList()433 public String[] getSecureContainerList() throws RemoteException { 434 Parcel _data = Parcel.obtain(); 435 Parcel _reply = Parcel.obtain(); 436 String[] _result; 437 try { 438 _data.writeInterfaceToken(DESCRIPTOR); 439 mRemote.transact(Stub.TRANSACTION_getSecureContainerList, _data, _reply, 0); 440 _reply.readException(); 441 _result = _reply.createStringArray(); 442 } finally { 443 _reply.recycle(); 444 _data.recycle(); 445 } 446 return _result; 447 } 448 449 /** 450 * Shuts down the MountService and gracefully unmounts all external 451 * media. Invokes call back once the shutdown is complete. 452 */ shutdown(IMountShutdownObserver observer)453 public void shutdown(IMountShutdownObserver observer) 454 throws RemoteException { 455 Parcel _data = Parcel.obtain(); 456 Parcel _reply = Parcel.obtain(); 457 try { 458 _data.writeInterfaceToken(DESCRIPTOR); 459 _data.writeStrongBinder((observer != null ? observer.asBinder() : null)); 460 mRemote.transact(Stub.TRANSACTION_shutdown, _data, _reply, 0); 461 _reply.readException(); 462 } finally { 463 _reply.recycle(); 464 _data.recycle(); 465 } 466 } 467 468 /** 469 * Call into MountService by PackageManager to notify that its done 470 * processing the media status update request. 471 */ finishMediaUpdate()472 public void finishMediaUpdate() throws RemoteException { 473 Parcel _data = Parcel.obtain(); 474 Parcel _reply = Parcel.obtain(); 475 try { 476 _data.writeInterfaceToken(DESCRIPTOR); 477 mRemote.transact(Stub.TRANSACTION_finishMediaUpdate, _data, _reply, 0); 478 _reply.readException(); 479 } finally { 480 _reply.recycle(); 481 _data.recycle(); 482 } 483 } 484 485 /** 486 * Mounts an Opaque Binary Blob (OBB) with the specified decryption 487 * key and only allows the calling process's UID access to the 488 * contents. MountService will call back to the supplied 489 * IObbActionListener to inform it of the terminal state of the 490 * call. 491 */ mountObb(String rawPath, String canonicalPath, String key, IObbActionListener token, int nonce)492 public void mountObb(String rawPath, String canonicalPath, String key, 493 IObbActionListener token, int nonce) throws RemoteException { 494 Parcel _data = Parcel.obtain(); 495 Parcel _reply = Parcel.obtain(); 496 try { 497 _data.writeInterfaceToken(DESCRIPTOR); 498 _data.writeString(rawPath); 499 _data.writeString(canonicalPath); 500 _data.writeString(key); 501 _data.writeStrongBinder((token != null ? token.asBinder() : null)); 502 _data.writeInt(nonce); 503 mRemote.transact(Stub.TRANSACTION_mountObb, _data, _reply, 0); 504 _reply.readException(); 505 } finally { 506 _reply.recycle(); 507 _data.recycle(); 508 } 509 } 510 511 /** 512 * Unmounts an Opaque Binary Blob (OBB). When the force flag is 513 * specified, any program using it will be forcibly killed to 514 * unmount the image. MountService will call back to the supplied 515 * IObbActionListener to inform it of the terminal state of the 516 * call. 517 */ unmountObb( String rawPath, boolean force, IObbActionListener token, int nonce)518 public void unmountObb( 519 String rawPath, boolean force, IObbActionListener token, int nonce) 520 throws RemoteException { 521 Parcel _data = Parcel.obtain(); 522 Parcel _reply = Parcel.obtain(); 523 try { 524 _data.writeInterfaceToken(DESCRIPTOR); 525 _data.writeString(rawPath); 526 _data.writeInt((force ? 1 : 0)); 527 _data.writeStrongBinder((token != null ? token.asBinder() : null)); 528 _data.writeInt(nonce); 529 mRemote.transact(Stub.TRANSACTION_unmountObb, _data, _reply, 0); 530 _reply.readException(); 531 } finally { 532 _reply.recycle(); 533 _data.recycle(); 534 } 535 } 536 537 /** 538 * Checks whether the specified Opaque Binary Blob (OBB) is mounted 539 * somewhere. 540 */ isObbMounted(String rawPath)541 public boolean isObbMounted(String rawPath) throws RemoteException { 542 Parcel _data = Parcel.obtain(); 543 Parcel _reply = Parcel.obtain(); 544 boolean _result; 545 try { 546 _data.writeInterfaceToken(DESCRIPTOR); 547 _data.writeString(rawPath); 548 mRemote.transact(Stub.TRANSACTION_isObbMounted, _data, _reply, 0); 549 _reply.readException(); 550 _result = 0 != _reply.readInt(); 551 } finally { 552 _reply.recycle(); 553 _data.recycle(); 554 } 555 return _result; 556 } 557 558 /** 559 * Gets the path to the mounted Opaque Binary Blob (OBB). 560 */ getMountedObbPath(String rawPath)561 public String getMountedObbPath(String rawPath) throws RemoteException { 562 Parcel _data = Parcel.obtain(); 563 Parcel _reply = Parcel.obtain(); 564 String _result; 565 try { 566 _data.writeInterfaceToken(DESCRIPTOR); 567 _data.writeString(rawPath); 568 mRemote.transact(Stub.TRANSACTION_getMountedObbPath, _data, _reply, 0); 569 _reply.readException(); 570 _result = _reply.readString(); 571 } finally { 572 _reply.recycle(); 573 _data.recycle(); 574 } 575 return _result; 576 } 577 578 /** 579 * Returns whether the external storage is emulated. 580 */ isExternalStorageEmulated()581 public boolean isExternalStorageEmulated() throws RemoteException { 582 Parcel _data = Parcel.obtain(); 583 Parcel _reply = Parcel.obtain(); 584 boolean _result; 585 try { 586 _data.writeInterfaceToken(DESCRIPTOR); 587 mRemote.transact(Stub.TRANSACTION_isExternalStorageEmulated, _data, _reply, 0); 588 _reply.readException(); 589 _result = 0 != _reply.readInt(); 590 } finally { 591 _reply.recycle(); 592 _data.recycle(); 593 } 594 return _result; 595 } 596 getEncryptionState()597 public int getEncryptionState() throws RemoteException { 598 Parcel _data = Parcel.obtain(); 599 Parcel _reply = Parcel.obtain(); 600 int _result; 601 try { 602 _data.writeInterfaceToken(DESCRIPTOR); 603 mRemote.transact(Stub.TRANSACTION_getEncryptionState, _data, _reply, 0); 604 _reply.readException(); 605 _result = _reply.readInt(); 606 } finally { 607 _reply.recycle(); 608 _data.recycle(); 609 } 610 return _result; 611 } 612 decryptStorage(String password)613 public int decryptStorage(String password) throws RemoteException { 614 Parcel _data = Parcel.obtain(); 615 Parcel _reply = Parcel.obtain(); 616 int _result; 617 try { 618 _data.writeInterfaceToken(DESCRIPTOR); 619 _data.writeString(password); 620 mRemote.transact(Stub.TRANSACTION_decryptStorage, _data, _reply, 0); 621 _reply.readException(); 622 _result = _reply.readInt(); 623 } finally { 624 _reply.recycle(); 625 _data.recycle(); 626 } 627 return _result; 628 } 629 encryptStorage(int type, String password)630 public int encryptStorage(int type, String password) throws RemoteException { 631 Parcel _data = Parcel.obtain(); 632 Parcel _reply = Parcel.obtain(); 633 int _result; 634 try { 635 _data.writeInterfaceToken(DESCRIPTOR); 636 _data.writeInt(type); 637 _data.writeString(password); 638 mRemote.transact(Stub.TRANSACTION_encryptStorage, _data, _reply, 0); 639 _reply.readException(); 640 _result = _reply.readInt(); 641 } finally { 642 _reply.recycle(); 643 _data.recycle(); 644 } 645 return _result; 646 } 647 changeEncryptionPassword(int type, String password)648 public int changeEncryptionPassword(int type, String password) throws RemoteException { 649 Parcel _data = Parcel.obtain(); 650 Parcel _reply = Parcel.obtain(); 651 int _result; 652 try { 653 _data.writeInterfaceToken(DESCRIPTOR); 654 _data.writeInt(type); 655 _data.writeString(password); 656 mRemote.transact(Stub.TRANSACTION_changeEncryptionPassword, _data, _reply, 0); 657 _reply.readException(); 658 _result = _reply.readInt(); 659 } finally { 660 _reply.recycle(); 661 _data.recycle(); 662 } 663 return _result; 664 } 665 666 @Override verifyEncryptionPassword(String password)667 public int verifyEncryptionPassword(String password) throws RemoteException { 668 Parcel _data = Parcel.obtain(); 669 Parcel _reply = Parcel.obtain(); 670 int _result; 671 try { 672 _data.writeInterfaceToken(DESCRIPTOR); 673 _data.writeString(password); 674 mRemote.transact(Stub.TRANSACTION_verifyEncryptionPassword, _data, _reply, 0); 675 _reply.readException(); 676 _result = _reply.readInt(); 677 } finally { 678 _reply.recycle(); 679 _data.recycle(); 680 } 681 return _result; 682 } 683 getPasswordType()684 public int getPasswordType() throws RemoteException { 685 Parcel _data = Parcel.obtain(); 686 Parcel _reply = Parcel.obtain(); 687 int _result; 688 try { 689 _data.writeInterfaceToken(DESCRIPTOR); 690 mRemote.transact(Stub.TRANSACTION_getPasswordType, _data, _reply, 0); 691 _reply.readException(); 692 _result = _reply.readInt(); 693 } finally { 694 _reply.recycle(); 695 _data.recycle(); 696 } 697 return _result; 698 } 699 getPassword()700 public String getPassword() throws RemoteException { 701 Parcel _data = Parcel.obtain(); 702 Parcel _reply = Parcel.obtain(); 703 String _result; 704 try { 705 _data.writeInterfaceToken(DESCRIPTOR); 706 mRemote.transact(Stub.TRANSACTION_getPassword, _data, _reply, 0); 707 _reply.readException(); 708 _result = _reply.readString(); 709 } finally { 710 _reply.recycle(); 711 _data.recycle(); 712 } 713 return _result; 714 } 715 clearPassword()716 public void clearPassword() throws RemoteException { 717 Parcel _data = Parcel.obtain(); 718 Parcel _reply = Parcel.obtain(); 719 try { 720 _data.writeInterfaceToken(DESCRIPTOR); 721 mRemote.transact(Stub.TRANSACTION_clearPassword, _data, _reply, IBinder.FLAG_ONEWAY); 722 _reply.readException(); 723 } finally { 724 _reply.recycle(); 725 _data.recycle(); 726 } 727 } 728 setField(String field, String data)729 public void setField(String field, String data) throws RemoteException { 730 Parcel _data = Parcel.obtain(); 731 Parcel _reply = Parcel.obtain(); 732 try { 733 _data.writeInterfaceToken(DESCRIPTOR); 734 _data.writeString(field); 735 _data.writeString(data); 736 mRemote.transact(Stub.TRANSACTION_setField, _data, _reply, IBinder.FLAG_ONEWAY); 737 _reply.readException(); 738 } finally { 739 _reply.recycle(); 740 _data.recycle(); 741 } 742 } 743 getField(String field)744 public String getField(String field) throws RemoteException { 745 Parcel _data = Parcel.obtain(); 746 Parcel _reply = Parcel.obtain(); 747 String _result; 748 try { 749 _data.writeInterfaceToken(DESCRIPTOR); 750 _data.writeString(field); 751 mRemote.transact(Stub.TRANSACTION_getField, _data, _reply, 0); 752 _reply.readException(); 753 _result = _reply.readString(); 754 } finally { 755 _reply.recycle(); 756 _data.recycle(); 757 } 758 return _result; 759 } 760 getVolumeList(int uid, String packageName, int flags)761 public StorageVolume[] getVolumeList(int uid, String packageName, int flags) 762 throws RemoteException { 763 Parcel _data = Parcel.obtain(); 764 Parcel _reply = Parcel.obtain(); 765 StorageVolume[] _result; 766 try { 767 _data.writeInterfaceToken(DESCRIPTOR); 768 _data.writeInt(uid); 769 _data.writeString(packageName); 770 _data.writeInt(flags); 771 mRemote.transact(Stub.TRANSACTION_getVolumeList, _data, _reply, 0); 772 _reply.readException(); 773 _result = _reply.createTypedArray(StorageVolume.CREATOR); 774 } finally { 775 _reply.recycle(); 776 _data.recycle(); 777 } 778 return _result; 779 } 780 781 /* 782 * Returns the filesystem path of a mounted secure container. 783 */ getSecureContainerFilesystemPath(String id)784 public String getSecureContainerFilesystemPath(String id) throws RemoteException { 785 Parcel _data = Parcel.obtain(); 786 Parcel _reply = Parcel.obtain(); 787 String _result; 788 try { 789 _data.writeInterfaceToken(DESCRIPTOR); 790 _data.writeString(id); 791 mRemote.transact(Stub.TRANSACTION_getSecureContainerFilesystemPath, _data, _reply, 0); 792 _reply.readException(); 793 _result = _reply.readString(); 794 } finally { 795 _reply.recycle(); 796 _data.recycle(); 797 } 798 return _result; 799 } 800 801 /** 802 * Fix permissions in a container which has just been created and 803 * populated. Returns an int consistent with MountServiceResultCode 804 */ fixPermissionsSecureContainer(String id, int gid, String filename)805 public int fixPermissionsSecureContainer(String id, int gid, String filename) 806 throws RemoteException { 807 Parcel _data = Parcel.obtain(); 808 Parcel _reply = Parcel.obtain(); 809 int _result; 810 try { 811 _data.writeInterfaceToken(DESCRIPTOR); 812 _data.writeString(id); 813 _data.writeInt(gid); 814 _data.writeString(filename); 815 mRemote.transact(Stub.TRANSACTION_fixPermissionsSecureContainer, _data, _reply, 0); 816 _reply.readException(); 817 _result = _reply.readInt(); 818 } finally { 819 _reply.recycle(); 820 _data.recycle(); 821 } 822 return _result; 823 } 824 825 @Override mkdirs(String callingPkg, String path)826 public int mkdirs(String callingPkg, String path) throws RemoteException { 827 Parcel _data = Parcel.obtain(); 828 Parcel _reply = Parcel.obtain(); 829 int _result; 830 try { 831 _data.writeInterfaceToken(DESCRIPTOR); 832 _data.writeString(callingPkg); 833 _data.writeString(path); 834 mRemote.transact(Stub.TRANSACTION_mkdirs, _data, _reply, 0); 835 _reply.readException(); 836 _result = _reply.readInt(); 837 } finally { 838 _reply.recycle(); 839 _data.recycle(); 840 } 841 return _result; 842 } 843 844 @Override resizeSecureContainer(String id, int sizeMb, String key)845 public int resizeSecureContainer(String id, int sizeMb, String key) 846 throws RemoteException { 847 Parcel _data = Parcel.obtain(); 848 Parcel _reply = Parcel.obtain(); 849 int _result; 850 try { 851 _data.writeInterfaceToken(DESCRIPTOR); 852 _data.writeString(id); 853 _data.writeInt(sizeMb); 854 _data.writeString(key); 855 mRemote.transact(Stub.TRANSACTION_resizeSecureContainer, _data, _reply, 0); 856 _reply.readException(); 857 _result = _reply.readInt(); 858 } finally { 859 _reply.recycle(); 860 _data.recycle(); 861 } 862 return _result; 863 } 864 865 @Override lastMaintenance()866 public long lastMaintenance() throws RemoteException { 867 Parcel _data = Parcel.obtain(); 868 Parcel _reply = Parcel.obtain(); 869 long _result; 870 try { 871 _data.writeInterfaceToken(DESCRIPTOR); 872 mRemote.transact(Stub.TRANSACTION_lastMaintenance, _data, _reply, 0); 873 _reply.readException(); 874 _result = _reply.readLong(); 875 } finally { 876 _reply.recycle(); 877 _data.recycle(); 878 } 879 return _result; 880 } 881 882 @Override runMaintenance()883 public void runMaintenance() throws RemoteException { 884 Parcel _data = Parcel.obtain(); 885 Parcel _reply = Parcel.obtain(); 886 try { 887 _data.writeInterfaceToken(DESCRIPTOR); 888 mRemote.transact(Stub.TRANSACTION_runMaintenance, _data, _reply, 0); 889 _reply.readException(); 890 } finally { 891 _reply.recycle(); 892 _data.recycle(); 893 } 894 return; 895 } 896 897 @Override waitForAsecScan()898 public void waitForAsecScan() throws RemoteException { 899 Parcel _data = Parcel.obtain(); 900 Parcel _reply = Parcel.obtain(); 901 try { 902 _data.writeInterfaceToken(DESCRIPTOR); 903 mRemote.transact(Stub.TRANSACTION_waitForAsecScan, _data, _reply, 0); 904 _reply.readException(); 905 } finally { 906 _reply.recycle(); 907 _data.recycle(); 908 } 909 return; 910 } 911 912 @Override getDisks()913 public DiskInfo[] getDisks() throws RemoteException { 914 Parcel _data = Parcel.obtain(); 915 Parcel _reply = Parcel.obtain(); 916 DiskInfo[] _result; 917 try { 918 _data.writeInterfaceToken(DESCRIPTOR); 919 mRemote.transact(Stub.TRANSACTION_getDisks, _data, _reply, 0); 920 _reply.readException(); 921 _result = _reply.createTypedArray(DiskInfo.CREATOR); 922 } finally { 923 _reply.recycle(); 924 _data.recycle(); 925 } 926 return _result; 927 } 928 929 @Override getVolumes(int _flags)930 public VolumeInfo[] getVolumes(int _flags) throws RemoteException { 931 Parcel _data = Parcel.obtain(); 932 Parcel _reply = Parcel.obtain(); 933 VolumeInfo[] _result; 934 try { 935 _data.writeInterfaceToken(DESCRIPTOR); 936 _data.writeInt(_flags); 937 mRemote.transact(Stub.TRANSACTION_getVolumes, _data, _reply, 0); 938 _reply.readException(); 939 _result = _reply.createTypedArray(VolumeInfo.CREATOR); 940 } finally { 941 _reply.recycle(); 942 _data.recycle(); 943 } 944 return _result; 945 } 946 947 @Override getVolumeRecords(int _flags)948 public VolumeRecord[] getVolumeRecords(int _flags) throws RemoteException { 949 Parcel _data = Parcel.obtain(); 950 Parcel _reply = Parcel.obtain(); 951 VolumeRecord[] _result; 952 try { 953 _data.writeInterfaceToken(DESCRIPTOR); 954 _data.writeInt(_flags); 955 mRemote.transact(Stub.TRANSACTION_getVolumeRecords, _data, _reply, 0); 956 _reply.readException(); 957 _result = _reply.createTypedArray(VolumeRecord.CREATOR); 958 } finally { 959 _reply.recycle(); 960 _data.recycle(); 961 } 962 return _result; 963 } 964 965 @Override mount(String volId)966 public void mount(String volId) throws RemoteException { 967 Parcel _data = Parcel.obtain(); 968 Parcel _reply = Parcel.obtain(); 969 try { 970 _data.writeInterfaceToken(DESCRIPTOR); 971 _data.writeString(volId); 972 mRemote.transact(Stub.TRANSACTION_mount, _data, _reply, 0); 973 _reply.readException(); 974 } finally { 975 _reply.recycle(); 976 _data.recycle(); 977 } 978 } 979 980 @Override unmount(String volId)981 public void unmount(String volId) throws RemoteException { 982 Parcel _data = Parcel.obtain(); 983 Parcel _reply = Parcel.obtain(); 984 try { 985 _data.writeInterfaceToken(DESCRIPTOR); 986 _data.writeString(volId); 987 mRemote.transact(Stub.TRANSACTION_unmount, _data, _reply, 0); 988 _reply.readException(); 989 } finally { 990 _reply.recycle(); 991 _data.recycle(); 992 } 993 } 994 995 @Override format(String volId)996 public void format(String volId) throws RemoteException { 997 Parcel _data = Parcel.obtain(); 998 Parcel _reply = Parcel.obtain(); 999 try { 1000 _data.writeInterfaceToken(DESCRIPTOR); 1001 _data.writeString(volId); 1002 mRemote.transact(Stub.TRANSACTION_format, _data, _reply, 0); 1003 _reply.readException(); 1004 } finally { 1005 _reply.recycle(); 1006 _data.recycle(); 1007 } 1008 } 1009 1010 @Override benchmark(String volId)1011 public long benchmark(String volId) throws RemoteException { 1012 Parcel _data = Parcel.obtain(); 1013 Parcel _reply = Parcel.obtain(); 1014 try { 1015 _data.writeInterfaceToken(DESCRIPTOR); 1016 _data.writeString(volId); 1017 mRemote.transact(Stub.TRANSACTION_benchmark, _data, _reply, 0); 1018 _reply.readException(); 1019 return _reply.readLong(); 1020 } finally { 1021 _reply.recycle(); 1022 _data.recycle(); 1023 } 1024 } 1025 1026 @Override partitionPublic(String diskId)1027 public void partitionPublic(String diskId) throws RemoteException { 1028 Parcel _data = Parcel.obtain(); 1029 Parcel _reply = Parcel.obtain(); 1030 try { 1031 _data.writeInterfaceToken(DESCRIPTOR); 1032 _data.writeString(diskId); 1033 mRemote.transact(Stub.TRANSACTION_partitionPublic, _data, _reply, 0); 1034 _reply.readException(); 1035 } finally { 1036 _reply.recycle(); 1037 _data.recycle(); 1038 } 1039 } 1040 1041 @Override partitionPrivate(String diskId)1042 public void partitionPrivate(String diskId) throws RemoteException { 1043 Parcel _data = Parcel.obtain(); 1044 Parcel _reply = Parcel.obtain(); 1045 try { 1046 _data.writeInterfaceToken(DESCRIPTOR); 1047 _data.writeString(diskId); 1048 mRemote.transact(Stub.TRANSACTION_partitionPrivate, _data, _reply, 0); 1049 _reply.readException(); 1050 } finally { 1051 _reply.recycle(); 1052 _data.recycle(); 1053 } 1054 } 1055 1056 @Override partitionMixed(String diskId, int ratio)1057 public void partitionMixed(String diskId, int ratio) throws RemoteException { 1058 Parcel _data = Parcel.obtain(); 1059 Parcel _reply = Parcel.obtain(); 1060 try { 1061 _data.writeInterfaceToken(DESCRIPTOR); 1062 _data.writeString(diskId); 1063 _data.writeInt(ratio); 1064 mRemote.transact(Stub.TRANSACTION_partitionMixed, _data, _reply, 0); 1065 _reply.readException(); 1066 } finally { 1067 _reply.recycle(); 1068 _data.recycle(); 1069 } 1070 } 1071 1072 @Override setVolumeNickname(String fsUuid, String nickname)1073 public void setVolumeNickname(String fsUuid, String nickname) throws RemoteException { 1074 Parcel _data = Parcel.obtain(); 1075 Parcel _reply = Parcel.obtain(); 1076 try { 1077 _data.writeInterfaceToken(DESCRIPTOR); 1078 _data.writeString(fsUuid); 1079 _data.writeString(nickname); 1080 mRemote.transact(Stub.TRANSACTION_setVolumeNickname, _data, _reply, 0); 1081 _reply.readException(); 1082 } finally { 1083 _reply.recycle(); 1084 _data.recycle(); 1085 } 1086 } 1087 1088 @Override setVolumeUserFlags(String fsUuid, int flags, int mask)1089 public void setVolumeUserFlags(String fsUuid, int flags, int mask) throws RemoteException { 1090 Parcel _data = Parcel.obtain(); 1091 Parcel _reply = Parcel.obtain(); 1092 try { 1093 _data.writeInterfaceToken(DESCRIPTOR); 1094 _data.writeString(fsUuid); 1095 _data.writeInt(flags); 1096 _data.writeInt(mask); 1097 mRemote.transact(Stub.TRANSACTION_setVolumeUserFlags, _data, _reply, 0); 1098 _reply.readException(); 1099 } finally { 1100 _reply.recycle(); 1101 _data.recycle(); 1102 } 1103 } 1104 1105 @Override forgetVolume(String fsUuid)1106 public void forgetVolume(String fsUuid) throws RemoteException { 1107 Parcel _data = Parcel.obtain(); 1108 Parcel _reply = Parcel.obtain(); 1109 try { 1110 _data.writeInterfaceToken(DESCRIPTOR); 1111 _data.writeString(fsUuid); 1112 mRemote.transact(Stub.TRANSACTION_forgetVolume, _data, _reply, 0); 1113 _reply.readException(); 1114 } finally { 1115 _reply.recycle(); 1116 _data.recycle(); 1117 } 1118 } 1119 1120 @Override forgetAllVolumes()1121 public void forgetAllVolumes() throws RemoteException { 1122 Parcel _data = Parcel.obtain(); 1123 Parcel _reply = Parcel.obtain(); 1124 try { 1125 _data.writeInterfaceToken(DESCRIPTOR); 1126 mRemote.transact(Stub.TRANSACTION_forgetAllVolumes, _data, _reply, 0); 1127 _reply.readException(); 1128 } finally { 1129 _reply.recycle(); 1130 _data.recycle(); 1131 } 1132 } 1133 1134 @Override setDebugFlags(int _flags, int _mask)1135 public void setDebugFlags(int _flags, int _mask) throws RemoteException { 1136 Parcel _data = Parcel.obtain(); 1137 Parcel _reply = Parcel.obtain(); 1138 try { 1139 _data.writeInterfaceToken(DESCRIPTOR); 1140 _data.writeInt(_flags); 1141 _data.writeInt(_mask); 1142 mRemote.transact(Stub.TRANSACTION_setDebugFlags, _data, _reply, 0); 1143 _reply.readException(); 1144 } finally { 1145 _reply.recycle(); 1146 _data.recycle(); 1147 } 1148 } 1149 1150 @Override getPrimaryStorageUuid()1151 public String getPrimaryStorageUuid() throws RemoteException { 1152 Parcel _data = Parcel.obtain(); 1153 Parcel _reply = Parcel.obtain(); 1154 String _result; 1155 try { 1156 _data.writeInterfaceToken(DESCRIPTOR); 1157 mRemote.transact(Stub.TRANSACTION_getPrimaryStorageUuid, _data, _reply, 0); 1158 _reply.readException(); 1159 _result = _reply.readString(); 1160 } finally { 1161 _reply.recycle(); 1162 _data.recycle(); 1163 } 1164 return _result; 1165 } 1166 1167 @Override setPrimaryStorageUuid(String volumeUuid, IPackageMoveObserver callback)1168 public void setPrimaryStorageUuid(String volumeUuid, IPackageMoveObserver callback) 1169 throws RemoteException { 1170 Parcel _data = Parcel.obtain(); 1171 Parcel _reply = Parcel.obtain(); 1172 try { 1173 _data.writeInterfaceToken(DESCRIPTOR); 1174 _data.writeString(volumeUuid); 1175 _data.writeStrongBinder((callback != null ? callback.asBinder() : null)); 1176 mRemote.transact(Stub.TRANSACTION_setPrimaryStorageUuid, _data, _reply, 0); 1177 _reply.readException(); 1178 } finally { 1179 _reply.recycle(); 1180 _data.recycle(); 1181 } 1182 } 1183 } 1184 1185 private static final String DESCRIPTOR = "IMountService"; 1186 1187 static final int TRANSACTION_registerListener = IBinder.FIRST_CALL_TRANSACTION + 0; 1188 1189 static final int TRANSACTION_unregisterListener = IBinder.FIRST_CALL_TRANSACTION + 1; 1190 1191 static final int TRANSACTION_isUsbMassStorageConnected = IBinder.FIRST_CALL_TRANSACTION + 2; 1192 1193 static final int TRANSACTION_setUsbMassStorageEnabled = IBinder.FIRST_CALL_TRANSACTION + 3; 1194 1195 static final int TRANSACTION_isUsbMassStorageEnabled = IBinder.FIRST_CALL_TRANSACTION + 4; 1196 1197 static final int TRANSACTION_mountVolume = IBinder.FIRST_CALL_TRANSACTION + 5; 1198 1199 static final int TRANSACTION_unmountVolume = IBinder.FIRST_CALL_TRANSACTION + 6; 1200 1201 static final int TRANSACTION_formatVolume = IBinder.FIRST_CALL_TRANSACTION + 7; 1202 1203 static final int TRANSACTION_getStorageUsers = IBinder.FIRST_CALL_TRANSACTION + 8; 1204 1205 static final int TRANSACTION_getVolumeState = IBinder.FIRST_CALL_TRANSACTION + 9; 1206 1207 static final int TRANSACTION_createSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 10; 1208 1209 static final int TRANSACTION_finalizeSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 11; 1210 1211 static final int TRANSACTION_destroySecureContainer = IBinder.FIRST_CALL_TRANSACTION + 12; 1212 1213 static final int TRANSACTION_mountSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 13; 1214 1215 static final int TRANSACTION_unmountSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 14; 1216 1217 static final int TRANSACTION_isSecureContainerMounted = IBinder.FIRST_CALL_TRANSACTION + 15; 1218 1219 static final int TRANSACTION_renameSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 16; 1220 1221 static final int TRANSACTION_getSecureContainerPath = IBinder.FIRST_CALL_TRANSACTION + 17; 1222 1223 static final int TRANSACTION_getSecureContainerList = IBinder.FIRST_CALL_TRANSACTION + 18; 1224 1225 static final int TRANSACTION_shutdown = IBinder.FIRST_CALL_TRANSACTION + 19; 1226 1227 static final int TRANSACTION_finishMediaUpdate = IBinder.FIRST_CALL_TRANSACTION + 20; 1228 1229 static final int TRANSACTION_mountObb = IBinder.FIRST_CALL_TRANSACTION + 21; 1230 1231 static final int TRANSACTION_unmountObb = IBinder.FIRST_CALL_TRANSACTION + 22; 1232 1233 static final int TRANSACTION_isObbMounted = IBinder.FIRST_CALL_TRANSACTION + 23; 1234 1235 static final int TRANSACTION_getMountedObbPath = IBinder.FIRST_CALL_TRANSACTION + 24; 1236 1237 static final int TRANSACTION_isExternalStorageEmulated = IBinder.FIRST_CALL_TRANSACTION + 25; 1238 1239 static final int TRANSACTION_decryptStorage = IBinder.FIRST_CALL_TRANSACTION + 26; 1240 1241 static final int TRANSACTION_encryptStorage = IBinder.FIRST_CALL_TRANSACTION + 27; 1242 1243 static final int TRANSACTION_changeEncryptionPassword = IBinder.FIRST_CALL_TRANSACTION + 28; 1244 1245 static final int TRANSACTION_getVolumeList = IBinder.FIRST_CALL_TRANSACTION + 29; 1246 1247 static final int TRANSACTION_getSecureContainerFilesystemPath = IBinder.FIRST_CALL_TRANSACTION + 30; 1248 1249 static final int TRANSACTION_getEncryptionState = IBinder.FIRST_CALL_TRANSACTION + 31; 1250 1251 static final int TRANSACTION_verifyEncryptionPassword = IBinder.FIRST_CALL_TRANSACTION + 32; 1252 1253 static final int TRANSACTION_fixPermissionsSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 33; 1254 1255 static final int TRANSACTION_mkdirs = IBinder.FIRST_CALL_TRANSACTION + 34; 1256 1257 static final int TRANSACTION_getPasswordType = IBinder.FIRST_CALL_TRANSACTION + 35; 1258 1259 static final int TRANSACTION_getPassword = IBinder.FIRST_CALL_TRANSACTION + 36; 1260 1261 static final int TRANSACTION_clearPassword = IBinder.FIRST_CALL_TRANSACTION + 37; 1262 1263 static final int TRANSACTION_setField = IBinder.FIRST_CALL_TRANSACTION + 38; 1264 1265 static final int TRANSACTION_getField = IBinder.FIRST_CALL_TRANSACTION + 39; 1266 1267 static final int TRANSACTION_resizeSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 40; 1268 1269 static final int TRANSACTION_lastMaintenance = IBinder.FIRST_CALL_TRANSACTION + 41; 1270 1271 static final int TRANSACTION_runMaintenance = IBinder.FIRST_CALL_TRANSACTION + 42; 1272 1273 static final int TRANSACTION_waitForAsecScan = IBinder.FIRST_CALL_TRANSACTION + 43; 1274 1275 static final int TRANSACTION_getDisks = IBinder.FIRST_CALL_TRANSACTION + 44; 1276 static final int TRANSACTION_getVolumes = IBinder.FIRST_CALL_TRANSACTION + 45; 1277 static final int TRANSACTION_getVolumeRecords = IBinder.FIRST_CALL_TRANSACTION + 46; 1278 1279 static final int TRANSACTION_mount = IBinder.FIRST_CALL_TRANSACTION + 47; 1280 static final int TRANSACTION_unmount = IBinder.FIRST_CALL_TRANSACTION + 48; 1281 static final int TRANSACTION_format = IBinder.FIRST_CALL_TRANSACTION + 49; 1282 1283 static final int TRANSACTION_partitionPublic = IBinder.FIRST_CALL_TRANSACTION + 50; 1284 static final int TRANSACTION_partitionPrivate = IBinder.FIRST_CALL_TRANSACTION + 51; 1285 static final int TRANSACTION_partitionMixed = IBinder.FIRST_CALL_TRANSACTION + 52; 1286 1287 static final int TRANSACTION_setVolumeNickname = IBinder.FIRST_CALL_TRANSACTION + 53; 1288 static final int TRANSACTION_setVolumeUserFlags = IBinder.FIRST_CALL_TRANSACTION + 54; 1289 static final int TRANSACTION_forgetVolume = IBinder.FIRST_CALL_TRANSACTION + 55; 1290 static final int TRANSACTION_forgetAllVolumes = IBinder.FIRST_CALL_TRANSACTION + 56; 1291 1292 static final int TRANSACTION_getPrimaryStorageUuid = IBinder.FIRST_CALL_TRANSACTION + 57; 1293 static final int TRANSACTION_setPrimaryStorageUuid = IBinder.FIRST_CALL_TRANSACTION + 58; 1294 1295 static final int TRANSACTION_benchmark = IBinder.FIRST_CALL_TRANSACTION + 59; 1296 static final int TRANSACTION_setDebugFlags = IBinder.FIRST_CALL_TRANSACTION + 60; 1297 1298 /** 1299 * Cast an IBinder object into an IMountService interface, generating a 1300 * proxy if needed. 1301 */ asInterface(IBinder obj)1302 public static IMountService asInterface(IBinder obj) { 1303 if (obj == null) { 1304 return null; 1305 } 1306 IInterface iin = obj.queryLocalInterface(DESCRIPTOR); 1307 if (iin != null && iin instanceof IMountService) { 1308 return (IMountService) iin; 1309 } 1310 return new IMountService.Stub.Proxy(obj); 1311 } 1312 1313 /** Construct the stub at attach it to the interface. */ Stub()1314 public Stub() { 1315 attachInterface(this, DESCRIPTOR); 1316 } 1317 asBinder()1318 public IBinder asBinder() { 1319 return this; 1320 } 1321 1322 @Override onTransact(int code, Parcel data, Parcel reply, int flags)1323 public boolean onTransact(int code, Parcel data, Parcel reply, 1324 int flags) throws RemoteException { 1325 switch (code) { 1326 case INTERFACE_TRANSACTION: { 1327 reply.writeString(DESCRIPTOR); 1328 return true; 1329 } 1330 case TRANSACTION_registerListener: { 1331 data.enforceInterface(DESCRIPTOR); 1332 IMountServiceListener listener; 1333 listener = IMountServiceListener.Stub.asInterface(data.readStrongBinder()); 1334 registerListener(listener); 1335 reply.writeNoException(); 1336 return true; 1337 } 1338 case TRANSACTION_unregisterListener: { 1339 data.enforceInterface(DESCRIPTOR); 1340 IMountServiceListener listener; 1341 listener = IMountServiceListener.Stub.asInterface(data.readStrongBinder()); 1342 unregisterListener(listener); 1343 reply.writeNoException(); 1344 return true; 1345 } 1346 case TRANSACTION_isUsbMassStorageConnected: { 1347 data.enforceInterface(DESCRIPTOR); 1348 boolean result = isUsbMassStorageConnected(); 1349 reply.writeNoException(); 1350 reply.writeInt((result ? 1 : 0)); 1351 return true; 1352 } 1353 case TRANSACTION_setUsbMassStorageEnabled: { 1354 data.enforceInterface(DESCRIPTOR); 1355 boolean enable; 1356 enable = 0 != data.readInt(); 1357 setUsbMassStorageEnabled(enable); 1358 reply.writeNoException(); 1359 return true; 1360 } 1361 case TRANSACTION_isUsbMassStorageEnabled: { 1362 data.enforceInterface(DESCRIPTOR); 1363 boolean result = isUsbMassStorageEnabled(); 1364 reply.writeNoException(); 1365 reply.writeInt((result ? 1 : 0)); 1366 return true; 1367 } 1368 case TRANSACTION_mountVolume: { 1369 data.enforceInterface(DESCRIPTOR); 1370 String mountPoint; 1371 mountPoint = data.readString(); 1372 int resultCode = mountVolume(mountPoint); 1373 reply.writeNoException(); 1374 reply.writeInt(resultCode); 1375 return true; 1376 } 1377 case TRANSACTION_unmountVolume: { 1378 data.enforceInterface(DESCRIPTOR); 1379 String mountPoint; 1380 mountPoint = data.readString(); 1381 boolean force = 0 != data.readInt(); 1382 boolean removeEncrypt = 0 != data.readInt(); 1383 unmountVolume(mountPoint, force, removeEncrypt); 1384 reply.writeNoException(); 1385 return true; 1386 } 1387 case TRANSACTION_formatVolume: { 1388 data.enforceInterface(DESCRIPTOR); 1389 String mountPoint; 1390 mountPoint = data.readString(); 1391 int result = formatVolume(mountPoint); 1392 reply.writeNoException(); 1393 reply.writeInt(result); 1394 return true; 1395 } 1396 case TRANSACTION_getStorageUsers: { 1397 data.enforceInterface(DESCRIPTOR); 1398 String path; 1399 path = data.readString(); 1400 int[] pids = getStorageUsers(path); 1401 reply.writeNoException(); 1402 reply.writeIntArray(pids); 1403 return true; 1404 } 1405 case TRANSACTION_getVolumeState: { 1406 data.enforceInterface(DESCRIPTOR); 1407 String mountPoint; 1408 mountPoint = data.readString(); 1409 String state = getVolumeState(mountPoint); 1410 reply.writeNoException(); 1411 reply.writeString(state); 1412 return true; 1413 } 1414 case TRANSACTION_createSecureContainer: { 1415 data.enforceInterface(DESCRIPTOR); 1416 String id; 1417 id = data.readString(); 1418 int sizeMb; 1419 sizeMb = data.readInt(); 1420 String fstype; 1421 fstype = data.readString(); 1422 String key; 1423 key = data.readString(); 1424 int ownerUid; 1425 ownerUid = data.readInt(); 1426 boolean external; 1427 external = 0 != data.readInt(); 1428 int resultCode = createSecureContainer(id, sizeMb, fstype, key, ownerUid, 1429 external); 1430 reply.writeNoException(); 1431 reply.writeInt(resultCode); 1432 return true; 1433 } 1434 case TRANSACTION_finalizeSecureContainer: { 1435 data.enforceInterface(DESCRIPTOR); 1436 String id; 1437 id = data.readString(); 1438 int resultCode = finalizeSecureContainer(id); 1439 reply.writeNoException(); 1440 reply.writeInt(resultCode); 1441 return true; 1442 } 1443 case TRANSACTION_destroySecureContainer: { 1444 data.enforceInterface(DESCRIPTOR); 1445 String id; 1446 id = data.readString(); 1447 boolean force; 1448 force = 0 != data.readInt(); 1449 int resultCode = destroySecureContainer(id, force); 1450 reply.writeNoException(); 1451 reply.writeInt(resultCode); 1452 return true; 1453 } 1454 case TRANSACTION_mountSecureContainer: { 1455 data.enforceInterface(DESCRIPTOR); 1456 String id; 1457 id = data.readString(); 1458 String key; 1459 key = data.readString(); 1460 int ownerUid; 1461 ownerUid = data.readInt(); 1462 boolean readOnly; 1463 readOnly = data.readInt() != 0; 1464 int resultCode = mountSecureContainer(id, key, ownerUid, readOnly); 1465 reply.writeNoException(); 1466 reply.writeInt(resultCode); 1467 return true; 1468 } 1469 case TRANSACTION_unmountSecureContainer: { 1470 data.enforceInterface(DESCRIPTOR); 1471 String id; 1472 id = data.readString(); 1473 boolean force; 1474 force = 0 != data.readInt(); 1475 int resultCode = unmountSecureContainer(id, force); 1476 reply.writeNoException(); 1477 reply.writeInt(resultCode); 1478 return true; 1479 } 1480 case TRANSACTION_isSecureContainerMounted: { 1481 data.enforceInterface(DESCRIPTOR); 1482 String id; 1483 id = data.readString(); 1484 boolean status = isSecureContainerMounted(id); 1485 reply.writeNoException(); 1486 reply.writeInt((status ? 1 : 0)); 1487 return true; 1488 } 1489 case TRANSACTION_renameSecureContainer: { 1490 data.enforceInterface(DESCRIPTOR); 1491 String oldId; 1492 oldId = data.readString(); 1493 String newId; 1494 newId = data.readString(); 1495 int resultCode = renameSecureContainer(oldId, newId); 1496 reply.writeNoException(); 1497 reply.writeInt(resultCode); 1498 return true; 1499 } 1500 case TRANSACTION_getSecureContainerPath: { 1501 data.enforceInterface(DESCRIPTOR); 1502 String id; 1503 id = data.readString(); 1504 String path = getSecureContainerPath(id); 1505 reply.writeNoException(); 1506 reply.writeString(path); 1507 return true; 1508 } 1509 case TRANSACTION_getSecureContainerList: { 1510 data.enforceInterface(DESCRIPTOR); 1511 String[] ids = getSecureContainerList(); 1512 reply.writeNoException(); 1513 reply.writeStringArray(ids); 1514 return true; 1515 } 1516 case TRANSACTION_shutdown: { 1517 data.enforceInterface(DESCRIPTOR); 1518 IMountShutdownObserver observer; 1519 observer = IMountShutdownObserver.Stub.asInterface(data 1520 .readStrongBinder()); 1521 shutdown(observer); 1522 reply.writeNoException(); 1523 return true; 1524 } 1525 case TRANSACTION_finishMediaUpdate: { 1526 data.enforceInterface(DESCRIPTOR); 1527 finishMediaUpdate(); 1528 reply.writeNoException(); 1529 return true; 1530 } 1531 case TRANSACTION_mountObb: { 1532 data.enforceInterface(DESCRIPTOR); 1533 final String rawPath = data.readString(); 1534 final String canonicalPath = data.readString(); 1535 final String key = data.readString(); 1536 IObbActionListener observer; 1537 observer = IObbActionListener.Stub.asInterface(data.readStrongBinder()); 1538 int nonce; 1539 nonce = data.readInt(); 1540 mountObb(rawPath, canonicalPath, key, observer, nonce); 1541 reply.writeNoException(); 1542 return true; 1543 } 1544 case TRANSACTION_unmountObb: { 1545 data.enforceInterface(DESCRIPTOR); 1546 String filename; 1547 filename = data.readString(); 1548 boolean force; 1549 force = 0 != data.readInt(); 1550 IObbActionListener observer; 1551 observer = IObbActionListener.Stub.asInterface(data.readStrongBinder()); 1552 int nonce; 1553 nonce = data.readInt(); 1554 unmountObb(filename, force, observer, nonce); 1555 reply.writeNoException(); 1556 return true; 1557 } 1558 case TRANSACTION_isObbMounted: { 1559 data.enforceInterface(DESCRIPTOR); 1560 String filename; 1561 filename = data.readString(); 1562 boolean status = isObbMounted(filename); 1563 reply.writeNoException(); 1564 reply.writeInt((status ? 1 : 0)); 1565 return true; 1566 } 1567 case TRANSACTION_getMountedObbPath: { 1568 data.enforceInterface(DESCRIPTOR); 1569 String filename; 1570 filename = data.readString(); 1571 String mountedPath = getMountedObbPath(filename); 1572 reply.writeNoException(); 1573 reply.writeString(mountedPath); 1574 return true; 1575 } 1576 case TRANSACTION_isExternalStorageEmulated: { 1577 data.enforceInterface(DESCRIPTOR); 1578 boolean emulated = isExternalStorageEmulated(); 1579 reply.writeNoException(); 1580 reply.writeInt(emulated ? 1 : 0); 1581 return true; 1582 } 1583 case TRANSACTION_decryptStorage: { 1584 data.enforceInterface(DESCRIPTOR); 1585 String password = data.readString(); 1586 int result = decryptStorage(password); 1587 reply.writeNoException(); 1588 reply.writeInt(result); 1589 return true; 1590 } 1591 case TRANSACTION_encryptStorage: { 1592 data.enforceInterface(DESCRIPTOR); 1593 int type = data.readInt(); 1594 String password = data.readString(); 1595 int result = encryptStorage(type, password); 1596 reply.writeNoException(); 1597 reply.writeInt(result); 1598 return true; 1599 } 1600 case TRANSACTION_changeEncryptionPassword: { 1601 data.enforceInterface(DESCRIPTOR); 1602 int type = data.readInt(); 1603 String password = data.readString(); 1604 int result = changeEncryptionPassword(type, password); 1605 reply.writeNoException(); 1606 reply.writeInt(result); 1607 return true; 1608 } 1609 case TRANSACTION_getVolumeList: { 1610 data.enforceInterface(DESCRIPTOR); 1611 int uid = data.readInt(); 1612 String packageName = data.readString(); 1613 int _flags = data.readInt(); 1614 StorageVolume[] result = getVolumeList(uid, packageName, _flags); 1615 reply.writeNoException(); 1616 reply.writeTypedArray(result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 1617 return true; 1618 } 1619 case TRANSACTION_getSecureContainerFilesystemPath: { 1620 data.enforceInterface(DESCRIPTOR); 1621 String id; 1622 id = data.readString(); 1623 String path = getSecureContainerFilesystemPath(id); 1624 reply.writeNoException(); 1625 reply.writeString(path); 1626 return true; 1627 } 1628 case TRANSACTION_getEncryptionState: { 1629 data.enforceInterface(DESCRIPTOR); 1630 int result = getEncryptionState(); 1631 reply.writeNoException(); 1632 reply.writeInt(result); 1633 return true; 1634 } 1635 case TRANSACTION_fixPermissionsSecureContainer: { 1636 data.enforceInterface(DESCRIPTOR); 1637 String id; 1638 id = data.readString(); 1639 int gid; 1640 gid = data.readInt(); 1641 String filename; 1642 filename = data.readString(); 1643 int resultCode = fixPermissionsSecureContainer(id, gid, filename); 1644 reply.writeNoException(); 1645 reply.writeInt(resultCode); 1646 return true; 1647 } 1648 case TRANSACTION_mkdirs: { 1649 data.enforceInterface(DESCRIPTOR); 1650 String callingPkg = data.readString(); 1651 String path = data.readString(); 1652 int result = mkdirs(callingPkg, path); 1653 reply.writeNoException(); 1654 reply.writeInt(result); 1655 return true; 1656 } 1657 case TRANSACTION_getPasswordType: { 1658 data.enforceInterface(DESCRIPTOR); 1659 int result = getPasswordType(); 1660 reply.writeNoException(); 1661 reply.writeInt(result); 1662 return true; 1663 } 1664 case TRANSACTION_getPassword: { 1665 data.enforceInterface(DESCRIPTOR); 1666 String result = getPassword(); 1667 reply.writeNoException(); 1668 reply.writeString(result); 1669 return true; 1670 } 1671 case TRANSACTION_clearPassword: { 1672 data.enforceInterface(DESCRIPTOR); 1673 clearPassword(); 1674 reply.writeNoException(); 1675 return true; 1676 } 1677 case TRANSACTION_setField: { 1678 data.enforceInterface(DESCRIPTOR); 1679 String field = data.readString(); 1680 String contents = data.readString(); 1681 setField(field, contents); 1682 reply.writeNoException(); 1683 return true; 1684 } 1685 case TRANSACTION_getField: { 1686 data.enforceInterface(DESCRIPTOR); 1687 String field = data.readString(); 1688 String contents = getField(field); 1689 reply.writeNoException(); 1690 reply.writeString(contents); 1691 return true; 1692 } 1693 case TRANSACTION_resizeSecureContainer: { 1694 data.enforceInterface(DESCRIPTOR); 1695 String id; 1696 id = data.readString(); 1697 int sizeMb; 1698 sizeMb = data.readInt(); 1699 String key; 1700 key = data.readString(); 1701 int resultCode = resizeSecureContainer(id, sizeMb, key); 1702 reply.writeNoException(); 1703 reply.writeInt(resultCode); 1704 return true; 1705 } 1706 case TRANSACTION_lastMaintenance: { 1707 data.enforceInterface(DESCRIPTOR); 1708 long lastMaintenance = lastMaintenance(); 1709 reply.writeNoException(); 1710 reply.writeLong(lastMaintenance); 1711 return true; 1712 } 1713 case TRANSACTION_runMaintenance: { 1714 data.enforceInterface(DESCRIPTOR); 1715 runMaintenance(); 1716 reply.writeNoException(); 1717 return true; 1718 } 1719 case TRANSACTION_waitForAsecScan: { 1720 data.enforceInterface(DESCRIPTOR); 1721 waitForAsecScan(); 1722 reply.writeNoException(); 1723 return true; 1724 } 1725 case TRANSACTION_getDisks: { 1726 data.enforceInterface(DESCRIPTOR); 1727 DiskInfo[] disks = getDisks(); 1728 reply.writeNoException(); 1729 reply.writeTypedArray(disks, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 1730 return true; 1731 } 1732 case TRANSACTION_getVolumes: { 1733 data.enforceInterface(DESCRIPTOR); 1734 int _flags = data.readInt(); 1735 VolumeInfo[] volumes = getVolumes(_flags); 1736 reply.writeNoException(); 1737 reply.writeTypedArray(volumes, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 1738 return true; 1739 } 1740 case TRANSACTION_getVolumeRecords: { 1741 data.enforceInterface(DESCRIPTOR); 1742 int _flags = data.readInt(); 1743 VolumeRecord[] volumes = getVolumeRecords(_flags); 1744 reply.writeNoException(); 1745 reply.writeTypedArray(volumes, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 1746 return true; 1747 } 1748 case TRANSACTION_mount: { 1749 data.enforceInterface(DESCRIPTOR); 1750 String volId = data.readString(); 1751 mount(volId); 1752 reply.writeNoException(); 1753 return true; 1754 } 1755 case TRANSACTION_unmount: { 1756 data.enforceInterface(DESCRIPTOR); 1757 String volId = data.readString(); 1758 unmount(volId); 1759 reply.writeNoException(); 1760 return true; 1761 } 1762 case TRANSACTION_format: { 1763 data.enforceInterface(DESCRIPTOR); 1764 String volId = data.readString(); 1765 format(volId); 1766 reply.writeNoException(); 1767 return true; 1768 } 1769 case TRANSACTION_benchmark: { 1770 data.enforceInterface(DESCRIPTOR); 1771 String volId = data.readString(); 1772 long res = benchmark(volId); 1773 reply.writeNoException(); 1774 reply.writeLong(res); 1775 return true; 1776 } 1777 case TRANSACTION_partitionPublic: { 1778 data.enforceInterface(DESCRIPTOR); 1779 String diskId = data.readString(); 1780 partitionPublic(diskId); 1781 reply.writeNoException(); 1782 return true; 1783 } 1784 case TRANSACTION_partitionPrivate: { 1785 data.enforceInterface(DESCRIPTOR); 1786 String diskId = data.readString(); 1787 partitionPrivate(diskId); 1788 reply.writeNoException(); 1789 return true; 1790 } 1791 case TRANSACTION_partitionMixed: { 1792 data.enforceInterface(DESCRIPTOR); 1793 String diskId = data.readString(); 1794 int ratio = data.readInt(); 1795 partitionMixed(diskId, ratio); 1796 reply.writeNoException(); 1797 return true; 1798 } 1799 case TRANSACTION_setVolumeNickname: { 1800 data.enforceInterface(DESCRIPTOR); 1801 String volId = data.readString(); 1802 String nickname = data.readString(); 1803 setVolumeNickname(volId, nickname); 1804 reply.writeNoException(); 1805 return true; 1806 } 1807 case TRANSACTION_setVolumeUserFlags: { 1808 data.enforceInterface(DESCRIPTOR); 1809 String volId = data.readString(); 1810 int _flags = data.readInt(); 1811 int _mask = data.readInt(); 1812 setVolumeUserFlags(volId, _flags, _mask); 1813 reply.writeNoException(); 1814 return true; 1815 } 1816 case TRANSACTION_forgetVolume: { 1817 data.enforceInterface(DESCRIPTOR); 1818 String fsUuid = data.readString(); 1819 forgetVolume(fsUuid); 1820 reply.writeNoException(); 1821 return true; 1822 } 1823 case TRANSACTION_forgetAllVolumes: { 1824 data.enforceInterface(DESCRIPTOR); 1825 forgetAllVolumes(); 1826 reply.writeNoException(); 1827 return true; 1828 } 1829 case TRANSACTION_setDebugFlags: { 1830 data.enforceInterface(DESCRIPTOR); 1831 int _flags = data.readInt(); 1832 int _mask = data.readInt(); 1833 setDebugFlags(_flags, _mask); 1834 reply.writeNoException(); 1835 return true; 1836 } 1837 case TRANSACTION_getPrimaryStorageUuid: { 1838 data.enforceInterface(DESCRIPTOR); 1839 String volumeUuid = getPrimaryStorageUuid(); 1840 reply.writeNoException(); 1841 reply.writeString(volumeUuid); 1842 return true; 1843 } 1844 case TRANSACTION_setPrimaryStorageUuid: { 1845 data.enforceInterface(DESCRIPTOR); 1846 String volumeUuid = data.readString(); 1847 IPackageMoveObserver listener = IPackageMoveObserver.Stub.asInterface( 1848 data.readStrongBinder()); 1849 setPrimaryStorageUuid(volumeUuid, listener); 1850 reply.writeNoException(); 1851 return true; 1852 } 1853 } 1854 return super.onTransact(code, data, reply, flags); 1855 } 1856 } 1857 1858 /* 1859 * Creates a secure container with the specified parameters. Returns an int 1860 * consistent with MountServiceResultCode 1861 */ createSecureContainer(String id, int sizeMb, String fstype, String key, int ownerUid, boolean external)1862 public int createSecureContainer(String id, int sizeMb, String fstype, String key, 1863 int ownerUid, boolean external) throws RemoteException; 1864 1865 /* 1866 * Destroy a secure container, and free up all resources associated with it. 1867 * NOTE: Ensure all references are released prior to deleting. Returns an 1868 * int consistent with MountServiceResultCode 1869 */ destroySecureContainer(String id, boolean force)1870 public int destroySecureContainer(String id, boolean force) throws RemoteException; 1871 1872 /* 1873 * Finalize a container which has just been created and populated. After 1874 * finalization, the container is immutable. Returns an int consistent with 1875 * MountServiceResultCode 1876 */ finalizeSecureContainer(String id)1877 public int finalizeSecureContainer(String id) throws RemoteException; 1878 1879 /** 1880 * Call into MountService by PackageManager to notify that its done 1881 * processing the media status update request. 1882 */ finishMediaUpdate()1883 public void finishMediaUpdate() throws RemoteException; 1884 1885 /** 1886 * Format external storage given a mount point. Returns an int consistent 1887 * with MountServiceResultCode 1888 */ formatVolume(String mountPoint)1889 public int formatVolume(String mountPoint) throws RemoteException; 1890 1891 /** 1892 * Gets the path to the mounted Opaque Binary Blob (OBB). 1893 */ getMountedObbPath(String rawPath)1894 public String getMountedObbPath(String rawPath) throws RemoteException; 1895 1896 /** 1897 * Gets an Array of currently known secure container IDs 1898 */ getSecureContainerList()1899 public String[] getSecureContainerList() throws RemoteException; 1900 1901 /* 1902 * Returns the filesystem path of a mounted secure container. 1903 */ getSecureContainerPath(String id)1904 public String getSecureContainerPath(String id) throws RemoteException; 1905 1906 /** 1907 * Returns an array of pids with open files on the specified path. 1908 */ getStorageUsers(String path)1909 public int[] getStorageUsers(String path) throws RemoteException; 1910 1911 /** 1912 * Gets the state of a volume via its mountpoint. 1913 */ getVolumeState(String mountPoint)1914 public String getVolumeState(String mountPoint) throws RemoteException; 1915 1916 /** 1917 * Checks whether the specified Opaque Binary Blob (OBB) is mounted 1918 * somewhere. 1919 */ isObbMounted(String rawPath)1920 public boolean isObbMounted(String rawPath) throws RemoteException; 1921 1922 /* 1923 * Returns true if the specified container is mounted 1924 */ isSecureContainerMounted(String id)1925 public boolean isSecureContainerMounted(String id) throws RemoteException; 1926 1927 /** 1928 * Returns true if a USB mass storage host is connected 1929 */ isUsbMassStorageConnected()1930 public boolean isUsbMassStorageConnected() throws RemoteException; 1931 1932 /** 1933 * Returns true if a USB mass storage host is enabled (media is shared) 1934 */ isUsbMassStorageEnabled()1935 public boolean isUsbMassStorageEnabled() throws RemoteException; 1936 1937 /** 1938 * Mounts an Opaque Binary Blob (OBB) with the specified decryption key and 1939 * only allows the calling process's UID access to the contents. 1940 * MountService will call back to the supplied IObbActionListener to inform 1941 * it of the terminal state of the call. 1942 */ mountObb(String rawPath, String canonicalPath, String key, IObbActionListener token, int nonce)1943 public void mountObb(String rawPath, String canonicalPath, String key, 1944 IObbActionListener token, int nonce) throws RemoteException; 1945 1946 /* 1947 * Mount a secure container with the specified key and owner UID. Returns an 1948 * int consistent with MountServiceResultCode 1949 */ mountSecureContainer(String id, String key, int ownerUid, boolean readOnly)1950 public int mountSecureContainer(String id, String key, int ownerUid, boolean readOnly) 1951 throws RemoteException; 1952 1953 /** 1954 * Mount external storage at given mount point. Returns an int consistent 1955 * with MountServiceResultCode 1956 */ mountVolume(String mountPoint)1957 public int mountVolume(String mountPoint) throws RemoteException; 1958 1959 /** 1960 * Registers an IMountServiceListener for receiving async notifications. 1961 */ registerListener(IMountServiceListener listener)1962 public void registerListener(IMountServiceListener listener) throws RemoteException; 1963 1964 /* 1965 * Rename an unmounted secure container. Returns an int consistent with 1966 * MountServiceResultCode 1967 */ renameSecureContainer(String oldId, String newId)1968 public int renameSecureContainer(String oldId, String newId) throws RemoteException; 1969 1970 /** 1971 * Enables / disables USB mass storage. The caller should check actual 1972 * status of enabling/disabling USB mass storage via StorageEventListener. 1973 */ setUsbMassStorageEnabled(boolean enable)1974 public void setUsbMassStorageEnabled(boolean enable) throws RemoteException; 1975 1976 /** 1977 * Shuts down the MountService and gracefully unmounts all external media. 1978 * Invokes call back once the shutdown is complete. 1979 */ shutdown(IMountShutdownObserver observer)1980 public void shutdown(IMountShutdownObserver observer) throws RemoteException; 1981 1982 /** 1983 * Unmounts an Opaque Binary Blob (OBB). When the force flag is specified, 1984 * any program using it will be forcibly killed to unmount the image. 1985 * MountService will call back to the supplied IObbActionListener to inform 1986 * it of the terminal state of the call. 1987 */ unmountObb(String rawPath, boolean force, IObbActionListener token, int nonce)1988 public void unmountObb(String rawPath, boolean force, IObbActionListener token, int nonce) 1989 throws RemoteException; 1990 1991 /* 1992 * Unount a secure container. Returns an int consistent with 1993 * MountServiceResultCode 1994 */ unmountSecureContainer(String id, boolean force)1995 public int unmountSecureContainer(String id, boolean force) throws RemoteException; 1996 1997 /** 1998 * Safely unmount external storage at given mount point. The unmount is an 1999 * asynchronous operation. Applications should register StorageEventListener 2000 * for storage related status changes. 2001 * @param mountPoint the mount point 2002 * @param force whether or not to forcefully unmount it (e.g. even if programs are using this 2003 * data currently) 2004 * @param removeEncryption whether or not encryption mapping should be removed from the volume. 2005 * This value implies {@code force}. 2006 */ unmountVolume(String mountPoint, boolean force, boolean removeEncryption)2007 public void unmountVolume(String mountPoint, boolean force, boolean removeEncryption) 2008 throws RemoteException; 2009 2010 /** 2011 * Unregisters an IMountServiceListener 2012 */ unregisterListener(IMountServiceListener listener)2013 public void unregisterListener(IMountServiceListener listener) throws RemoteException; 2014 2015 /** 2016 * Returns whether or not the external storage is emulated. 2017 */ isExternalStorageEmulated()2018 public boolean isExternalStorageEmulated() throws RemoteException; 2019 2020 /** The volume is not encrypted. */ 2021 static final int ENCRYPTION_STATE_NONE = 1; 2022 /** The volume has been encrypted succesfully. */ 2023 static final int ENCRYPTION_STATE_OK = 0; 2024 /** The volume is in a bad state.*/ 2025 static final int ENCRYPTION_STATE_ERROR_UNKNOWN = -1; 2026 /** Encryption is incomplete */ 2027 static final int ENCRYPTION_STATE_ERROR_INCOMPLETE = -2; 2028 /** Encryption is incomplete and irrecoverable */ 2029 static final int ENCRYPTION_STATE_ERROR_INCONSISTENT = -3; 2030 /** Underlying data is corrupt */ 2031 static final int ENCRYPTION_STATE_ERROR_CORRUPT = -4; 2032 2033 /** 2034 * Determines the encryption state of the volume. 2035 * @return a numerical value. See {@code ENCRYPTION_STATE_*} for possible values. 2036 */ getEncryptionState()2037 public int getEncryptionState() throws RemoteException; 2038 2039 /** 2040 * Decrypts any encrypted volumes. 2041 */ decryptStorage(String password)2042 public int decryptStorage(String password) throws RemoteException; 2043 2044 /** 2045 * Encrypts storage. 2046 */ encryptStorage(int type, String password)2047 public int encryptStorage(int type, String password) throws RemoteException; 2048 2049 /** 2050 * Changes the encryption password. 2051 */ changeEncryptionPassword(int type, String password)2052 public int changeEncryptionPassword(int type, String password) 2053 throws RemoteException; 2054 2055 /** 2056 * Verify the encryption password against the stored volume. This method 2057 * may only be called by the system process. 2058 */ verifyEncryptionPassword(String password)2059 public int verifyEncryptionPassword(String password) throws RemoteException; 2060 2061 /** 2062 * Returns list of all mountable volumes. 2063 */ getVolumeList(int uid, String packageName, int flags)2064 public StorageVolume[] getVolumeList(int uid, String packageName, int flags) throws RemoteException; 2065 2066 /** 2067 * Gets the path on the filesystem for the ASEC container itself. 2068 * 2069 * @param cid ASEC container ID 2070 * @return path to filesystem or {@code null} if it's not found 2071 * @throws RemoteException 2072 */ getSecureContainerFilesystemPath(String cid)2073 public String getSecureContainerFilesystemPath(String cid) throws RemoteException; 2074 2075 /* 2076 * Fix permissions in a container which has just been created and populated. 2077 * Returns an int consistent with MountServiceResultCode 2078 */ fixPermissionsSecureContainer(String id, int gid, String filename)2079 public int fixPermissionsSecureContainer(String id, int gid, String filename) 2080 throws RemoteException; 2081 2082 /** 2083 * Ensure that all directories along given path exist, creating parent 2084 * directories as needed. Validates that given path is absolute and that it 2085 * contains no relative "." or ".." paths or symlinks. Also ensures that 2086 * path belongs to a volume managed by vold, and that path is either 2087 * external storage data or OBB directory belonging to calling app. 2088 */ mkdirs(String callingPkg, String path)2089 public int mkdirs(String callingPkg, String path) throws RemoteException; 2090 2091 /** 2092 * Determines the type of the encryption password 2093 * @return PasswordType 2094 */ getPasswordType()2095 public int getPasswordType() throws RemoteException; 2096 2097 /** 2098 * Get password from vold 2099 * @return password or empty string 2100 */ getPassword()2101 public String getPassword() throws RemoteException; 2102 2103 /** 2104 * Securely clear password from vold 2105 */ clearPassword()2106 public void clearPassword() throws RemoteException; 2107 2108 /** 2109 * Set a field in the crypto header. 2110 * @param field field to set 2111 * @param contents contents to set in field 2112 */ setField(String field, String contents)2113 public void setField(String field, String contents) throws RemoteException; 2114 2115 /** 2116 * Gets a field from the crypto header. 2117 * @param field field to get 2118 * @return contents of field 2119 */ getField(String field)2120 public String getField(String field) throws RemoteException; 2121 resizeSecureContainer(String id, int sizeMb, String key)2122 public int resizeSecureContainer(String id, int sizeMb, String key) throws RemoteException; 2123 2124 /** 2125 * Report the time of the last maintenance operation such as fstrim. 2126 * @return Timestamp of the last maintenance operation, in the 2127 * System.currentTimeMillis() time base 2128 * @throws RemoteException 2129 */ lastMaintenance()2130 public long lastMaintenance() throws RemoteException; 2131 2132 /** 2133 * Kick off an immediate maintenance operation 2134 * @throws RemoteException 2135 */ runMaintenance()2136 public void runMaintenance() throws RemoteException; 2137 waitForAsecScan()2138 public void waitForAsecScan() throws RemoteException; 2139 getDisks()2140 public DiskInfo[] getDisks() throws RemoteException; getVolumes(int flags)2141 public VolumeInfo[] getVolumes(int flags) throws RemoteException; getVolumeRecords(int flags)2142 public VolumeRecord[] getVolumeRecords(int flags) throws RemoteException; 2143 mount(String volId)2144 public void mount(String volId) throws RemoteException; unmount(String volId)2145 public void unmount(String volId) throws RemoteException; format(String volId)2146 public void format(String volId) throws RemoteException; benchmark(String volId)2147 public long benchmark(String volId) throws RemoteException; 2148 partitionPublic(String diskId)2149 public void partitionPublic(String diskId) throws RemoteException; partitionPrivate(String diskId)2150 public void partitionPrivate(String diskId) throws RemoteException; partitionMixed(String diskId, int ratio)2151 public void partitionMixed(String diskId, int ratio) throws RemoteException; 2152 setVolumeNickname(String fsUuid, String nickname)2153 public void setVolumeNickname(String fsUuid, String nickname) throws RemoteException; setVolumeUserFlags(String fsUuid, int flags, int mask)2154 public void setVolumeUserFlags(String fsUuid, int flags, int mask) throws RemoteException; forgetVolume(String fsUuid)2155 public void forgetVolume(String fsUuid) throws RemoteException; forgetAllVolumes()2156 public void forgetAllVolumes() throws RemoteException; setDebugFlags(int flags, int mask)2157 public void setDebugFlags(int flags, int mask) throws RemoteException; 2158 getPrimaryStorageUuid()2159 public String getPrimaryStorageUuid() throws RemoteException; setPrimaryStorageUuid(String volumeUuid, IPackageMoveObserver callback)2160 public void setPrimaryStorageUuid(String volumeUuid, IPackageMoveObserver callback) 2161 throws RemoteException; 2162 } 2163