1 /*
2  * Copyright (C) 2014 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.service.persistentdata;
18 
19 import android.annotation.IntDef;
20 import android.annotation.RequiresPermission;
21 import android.annotation.SuppressLint;
22 import android.annotation.SystemApi;
23 import android.annotation.SystemService;
24 import android.content.Context;
25 import android.os.RemoteException;
26 import android.service.oemlock.OemLockManager;
27 
28 import java.lang.annotation.Retention;
29 import java.lang.annotation.RetentionPolicy;
30 
31 /**
32  * Interface for reading and writing data blocks to a persistent partition.
33  *
34  * Allows writing one block at a time. Namely, each time
35  * {@link PersistentDataBlockManager#write(byte[])}
36  * is called, it will overwite the data that was previously written on the block.
37  *
38  * Clients can query the size of the currently written block via
39  * {@link PersistentDataBlockManager#getDataBlockSize()}.
40  *
41  * Clients can query the maximum size for a block via
42  * {@link PersistentDataBlockManager#getMaximumDataBlockSize()}
43  *
44  * Clients can read the currently written block by invoking
45  * {@link PersistentDataBlockManager#read()}.
46  *
47  * @hide
48  */
49 @SystemApi
50 @SystemService(Context.PERSISTENT_DATA_BLOCK_SERVICE)
51 public class PersistentDataBlockManager {
52     private static final String TAG = PersistentDataBlockManager.class.getSimpleName();
53     private IPersistentDataBlockService sService;
54 
55     /**
56      * Indicates that the device's bootloader lock state is UNKNOWN.
57      */
58     public static final int FLASH_LOCK_UNKNOWN = -1;
59     /**
60      * Indicates that the device's bootloader is UNLOCKED.
61      */
62     public static final int FLASH_LOCK_UNLOCKED = 0;
63     /**
64      * Indicates that the device's bootloader is LOCKED.
65      */
66     public static final int FLASH_LOCK_LOCKED = 1;
67 
68     @IntDef({
69         FLASH_LOCK_UNKNOWN,
70         FLASH_LOCK_LOCKED,
71         FLASH_LOCK_UNLOCKED,
72     })
73     @Retention(RetentionPolicy.SOURCE)
74     public @interface FlashLockState {}
75 
76     /** @hide */
PersistentDataBlockManager(IPersistentDataBlockService service)77     public PersistentDataBlockManager(IPersistentDataBlockService service) {
78         sService = service;
79     }
80 
81     /**
82      * Writes {@code data} to the persistent partition. Previously written data
83      * will be overwritten. This data will persist across factory resets.
84      *
85      * Returns the number of bytes written or -1 on error. If the block is too big
86      * to fit on the partition, returns -MAX_BLOCK_SIZE.
87      *
88      * {@link #wipe} will block any further {@link #write} operation until reboot,
89      * in which case -1 will be returned.
90      *
91      * @param data the data to write
92      */
93     @SuppressLint("Doclava125")
write(byte[] data)94     public int write(byte[] data) {
95         try {
96             return sService.write(data);
97         } catch (RemoteException e) {
98             throw e.rethrowFromSystemServer();
99         }
100     }
101 
102     /**
103      * Returns the data block stored on the persistent partition.
104      */
105     @SuppressLint("Doclava125")
read()106     public byte[] read() {
107         try {
108             return sService.read();
109         } catch (RemoteException e) {
110             throw e.rethrowFromSystemServer();
111         }
112     }
113 
114     /**
115      * Retrieves the size of the block currently written to the persistent partition.
116      *
117      * Return -1 on error.
118      */
119     @RequiresPermission(android.Manifest.permission.ACCESS_PDB_STATE)
getDataBlockSize()120     public int getDataBlockSize() {
121         try {
122             return sService.getDataBlockSize();
123         } catch (RemoteException e) {
124             throw e.rethrowFromSystemServer();
125         }
126     }
127 
128     /**
129      * Retrieves the maximum size allowed for a data block.
130      *
131      * Returns -1 on error.
132      */
getMaximumDataBlockSize()133     public long getMaximumDataBlockSize() {
134         try {
135             return sService.getMaximumDataBlockSize();
136         } catch (RemoteException e) {
137             throw e.rethrowFromSystemServer();
138         }
139     }
140 
141     /**
142      * Zeroes the previously written block in its entirety. Calling this method
143      * will erase all data written to the persistent data partition.
144      * It will also prevent any further {@link #write} operation until reboot,
145      * in order to prevent a potential race condition. See b/30352311.
146      */
147     @RequiresPermission(android.Manifest.permission.OEM_UNLOCK_STATE)
wipe()148     public void wipe() {
149         try {
150             sService.wipe();
151         } catch (RemoteException e) {
152             throw e.rethrowFromSystemServer();
153         }
154     }
155 
156     /**
157      * Writes a byte enabling or disabling the ability to "OEM unlock" the device.
158      *
159      * @deprecated use {@link OemLockManager#setOemUnlockAllowedByUser(boolean)} instead.
160      */
161     @RequiresPermission(android.Manifest.permission.OEM_UNLOCK_STATE)
setOemUnlockEnabled(boolean enabled)162     public void setOemUnlockEnabled(boolean enabled) {
163         try {
164             sService.setOemUnlockEnabled(enabled);
165         } catch (RemoteException e) {
166             throw e.rethrowFromSystemServer();
167         }
168     }
169 
170     /**
171      * Returns whether or not "OEM unlock" is enabled or disabled on this device.
172      *
173      * @deprecated use {@link OemLockManager#isOemUnlockAllowedByUser()} instead.
174      */
175     @RequiresPermission(anyOf = {
176             android.Manifest.permission.READ_OEM_UNLOCK_STATE,
177             android.Manifest.permission.OEM_UNLOCK_STATE
178     })
getOemUnlockEnabled()179     public boolean getOemUnlockEnabled() {
180         try {
181             return sService.getOemUnlockEnabled();
182         } catch (RemoteException e) {
183             throw e.rethrowFromSystemServer();
184         }
185     }
186 
187     /**
188      * Retrieves available information about this device's flash lock state.
189      *
190      * @return {@link #FLASH_LOCK_LOCKED} if device bootloader is locked,
191      * {@link #FLASH_LOCK_UNLOCKED} if device bootloader is unlocked, or {@link #FLASH_LOCK_UNKNOWN}
192      * if this information cannot be ascertained on this device.
193      */
194     @RequiresPermission(anyOf = {
195             android.Manifest.permission.READ_OEM_UNLOCK_STATE,
196             android.Manifest.permission.OEM_UNLOCK_STATE
197     })
198     @FlashLockState
getFlashLockState()199     public int getFlashLockState() {
200         try {
201             return sService.getFlashLockState();
202         } catch (RemoteException e) {
203             throw e.rethrowFromSystemServer();
204         }
205     }
206 }
207