| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.os.storage; |
| |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.content.res.Resources.NotFoundException; |
| import android.os.Environment; |
| import android.os.SystemClock; |
| import android.test.InstrumentationTestCase; |
| import android.util.Log; |
| import android.os.Environment; |
| import android.os.FileUtils; |
| import android.os.storage.OnObbStateChangeListener; |
| import android.os.storage.StorageManager; |
| |
| import java.io.BufferedReader; |
| import java.io.DataInputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.InputStream; |
| import java.io.IOException; |
| import java.io.StringReader; |
| |
| public class StorageManagerBaseTest extends InstrumentationTestCase { |
| |
| protected Context mContext = null; |
| protected StorageManager mSm = null; |
| private static String LOG_TAG = "StorageManagerBaseTest"; |
| protected static final long MAX_WAIT_TIME = 120*1000; |
| protected static final long WAIT_TIME_INCR = 5*1000; |
| protected static String OBB_FILE_1 = "obb_file1.obb"; |
| protected static String OBB_FILE_1_CONTENTS_1 = "OneToOneThousandInts.bin"; |
| protected static String OBB_FILE_2 = "obb_file2.obb"; |
| protected static String OBB_FILE_3 = "obb_file3.obb"; |
| protected static String OBB_FILE_1_PASSWORD = "password1"; |
| protected static String OBB_FILE_1_ENCRYPTED = "obb_enc_file100_orig1.obb"; |
| protected static String OBB_FILE_2_UNSIGNED = "obb_file2_nosign.obb"; |
| protected static String OBB_FILE_3_PASSWORD = "password3"; |
| protected static String OBB_FILE_3_ENCRYPTED = "obb_enc_file100_orig3.obb"; |
| protected static String OBB_FILE_3_BAD_PACKAGENAME = "obb_file3_bad_packagename.obb"; |
| |
| protected static boolean FORCE = true; |
| protected static boolean DONT_FORCE = false; |
| |
| private static final String SAMPLE1_TEXT = "This is sample text.\n\nTesting 1 2 3."; |
| |
| private static final String SAMPLE2_TEXT = |
| "We the people of the United States, in order to form a more perfect union,\n" |
| + "establish justice, insure domestic tranquility, provide for the common\n" |
| + "defense, promote the general welfare, and secure the blessings of liberty\n" |
| + "to ourselves and our posterity, do ordain and establish this Constitution\n" |
| + "for the United States of America.\n\n"; |
| |
| class MountingObbThread extends Thread { |
| boolean mStop = false; |
| volatile boolean mFileOpenOnObb = false; |
| private String mObbFilePath = null; |
| private String mPathToContentsFile = null; |
| private String mOfficialObbFilePath = null; |
| |
| /** |
| * Constructor |
| * |
| * @param obbFilePath path to the OBB image file |
| * @param pathToContentsFile path to a file on the mounted OBB volume to open after the OBB |
| * has been mounted |
| */ |
| public MountingObbThread (String obbFilePath, String pathToContentsFile) { |
| assertTrue("obbFilePath cannot be null!", obbFilePath != null); |
| mObbFilePath = obbFilePath; |
| assertTrue("path to contents file cannot be null!", pathToContentsFile != null); |
| mPathToContentsFile = pathToContentsFile; |
| } |
| |
| /** |
| * Runs the thread |
| * |
| * Mounts OBB_FILE_1, and tries to open a file on the mounted OBB (specified in the |
| * constructor). Once it's open, it waits until someone calls its doStop(), after which it |
| * closes the opened file. |
| */ |
| public void run() { |
| // the official OBB file path and the mount-request file path should be the same, but |
| // let's distinguish the two as they may make for some interesting tests later |
| mOfficialObbFilePath = mountObb(mObbFilePath); |
| assertEquals("Expected and actual OBB file paths differ!", mObbFilePath, |
| mOfficialObbFilePath); |
| |
| // open a file on OBB 1... |
| DataInputStream inputFile = openFileOnMountedObb(mOfficialObbFilePath, |
| mPathToContentsFile); |
| assertTrue("Failed to open file!", inputFile != null); |
| |
| synchronized (this) { |
| mFileOpenOnObb = true; |
| notifyAll(); |
| } |
| |
| while (!mStop) { |
| try { |
| Thread.sleep(WAIT_TIME_INCR); |
| } catch (InterruptedException e) { |
| // nothing special to be done for interruptions |
| } |
| } |
| try { |
| inputFile.close(); |
| } catch (IOException e) { |
| fail("Failed to close file on OBB due to error: " + e.toString()); |
| } |
| } |
| |
| /** |
| * Tells whether a file has yet been successfully opened on the OBB or not |
| * |
| * @return true if the specified file on the OBB was opened; false otherwise |
| */ |
| public boolean isFileOpenOnObb() { |
| return mFileOpenOnObb; |
| } |
| |
| /** |
| * Returns the official path of the OBB file that was mounted |
| * |
| * This is not the mount path, but the normalized path to the actual OBB file |
| * |
| * @return a {@link String} representation of the path to the OBB file that was mounted |
| */ |
| public String officialObbFilePath() { |
| return mOfficialObbFilePath; |
| } |
| |
| /** |
| * Requests the thread to stop running |
| * |
| * Closes the opened file and returns |
| */ |
| public void doStop() { |
| mStop = true; |
| } |
| } |
| |
| public class ObbListener extends OnObbStateChangeListener { |
| private String LOG_TAG = "StorageManagerBaseTest.ObbListener"; |
| |
| String mOfficialPath = null; |
| boolean mDone = false; |
| int mState = -1; |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public void onObbStateChange(String path, int state) { |
| Log.i(LOG_TAG, "Storage state changing to: " + state); |
| |
| synchronized (this) { |
| Log.i(LOG_TAG, "OfficialPath is now: " + path); |
| mState = state; |
| mOfficialPath = path; |
| mDone = true; |
| notifyAll(); |
| } |
| } |
| |
| /** |
| * Tells whether we are done or not (system told us the OBB has changed state) |
| * |
| * @return true if the system has told us this OBB's state has changed, false otherwise |
| */ |
| public boolean isDone() { |
| return mDone; |
| } |
| |
| /** |
| * The last state of the OBB, according to the system |
| * |
| * @return A {@link String} representation of the state of the OBB |
| */ |
| public int state() { |
| return mState; |
| } |
| |
| /** |
| * The normalized, official path to the OBB file (according to the system) |
| * |
| * @return A {@link String} representation of the official path to the OBB file |
| */ |
| public String officialPath() { |
| return mOfficialPath; |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public void setUp() throws Exception { |
| mContext = getInstrumentation().getContext(); |
| mSm = (StorageManager)mContext.getSystemService(android.content.Context.STORAGE_SERVICE); |
| |
| } |
| |
| /** |
| * Helper to copy a raw resource file to an actual specified file |
| * |
| * @param rawResId The raw resource ID of the OBB resource file |
| * @param outFile A File representing the file we want to copy the OBB to |
| * @throws NotFoundException If the resource file could not be found |
| */ |
| private void copyRawToFile(int rawResId, File outFile) throws NotFoundException { |
| Resources res = mContext.getResources(); |
| InputStream is = null; |
| try { |
| is = res.openRawResource(rawResId); |
| } catch (NotFoundException e) { |
| Log.i(LOG_TAG, "Failed to load resource with id: " + rawResId); |
| throw e; |
| } |
| FileUtils.setPermissions(outFile.getPath(), FileUtils.S_IRWXU | FileUtils.S_IRWXG |
| | FileUtils.S_IRWXO, -1, -1); |
| assertTrue(FileUtils.copyToFile(is, outFile)); |
| FileUtils.setPermissions(outFile.getPath(), FileUtils.S_IRWXU | FileUtils.S_IRWXG |
| | FileUtils.S_IRWXO, -1, -1); |
| } |
| |
| /** |
| * Creates an OBB file (with the given name), into the app's standard files directory |
| * |
| * @param name The name of the OBB file we want to create/write to |
| * @param rawResId The raw resource ID of the OBB file in the package |
| * @return A {@link File} representing the file to write to |
| */ |
| protected File createObbFile(String name, int rawResId) { |
| File outFile = null; |
| try { |
| final File filesDir = mContext.getFilesDir(); |
| outFile = new File(filesDir, name); |
| copyRawToFile(rawResId, outFile); |
| } catch (NotFoundException e) { |
| if (outFile != null) { |
| outFile.delete(); |
| } |
| } |
| return outFile; |
| } |
| |
| /** |
| * Mounts an OBB file and opens a file located on it |
| * |
| * @param obbPath Path to OBB image |
| * @param fileName The full name and path to the file on the OBB to open once the OBB is mounted |
| * @return The {@link DataInputStream} representing the opened file, if successful in opening |
| * the file, or null of unsuccessful. |
| */ |
| protected DataInputStream openFileOnMountedObb(String obbPath, String fileName) { |
| |
| // get mSm obb mount path |
| assertTrue("Cannot open file when OBB is not mounted!", mSm.isObbMounted(obbPath)); |
| |
| String path = mSm.getMountedObbPath(obbPath); |
| assertTrue("Path should not be null!", path != null); |
| |
| File inFile = new File(path, fileName); |
| DataInputStream inStream = null; |
| try { |
| inStream = new DataInputStream(new FileInputStream(inFile)); |
| Log.i(LOG_TAG, "Opened file: " + fileName + " for read at path: " + path); |
| } catch (FileNotFoundException e) { |
| Log.e(LOG_TAG, e.toString()); |
| return null; |
| } catch (SecurityException e) { |
| Log.e(LOG_TAG, e.toString()); |
| return null; |
| } |
| return inStream; |
| } |
| |
| /** |
| * Mounts an OBB file |
| * |
| * @param obbFilePath The full path to the OBB file to mount |
| * @param key (optional) The key to use to unencrypt the OBB; pass null for no encryption |
| * @param expectedState The expected state resulting from trying to mount the OBB |
| * @return A {@link String} representing the normalized path to OBB file that was mounted |
| */ |
| protected String mountObb(String obbFilePath, String key, int expectedState) { |
| return doMountObb(obbFilePath, key, expectedState); |
| } |
| |
| /** |
| * Mounts an OBB file with default options (no encryption, mounting succeeds) |
| * |
| * @param obbFilePath The full path to the OBB file to mount |
| * @return A {@link String} representing the normalized path to OBB file that was mounted |
| */ |
| protected String mountObb(String obbFilePath) { |
| return doMountObb(obbFilePath, null, OnObbStateChangeListener.MOUNTED); |
| } |
| |
| /** |
| * Synchronously waits for an OBB listener to be signaled of a state change, but does not throw |
| * |
| * @param obbListener The listener for the OBB file |
| * @return true if the listener was signaled of a state change by the system, else returns |
| * false if we time out. |
| */ |
| protected boolean doWaitForObbStateChange(ObbListener obbListener) { |
| synchronized(obbListener) { |
| long waitTimeMillis = 0; |
| while (!obbListener.isDone()) { |
| try { |
| Log.i(LOG_TAG, "Waiting for listener..."); |
| obbListener.wait(WAIT_TIME_INCR); |
| Log.i(LOG_TAG, "Awoke from waiting for listener..."); |
| waitTimeMillis += WAIT_TIME_INCR; |
| if (waitTimeMillis > MAX_WAIT_TIME) { |
| fail("Timed out waiting for OBB state to change!"); |
| } |
| } catch (InterruptedException e) { |
| Log.i(LOG_TAG, e.toString()); |
| } |
| } |
| return obbListener.isDone(); |
| } |
| } |
| |
| /** |
| * Synchronously waits for an OBB listener to be signaled of a state change |
| * |
| * @param obbListener The listener for the OBB file |
| * @return true if the listener was signaled of a state change by the system; else a fail() |
| * is triggered if we timed out |
| */ |
| protected String doMountObb_noThrow(String obbFilePath, String key, int expectedState) { |
| Log.i(LOG_TAG, "doMountObb() on " + obbFilePath + " using key: " + key); |
| assertTrue ("Null path was passed in for OBB file!", obbFilePath != null); |
| assertTrue ("Null path was passed in for OBB file!", obbFilePath != null); |
| |
| ObbListener obbListener = new ObbListener(); |
| boolean success = mSm.mountObb(obbFilePath, key, obbListener); |
| success &= obbFilePath.equals(doWaitForObbStateChange(obbListener)); |
| success &= (expectedState == obbListener.state()); |
| |
| if (OnObbStateChangeListener.MOUNTED == expectedState) { |
| success &= obbFilePath.equals(obbListener.officialPath()); |
| success &= mSm.isObbMounted(obbListener.officialPath()); |
| } else { |
| success &= !mSm.isObbMounted(obbListener.officialPath()); |
| } |
| |
| if (success) { |
| return obbListener.officialPath(); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Mounts an OBB file without throwing and synchronously waits for it to finish mounting |
| * |
| * @param obbFilePath The full path to the OBB file to mount |
| * @param key (optional) The key to use to unencrypt the OBB; pass null for no encryption |
| * @param expectedState The expected state resulting from trying to mount the OBB |
| * @return A {@link String} representing the actual normalized path to OBB file that was |
| * mounted, or null if the mounting failed |
| */ |
| protected String doMountObb(String obbFilePath, String key, int expectedState) { |
| Log.i(LOG_TAG, "doMountObb() on " + obbFilePath + " using key: " + key); |
| assertTrue ("Null path was passed in for OBB file!", obbFilePath != null); |
| |
| ObbListener obbListener = new ObbListener(); |
| assertTrue("mountObb call failed", mSm.mountObb(obbFilePath, key, obbListener)); |
| assertTrue("Failed to get OBB mount status change for file: " + obbFilePath, |
| doWaitForObbStateChange(obbListener)); |
| assertEquals("OBB mount state not what was expected!", expectedState, obbListener.state()); |
| |
| if (OnObbStateChangeListener.MOUNTED == expectedState) { |
| assertEquals(obbFilePath, obbListener.officialPath()); |
| assertTrue("Obb should be mounted, but SM reports it is not!", |
| mSm.isObbMounted(obbListener.officialPath())); |
| } else if (OnObbStateChangeListener.UNMOUNTED == expectedState) { |
| assertFalse("Obb should not be mounted, but SM reports it is!", |
| mSm.isObbMounted(obbListener.officialPath())); |
| } |
| |
| assertEquals("Mount state is not what was expected!", expectedState, obbListener.state()); |
| return obbListener.officialPath(); |
| } |
| |
| /** |
| * Unmounts an OBB file without throwing, and synchronously waits for it to finish unmounting |
| * |
| * @param obbFilePath The full path to the OBB file to mount |
| * @param force true if we shuold force the unmount, false otherwise |
| * @return true if the unmount was successful, false otherwise |
| */ |
| protected boolean unmountObb_noThrow(String obbFilePath, boolean force) { |
| Log.i(LOG_TAG, "doUnmountObb_noThrow() on " + obbFilePath); |
| assertTrue ("Null path was passed in for OBB file!", obbFilePath != null); |
| boolean success = true; |
| |
| ObbListener obbListener = new ObbListener(); |
| assertTrue("unmountObb call failed", mSm.unmountObb(obbFilePath, force, obbListener)); |
| |
| boolean stateChanged = doWaitForObbStateChange(obbListener); |
| if (force) { |
| success &= stateChanged; |
| success &= (OnObbStateChangeListener.UNMOUNTED == obbListener.state()); |
| success &= !mSm.isObbMounted(obbFilePath); |
| } |
| return success; |
| } |
| |
| /** |
| * Unmounts an OBB file and synchronously waits for it to finish unmounting |
| * |
| * @param obbFilePath The full path to the OBB file to mount |
| * @param force true if we shuold force the unmount, false otherwise |
| */ |
| protected void unmountObb(String obbFilePath, boolean force) { |
| Log.i(LOG_TAG, "doUnmountObb() on " + obbFilePath); |
| assertTrue ("Null path was passed in for OBB file!", obbFilePath != null); |
| |
| ObbListener obbListener = new ObbListener(); |
| assertTrue("unmountObb call failed", mSm.unmountObb(obbFilePath, force, obbListener)); |
| |
| boolean stateChanged = doWaitForObbStateChange(obbListener); |
| if (force) { |
| assertTrue("Timed out waiting to unmount OBB file " + obbFilePath, stateChanged); |
| assertEquals("OBB failed to unmount", OnObbStateChangeListener.UNMOUNTED, |
| obbListener.state()); |
| assertFalse("Obb should NOT be mounted, but SM reports it is!", mSm.isObbMounted( |
| obbFilePath)); |
| } |
| } |
| |
| /** |
| * Helper to validate the contents of an "int" file in an OBB. |
| * |
| * The format of the files are sequential int's, in the range of: [start..end) |
| * |
| * @param path The full path to the file (path to OBB) |
| * @param filename The filename containing the ints to validate |
| * @param start The first int expected to be found in the file |
| * @param end The last int + 1 expected to be found in the file |
| */ |
| protected void doValidateIntContents(String path, String filename, int start, int end) { |
| File inFile = new File(path, filename); |
| DataInputStream inStream = null; |
| Log.i(LOG_TAG, "Validating file " + filename + " at " + path); |
| try { |
| inStream = new DataInputStream(new FileInputStream(inFile)); |
| |
| for (int i = start; i < end; ++i) { |
| if (inStream.readInt() != i) { |
| fail("Unexpected value read in OBB file"); |
| } |
| } |
| if (inStream != null) { |
| inStream.close(); |
| } |
| Log.i(LOG_TAG, "Successfully validated file " + filename); |
| } catch (FileNotFoundException e) { |
| fail("File " + inFile + " not found: " + e.toString()); |
| } catch (IOException e) { |
| fail("IOError with file " + inFile + ":" + e.toString()); |
| } |
| } |
| |
| /** |
| * Helper to validate the contents of a text file in an OBB |
| * |
| * @param path The full path to the file (path to OBB) |
| * @param filename The filename containing the ints to validate |
| * @param contents A {@link String} containing the expected contents of the file |
| */ |
| protected void doValidateTextContents(String path, String filename, String contents) { |
| File inFile = new File(path, filename); |
| BufferedReader fileReader = null; |
| BufferedReader textReader = null; |
| Log.i(LOG_TAG, "Validating file " + filename + " at " + path); |
| try { |
| fileReader = new BufferedReader(new FileReader(inFile)); |
| textReader = new BufferedReader(new StringReader(contents)); |
| String actual = null; |
| String expected = null; |
| while ((actual = fileReader.readLine()) != null) { |
| expected = textReader.readLine(); |
| if (!actual.equals(expected)) { |
| fail("File " + filename + " in OBB " + path + " does not match expected value"); |
| } |
| } |
| fileReader.close(); |
| textReader.close(); |
| Log.i(LOG_TAG, "File " + filename + " successfully verified."); |
| } catch (IOException e) { |
| fail("IOError with file " + inFile + ":" + e.toString()); |
| } |
| } |
| |
| /** |
| * Helper to validate the contents of a "long" file on our OBBs |
| * |
| * The format of the files are sequential 0's of type long |
| * |
| * @param path The full path to the file (path to OBB) |
| * @param filename The filename containing the ints to validate |
| * @param size The number of zero's expected in the file |
| * @param checkContents If true, the contents of the file are actually verified; if false, |
| * we simply verify that the file can be opened |
| */ |
| protected void doValidateZeroLongFile(String path, String filename, long size, |
| boolean checkContents) { |
| File inFile = new File(path, filename); |
| DataInputStream inStream = null; |
| Log.i(LOG_TAG, "Validating file " + filename + " at " + path); |
| try { |
| inStream = new DataInputStream(new FileInputStream(inFile)); |
| |
| if (checkContents) { |
| for (long i = 0; i < size; ++i) { |
| if (inStream.readLong() != 0) { |
| fail("Unexpected value read in OBB file" + filename); |
| } |
| } |
| } |
| |
| if (inStream != null) { |
| inStream.close(); |
| } |
| Log.i(LOG_TAG, "File " + filename + " successfully verified for " + size + " zeros"); |
| } catch (IOException e) { |
| fail("IOError with file " + inFile + ":" + e.toString()); |
| } |
| } |
| |
| /** |
| * Helper to synchronously wait until we can get a path for a given OBB file |
| * |
| * @param filePath The full normalized path to the OBB file |
| * @return The mounted path of the OBB, used to access contents in it |
| */ |
| protected String doWaitForPath(String filePath) { |
| String path = null; |
| |
| long waitTimeMillis = 0; |
| assertTrue("OBB " + filePath + " is not currently mounted!", mSm.isObbMounted(filePath)); |
| while (path == null) { |
| try { |
| Thread.sleep(WAIT_TIME_INCR); |
| waitTimeMillis += WAIT_TIME_INCR; |
| if (waitTimeMillis > MAX_WAIT_TIME) { |
| fail("Timed out waiting to get path of OBB file " + filePath); |
| } |
| } catch (InterruptedException e) { |
| // do nothing |
| } |
| path = mSm.getMountedObbPath(filePath); |
| } |
| Log.i(LOG_TAG, "Got OBB path: " + path); |
| return path; |
| } |
| |
| /** |
| * Verifies the pre-defined contents of our first OBB (OBB_FILE_1) |
| * |
| * The OBB contains 4 files and no subdirectories |
| * |
| * @param filePath The normalized path to the already-mounted OBB file |
| */ |
| protected void verifyObb1Contents(String filePath) { |
| String path = null; |
| path = doWaitForPath(filePath); |
| |
| // Validate contents of 2 files in this obb |
| doValidateIntContents(path, "OneToOneThousandInts.bin", 0, 1000); |
| doValidateIntContents(path, "SevenHundredInts.bin", 0, 700); |
| doValidateZeroLongFile(path, "FiveLongs.bin", 5, true); |
| } |
| |
| /** |
| * Verifies the pre-defined contents of our second OBB (OBB_FILE_2) |
| * |
| * The OBB contains 2 files and no subdirectories |
| * |
| * @param filePath The normalized path to the already-mounted OBB file |
| */ |
| protected void verifyObb2Contents(String filename) { |
| String path = null; |
| path = doWaitForPath(filename); |
| |
| // Validate contents of file |
| doValidateTextContents(path, "sample.txt", SAMPLE1_TEXT); |
| doValidateTextContents(path, "sample2.txt", SAMPLE2_TEXT); |
| } |
| |
| /** |
| * Verifies the pre-defined contents of our third OBB (OBB_FILE_3) |
| * |
| * The OBB contains nested files and subdirectories |
| * |
| * @param filePath The normalized path to the already-mounted OBB file |
| */ |
| protected void verifyObb3Contents(String filename) { |
| String path = null; |
| path = doWaitForPath(filename); |
| |
| // Validate contents of file |
| doValidateIntContents(path, "OneToOneThousandInts.bin", 0, 1000); |
| doValidateZeroLongFile(path, "TwoHundredLongs", 200, true); |
| |
| // validate subdirectory 1 |
| doValidateZeroLongFile(path + File.separator + "subdir1", "FiftyLongs", 50, true); |
| |
| // validate subdirectory subdir2/ |
| doValidateIntContents(path + File.separator + "subdir2", "OneToOneThousandInts", 0, 1000); |
| |
| // validate subdirectory subdir2/subdir2a/ |
| doValidateZeroLongFile(path + File.separator + "subdir2" + File.separator + "subdir2a", |
| "TwoHundredLongs", 200, true); |
| |
| // validate subdirectory subdir2/subdir2a/subdir2a1/ |
| doValidateIntContents(path + File.separator + "subdir2" + File.separator + "subdir2a" |
| + File.separator + "subdir2a1", "OneToOneThousandInts", 0, 1000); |
| } |
| } |
