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