| /* |
| * Copyright (C) 2011 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 com.android.sdklib; |
| |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.prefs.AndroidLocation; |
| import com.android.prefs.AndroidLocation.AndroidLocationException; |
| import com.android.resources.Density; |
| import com.android.resources.Keyboard; |
| import com.android.resources.KeyboardState; |
| import com.android.resources.Navigation; |
| import com.android.resources.NavigationState; |
| import com.android.resources.ScreenOrientation; |
| import com.android.resources.ScreenRatio; |
| import com.android.resources.ScreenSize; |
| import com.android.resources.TouchScreen; |
| import com.android.sdklib.ISystemImage.LocationType; |
| import com.android.sdklib.devices.ButtonType; |
| import com.android.sdklib.devices.Device; |
| import com.android.sdklib.devices.Device.Builder; |
| import com.android.sdklib.devices.DeviceWriter; |
| import com.android.sdklib.devices.Hardware; |
| import com.android.sdklib.devices.Multitouch; |
| import com.android.sdklib.devices.PowerType; |
| import com.android.sdklib.devices.Screen; |
| import com.android.sdklib.devices.ScreenType; |
| import com.android.sdklib.devices.Software; |
| import com.android.sdklib.devices.State; |
| import com.android.sdklib.devices.Storage; |
| import com.android.sdklib.devices.Storage.Unit; |
| import com.android.sdklib.internal.avd.AvdManager; |
| import com.android.sdklib.io.FileOp; |
| import com.android.sdklib.mock.MockLog; |
| import com.android.sdklib.repository.FullRevision; |
| import com.android.sdklib.repository.PkgProps; |
| import com.android.sdklib.repository.SdkRepoConstants; |
| import com.android.sdklib.repository.local.LocalPlatformPkgInfo; |
| import com.android.sdklib.repository.local.LocalSysImgPkgInfo; |
| import com.android.utils.ILogger; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * Base Test case that allocates a temporary SDK, a temporary AVD base folder with an SdkManager and |
| * an AvdManager that points to them. <p/> Also overrides the {@link AndroidLocation} to point to |
| * temp one. |
| */ |
| public abstract class SdkManagerTestCase extends AndroidLocationTestCase { |
| |
| protected static final String TARGET_DIR_NAME_0 = "v0_0"; |
| |
| private File mFakeSdk; |
| |
| private MockLog mLog; |
| |
| private SdkManager mSdkManager; |
| |
| private AvdManager mAvdManager; |
| |
| private int mRepoXsdLevel; |
| |
| /** |
| * Returns the {@link MockLog} for this test case. |
| */ |
| public MockLog getLog() { |
| return mLog; |
| } |
| |
| /** |
| * Returns the {@link SdkManager} for this test case. |
| */ |
| public SdkManager getSdkManager() { |
| return mSdkManager; |
| } |
| |
| /** |
| * Returns the {@link AvdManager} for this test case. |
| */ |
| public AvdManager getAvdManager() { |
| return mAvdManager; |
| } |
| |
| /** |
| * Sets up a {@link MockLog}, a fake SDK in a temporary directory and an AVD Manager pointing to |
| * an initially-empty AVD directory. |
| */ |
| public void setUp(int repoXsdLevel) throws Exception { |
| super.setUp(); |
| mRepoXsdLevel = repoXsdLevel; |
| mLog = new MockLog(); |
| makeFakeSdk(); |
| createSdkAvdManagers(); |
| } |
| |
| /** |
| * Recreate the SDK and AVD Managers from scratch even if they already existed. Useful for tests |
| * that want to reset their state without recreating the android-home or the fake SDK. The SDK |
| * will be reparsed. |
| */ |
| protected void createSdkAvdManagers() throws AndroidLocationException { |
| mSdkManager = SdkManager.createManager(mFakeSdk.getAbsolutePath(), mLog); |
| assertNotNull("SdkManager location was invalid", mSdkManager); |
| // Note: it's safe to use the default AvdManager implementation since makeFakeAndroidHome |
| // above overrides the ANDROID_HOME folder to use a temp folder; consequently all |
| // the AVDs created here will be located in this temp folder and will not alter |
| // or pollute the default user's AVD folder. |
| mAvdManager = new AvdManager(mSdkManager.getLocalSdk(), mLog) { |
| @Override |
| protected boolean createSdCard( |
| String toolLocation, |
| String size, |
| String location, |
| ILogger log) { |
| if (new File(toolLocation).exists()) { |
| log.info("[EXEC] %1$s %2$s %3$s\n", toolLocation, size, location); |
| return true; |
| } else { |
| log.error(null, "Failed to create the SD card.\n"); |
| return false; |
| } |
| |
| } |
| }; |
| } |
| |
| /** |
| * Sets up a {@link MockLog}, a fake SDK in a temporary directory and an AVD Manager pointing to |
| * an initially-empty AVD directory. |
| */ |
| @Override |
| public void setUp() throws Exception { |
| setUp(SdkRepoConstants.NS_LATEST_VERSION); |
| } |
| |
| /** |
| * Removes the temporary SDK and AVD directories. |
| */ |
| @Override |
| public void tearDown() throws Exception { |
| tearDownSdk(); |
| super.tearDown(); |
| } |
| |
| /** |
| * Build enough of a skeleton SDK to make the tests pass. <p/> Ideally this wouldn't touch the |
| * file system but the current structure of the SdkManager and AvdManager makes this |
| * impossible. |
| */ |
| private void makeFakeSdk() throws IOException { |
| // First we create a temp file to "reserve" the temp directory name we want to use. |
| mFakeSdk = File.createTempFile( |
| "sdk_" + this.getClass().getSimpleName() + '_' + this.getName(), null); |
| // Then erase the file and make the directory |
| mFakeSdk.delete(); |
| mFakeSdk.mkdirs(); |
| |
| File addonsDir = new File(mFakeSdk, SdkConstants.FD_ADDONS); |
| addonsDir.mkdir(); |
| |
| File toolsDir = new File(mFakeSdk, SdkConstants.OS_SDK_TOOLS_FOLDER); |
| toolsDir.mkdir(); |
| createSourceProps(toolsDir, PkgProps.PKG_REVISION, "1.0.1"); |
| new File(toolsDir, SdkConstants.androidCmdName()).createNewFile(); |
| new File(toolsDir, SdkConstants.FN_EMULATOR).createNewFile(); |
| new File(toolsDir, SdkConstants.mkSdCardCmdName()).createNewFile(); |
| |
| makePlatformTools(new File(mFakeSdk, SdkConstants.FD_PLATFORM_TOOLS)); |
| |
| if (mRepoXsdLevel >= 8) { |
| makeBuildTools(mFakeSdk); |
| } |
| |
| File toolsLibEmuDir = new File(mFakeSdk, SdkConstants.OS_SDK_TOOLS_LIB_FOLDER + "emulator"); |
| toolsLibEmuDir.mkdirs(); |
| new File(toolsLibEmuDir, "snapshots.img").createNewFile(); |
| File platformsDir = new File(mFakeSdk, SdkConstants.FD_PLATFORMS); |
| |
| // Creating a fake target here on down |
| File targetDir = makeFakeTargetInternal(platformsDir); |
| makeFakeLegacySysImg(targetDir, SdkConstants.ABI_ARMEABI); |
| |
| makeFakeSkin(targetDir, "HVGA"); |
| makeFakeSourceInternal(mFakeSdk); |
| } |
| |
| private void tearDownSdk() { |
| deleteDir(mFakeSdk); |
| } |
| |
| /** |
| * Creates the system image folder and places a fake userdata.img in it. |
| * |
| * @param systemImage A system image with a valid location. |
| */ |
| protected void makeSystemImageFolder(ISystemImage systemImage, String deviceId) |
| throws Exception { |
| File sysImgDir = systemImage.getLocation(); |
| String vendor = systemImage.getAddonVendor() == null ? null |
| : systemImage.getAddonVendor().getId(); |
| if (systemImage.getLocationType() == LocationType.IN_LEGACY_FOLDER) { |
| // legacy mode. Path should look like SDK/platforms/platform-N/userdata.img |
| makeFakeLegacySysImg(sysImgDir.getParentFile(), systemImage.getAbiType()); |
| |
| } else if (systemImage.getLocationType() == LocationType.IN_IMAGES_SUBFOLDER) { |
| // not-so-legacy mode. |
| // Path should look like SDK/platforms/platform-N/images/userdata.img |
| makeFakeSysImgInternal( |
| sysImgDir, |
| systemImage.getTag().getId(), |
| systemImage.getAbiType(), |
| deviceId, |
| vendor); |
| |
| } else if (systemImage.getLocationType() == LocationType.IN_SYSTEM_IMAGE) { |
| // system-image folder mode. |
| // Path should like SDK/system-images/platform-N/tag/abi/userdata.img+source.properties |
| makeFakeSysImgInternal( |
| sysImgDir, |
| systemImage.getTag().getId(), |
| systemImage.getAbiType(), |
| deviceId, |
| vendor); |
| } |
| } |
| |
| /** |
| * Creates the system image folder and places a fake userdata.img in it. This must be called |
| * after {@link #setUp()} so that it can use the temp fake SDK folder, and consequently you do |
| * not need to specify the SDK root. |
| * |
| * @param targetDir The targetDir segment of the sys-image folder. Use {@link |
| * #TARGET_DIR_NAME_0} to match the default single platform. |
| * @param tagId An optional tag id. Use null for legacy no-tag system images. |
| * @param abiType The abi for the system image. |
| * @return The directory of the system-image/tag/abi created. |
| * @throws IOException if the file fails to be created. |
| */ |
| @NonNull |
| protected File makeSystemImageFolder( |
| @NonNull String targetDir, |
| @Nullable String tagId, |
| @NonNull String abiType) throws Exception { |
| File sysImgDir = new File(mFakeSdk, SdkConstants.FD_SYSTEM_IMAGES); |
| sysImgDir = new File(sysImgDir, targetDir); |
| if (tagId != null) { |
| sysImgDir = new File(sysImgDir, tagId); |
| } |
| sysImgDir = new File(sysImgDir, abiType); |
| |
| makeFakeSysImgInternal(sysImgDir, tagId, abiType, null, null); |
| return sysImgDir; |
| } |
| |
| //---- |
| |
| private void createTextFile(File dir, String filepath, String... lines) throws IOException { |
| File file = new File(dir, filepath); |
| |
| File parent = file.getParentFile(); |
| if (!parent.isDirectory()) { |
| parent.mkdirs(); |
| } |
| |
| if (!file.isFile()) { |
| assertTrue(file.createNewFile()); |
| } |
| if (lines != null && lines.length > 0) { |
| FileWriter out = new FileWriter(file); |
| for (String line : lines) { |
| out.write(line); |
| } |
| out.close(); |
| } |
| } |
| |
| /** |
| * Utility used by {@link #makeFakeSdk()} to create a fake target with API 0, rev 0. |
| */ |
| private File makeFakeTargetInternal(File platformsDir) throws IOException { |
| File targetDir = new File(platformsDir, TARGET_DIR_NAME_0); |
| targetDir.mkdirs(); |
| new File(targetDir, SdkConstants.FN_FRAMEWORK_LIBRARY).createNewFile(); |
| new File(targetDir, SdkConstants.FN_FRAMEWORK_AIDL).createNewFile(); |
| |
| createSourceProps(targetDir, |
| PkgProps.PKG_REVISION, "1", |
| PkgProps.PLATFORM_VERSION, "0.0", |
| PkgProps.VERSION_API_LEVEL, "0", |
| PkgProps.LAYOUTLIB_API, "5", |
| PkgProps.LAYOUTLIB_REV, "2"); |
| |
| createFileProps(SdkConstants.FN_BUILD_PROP, targetDir, |
| LocalPlatformPkgInfo.PROP_VERSION_RELEASE, "0.0", |
| LocalPlatformPkgInfo.PROP_VERSION_SDK, "0", |
| LocalPlatformPkgInfo.PROP_VERSION_CODENAME, "REL"); |
| |
| return targetDir; |
| } |
| |
| /** |
| * Utility to create a fake *legacy* sys image in a platform folder. Legacy system images follow |
| * that path pattern: $SDK/platforms/platform-N/images/userdata.img |
| * |
| * They have no source.properties file in that directory. |
| */ |
| private void makeFakeLegacySysImg( |
| @NonNull File platformDir, |
| @NonNull String abiType) throws IOException { |
| File imagesDir = new File(platformDir, "images"); |
| imagesDir.mkdirs(); |
| new File(imagesDir, "userdata.img").createNewFile(); |
| } |
| |
| /** |
| * Utility to create a fake sys image in the system-images folder. |
| * |
| * "modern" (as in "not legacy") system-images follow that path pattern: |
| * $SDK/system-images/platform-N/abi/source.properties $SDK/system-images/platform-N/abi/userdata.img |
| * or $SDK/system-images/platform-N/tag/abi/source.properties $SDK/system-images/platform-N/tag/abi/userdata.img |
| * |
| * The tag id is optional and was only introduced in API 20 / Tools 22.6. The platform-N and the |
| * tag folder names are irrelevant as the info from source.properties matters most. |
| */ |
| private void makeFakeSysImgInternal( |
| @NonNull File sysImgDir, |
| @Nullable String tagId, |
| @NonNull String abiType, |
| @Nullable String deviceId, |
| @Nullable String deviceMfg) throws Exception { |
| sysImgDir.mkdirs(); |
| new File(sysImgDir, "userdata.img").createNewFile(); |
| |
| if (tagId == null) { |
| createSourceProps(sysImgDir, |
| PkgProps.PKG_REVISION, "0", |
| PkgProps.VERSION_API_LEVEL, "0", |
| PkgProps.SYS_IMG_ABI, abiType); |
| } else { |
| String tagDisplay = LocalSysImgPkgInfo.tagIdToDisplay(tagId); |
| createSourceProps(sysImgDir, |
| PkgProps.PKG_REVISION, "0", |
| PkgProps.VERSION_API_LEVEL, "0", |
| PkgProps.SYS_IMG_TAG_ID, tagId, |
| PkgProps.SYS_IMG_TAG_DISPLAY, tagDisplay, |
| PkgProps.SYS_IMG_ABI, abiType, |
| PkgProps.PKG_LIST_DISPLAY, |
| "Sys-Img v0 for (" + tagDisplay + ", " + abiType + ")"); |
| |
| // create a devices.xml file |
| List<Device> devices = new ArrayList<Device>(); |
| Builder b = new Device.Builder(); |
| b.setName("Mock " + tagDisplay + " Device Name"); |
| b.setId(deviceId == null ? "MockDevice-" + tagId : deviceId); |
| b.setManufacturer(deviceMfg == null ? "Mock " + tagDisplay + " OEM" : deviceMfg); |
| |
| Software sw = new Software(); |
| sw.setGlVersion("4.2"); |
| sw.setLiveWallpaperSupport(false); |
| sw.setMaxSdkLevel(42); |
| sw.setMinSdkLevel(1); |
| sw.setStatusBar(true); |
| |
| Screen sc = new Screen(); |
| sc.setDiagonalLength(7); |
| sc.setMechanism(TouchScreen.FINGER); |
| sc.setMultitouch(Multitouch.JAZZ_HANDS); |
| sc.setPixelDensity(Density.HIGH); |
| sc.setRatio(ScreenRatio.NOTLONG); |
| sc.setScreenType(ScreenType.CAPACITIVE); |
| sc.setSize(ScreenSize.LARGE); |
| sc.setXDimension(5); |
| sc.setXdpi(100); |
| sc.setYDimension(4); |
| sc.setYdpi(100); |
| |
| Hardware hw = new Hardware(); |
| hw.setButtonType(ButtonType.SOFT); |
| hw.setChargeType(PowerType.BATTERY); |
| hw.setCpu(abiType); |
| hw.setGpu("pixelpushing"); |
| hw.setHasMic(true); |
| hw.setKeyboard(Keyboard.QWERTY); |
| hw.setNav(Navigation.NONAV); |
| hw.setRam(new Storage(512, Unit.MiB)); |
| hw.setScreen(sc); |
| |
| State st = new State(); |
| st.setName("portrait"); |
| st.setDescription("Portrait"); |
| st.setDefaultState(true); |
| st.setOrientation(ScreenOrientation.PORTRAIT); |
| st.setKeyState(KeyboardState.SOFT); |
| st.setNavState(NavigationState.HIDDEN); |
| st.setHardware(hw); |
| |
| b.addSoftware(sw); |
| b.addState(st); |
| |
| devices.add(b.build()); |
| |
| File f = new File(sysImgDir, "devices.xml"); |
| FileOutputStream fos = new FileOutputStream(f); |
| DeviceWriter.writeToXml(fos, devices); |
| fos.close(); |
| } |
| } |
| |
| /** |
| * Utility to make a fake skin for the given target |
| */ |
| protected void makeFakeSkin(File targetDir, String skinName) throws IOException { |
| File skinFolder = FileOp.append(targetDir, "skins", skinName); |
| skinFolder.mkdirs(); |
| |
| // To be detected properly, the skin folder should have a "layout" file. |
| // Its content is however not parsed. |
| FileWriter out = new FileWriter(new File(skinFolder, "layout")); |
| out.write("parts {\n}\n"); |
| out.close(); |
| } |
| |
| /** |
| * Utility to create a fake source with a few files in the given sdk folder. |
| */ |
| private void makeFakeSourceInternal(File sdkDir) throws IOException { |
| File sourcesDir = FileOp.append(sdkDir, SdkConstants.FD_PKG_SOURCES, "android-0"); |
| sourcesDir.mkdirs(); |
| |
| createSourceProps(sourcesDir, PkgProps.VERSION_API_LEVEL, "0"); |
| |
| File dir1 = FileOp.append(sourcesDir, "src", "com", "android"); |
| dir1.mkdirs(); |
| FileOp.append(dir1, "File1.java").createNewFile(); |
| FileOp.append(dir1, "File2.java").createNewFile(); |
| |
| FileOp.append(sourcesDir, "res", "values").mkdirs(); |
| FileOp.append(sourcesDir, "res", "values", "styles.xml").createNewFile(); |
| } |
| |
| private void makePlatformTools(File platformToolsDir) throws IOException { |
| platformToolsDir.mkdir(); |
| createSourceProps(platformToolsDir, PkgProps.PKG_REVISION, "17.1.2"); |
| |
| // platform-tools revision >= 17 requires only an adb file to be valid. |
| new File(platformToolsDir, SdkConstants.FN_ADB).createNewFile(); |
| } |
| |
| private void makeBuildTools(File sdkDir) throws IOException { |
| for (String revision : new String[]{"3.0.0", "3.0.1", "18.3.4 rc5"}) { |
| createFakeBuildTools(sdkDir, "ANY", revision); |
| } |
| } |
| |
| /** |
| * Adds a new fake build tools to the SDK In the given SDK/build-tools folder. |
| * |
| * @param sdkDir The SDK top folder. Must already exist. |
| * @param os The OS. One of HostOs#toString() or "ANY". |
| * @param revision The "x.y.z rc r" revision number from {@link FullRevision#toShortString()}. |
| */ |
| protected void createFakeBuildTools(File sdkDir, String os, String revision) |
| throws IOException { |
| File buildToolsTopDir = new File(sdkDir, SdkConstants.FD_BUILD_TOOLS); |
| buildToolsTopDir.mkdir(); |
| File buildToolsDir = new File(buildToolsTopDir, revision); |
| createSourceProps(buildToolsDir, |
| PkgProps.PKG_REVISION, revision, |
| "Archive.Os", os); |
| |
| FullRevision fullRevision = FullRevision.parseRevision(revision); |
| |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.AAPT, SdkConstants.FN_AAPT); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.AIDL, SdkConstants.FN_AIDL); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.DX, SdkConstants.FN_DX); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.DX_JAR, SdkConstants.FD_LIB + File.separator + |
| SdkConstants.FN_DX_JAR); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.LLVM_RS_CC, SdkConstants.FN_RENDERSCRIPT); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.ANDROID_RS, SdkConstants.OS_FRAMEWORK_RS + File.separator + |
| "placeholder.txt"); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.ANDROID_RS_CLANG, |
| SdkConstants.OS_FRAMEWORK_RS_CLANG + File.separator + |
| "placeholder.txt"); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.BCC_COMPAT, SdkConstants.FN_BCC_COMPAT); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.LD_ARM, SdkConstants.FN_LD_ARM); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.LD_MIPS, SdkConstants.FN_LD_MIPS); |
| createFakeBuildToolsFile( |
| buildToolsDir, fullRevision, |
| BuildToolInfo.PathId.LD_X86, SdkConstants.FN_LD_X86); |
| } |
| |
| private void createFakeBuildToolsFile(@NonNull File dir, |
| @NonNull FullRevision buildToolsRevision, |
| @NonNull BuildToolInfo.PathId pathId, |
| @NonNull String filepath) |
| throws IOException { |
| |
| if (pathId.isPresentIn(buildToolsRevision)) { |
| createTextFile(dir, filepath); |
| } |
| } |
| |
| |
| protected void createSourceProps(File parentDir, String... paramValuePairs) throws IOException { |
| createFileProps(SdkConstants.FN_SOURCE_PROP, parentDir, paramValuePairs); |
| } |
| |
| protected void createFileProps(String fileName, File parentDir, String... paramValuePairs) |
| throws IOException { |
| File sourceProp = new File(parentDir, fileName); |
| parentDir = sourceProp.getParentFile(); |
| if (!parentDir.isDirectory()) { |
| assertTrue(parentDir.mkdirs()); |
| } |
| if (!sourceProp.isFile()) { |
| assertTrue(sourceProp.createNewFile()); |
| } |
| FileWriter out = new FileWriter(sourceProp); |
| int n = paramValuePairs.length; |
| assertTrue("paramValuePairs must have an even length, format [param=value]+", n % 2 == 0); |
| for (int i = 0; i < n; i += 2) { |
| out.write(paramValuePairs[i] + '=' + paramValuePairs[i + 1] + '\n'); |
| } |
| out.close(); |
| |
| } |
| |
| |
| /** |
| * Recursive delete directory. Mostly for fake SDKs. |
| * |
| * @param root directory to delete |
| */ |
| protected void deleteDir(File root) { |
| if (root.exists()) { |
| for (File file : root.listFiles()) { |
| if (file.isDirectory()) { |
| deleteDir(file); |
| } else { |
| file.delete(); |
| } |
| } |
| root.delete(); |
| } |
| } |
| |
| } |
