diff options
Diffstat (limited to 'src/plugins/android/src/com/motorola/studio/android/adt/SdkUtils.java')
| -rw-r--r-- | src/plugins/android/src/com/motorola/studio/android/adt/SdkUtils.java | 1006 |
1 files changed, 1006 insertions, 0 deletions
diff --git a/src/plugins/android/src/com/motorola/studio/android/adt/SdkUtils.java b/src/plugins/android/src/com/motorola/studio/android/adt/SdkUtils.java new file mode 100644 index 0000000..14836f3 --- /dev/null +++ b/src/plugins/android/src/com/motorola/studio/android/adt/SdkUtils.java @@ -0,0 +1,1006 @@ +/* + * Copyright (C) 2012 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.motorola.studio.android.adt; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FilenameFilter; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.osgi.util.NLS; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.PlatformUI; + +import com.android.ide.eclipse.adt.AdtPlugin; +import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; +import com.android.ide.eclipse.adt.internal.sdk.Sdk; +import com.android.sdklib.AndroidVersion; +import com.android.sdklib.IAndroidTarget; +import com.android.sdklib.ISdkLog; +import com.android.sdklib.NullSdkLog; +import com.android.sdklib.SdkConstants; +import com.android.sdklib.internal.avd.AvdInfo; +import com.android.sdklib.internal.avd.AvdManager; +import com.android.sdkuilib.internal.widgets.MessageBoxLog; +import com.motorola.studio.android.AndroidPlugin; +import com.motorola.studio.android.common.IAndroidConstants; +import com.motorola.studio.android.common.exception.AndroidException; +import com.motorola.studio.android.common.log.StudioLogger; +import com.motorola.studio.android.common.utilities.FileUtil; +import com.motorola.studio.android.i18n.AndroidNLS; +import com.motorola.studio.android.manifest.AndroidProjectManifestFile; +import com.motorola.studio.android.model.manifest.AndroidManifestFile; +import com.motorola.studio.android.model.manifest.dom.AndroidManifestNode; +import com.motorola.studio.android.model.manifest.dom.UsesSDKNode; + +/** + * DESCRIPTION: This class provides utility methods related to + * the Android SDK. + * <br> + * USAGE: See public methods + */ + +public class SdkUtils +{ + public static final int API_LEVEL_FOR_PLATFORM_VERSION_3_0_0 = 11; + + public static final String VM_CONFIG_FILENAME = "config.ini"; //$NON-NLS-1$ + + public static final String USERIMAGE_FILENAME = "userdata-qemu.img"; //$NON-NLS-1$ + + public static final String[] STATEDATA_FILENAMES = + { + "cache.img", "userdata.img", "emulator-user.ini" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + }; + + public static final String EMU_CONFIG_SKIN_NAME_PROPERTY = "skin.name"; //$NON-NLS-1$ + + /** + * Gets the current SDK object + */ + public static Sdk getCurrentSdk() + { + return Sdk.getCurrent(); + } + + /** + * Gets the directory where the configured SDK is located + */ + public static String getSdkPath() + { + String sdkDir = null; + Sdk sdk = getCurrentSdk(); + if (sdk != null) + { + sdkDir = sdk.getSdkLocation(); + } + return sdkDir; + } + + /** + * Gets the path to the "tools" folder of the SDK + * @return + */ + public static String getSdkToolsPath() + { + return AdtPlugin.getOsSdkToolsFolder(); + } + + public static IAndroidTarget getTargetByAPILevel(Integer apiLevel) + { + IAndroidTarget returnTarget = null; + + for (IAndroidTarget target : getAllTargets()) + { + if (target.getVersion().getApiLevel() == apiLevel) + { + returnTarget = target; + } + } + return returnTarget; + } + + /** + * Get the AAPT application path from an android target + * if null is passed, try to get some aapt + * @param target + * @return + */ + public static String getTargetAAPTPath(IAndroidTarget target) + { + IAndroidTarget realTarget = null; + if (target == null) + { + StudioLogger.warn(SdkUtils.class, "Trying to find a suitable aapt application to use"); //$NON-NLS-1$ + IAndroidTarget[] allTargets = Sdk.getCurrent().getTargets(); + if (allTargets.length > 0) + { + realTarget = allTargets[0]; + } + } + else + { + realTarget = target; + } + + while ((realTarget != null) && !realTarget.isPlatform()) + { + realTarget = realTarget.getParent(); + } + + if (realTarget == null) + { + StudioLogger.warn(SdkUtils.class, + "No aapt executable found: do you have an Android platform installed?"); //$NON-NLS-1$ + } + + return realTarget != null ? realTarget.getPath(IAndroidTarget.AAPT) : null; + } + + /** + * Gets the path to the "adb" executable of the SDK + * @return + */ + public static String getAdbPath() + { + return AdtPlugin.getOsAbsoluteAdb(); + } + + /** + * Reloads the recognized AVD list + */ + public static void reloadAvds() + { + + try + { + getVmManager().reloadAvds(NullSdkLog.getLogger()); + } + catch (Exception e) + { + StudioLogger.error(SdkUtils.class, "Error while reloading AVDs"); //$NON-NLS-1$ + } + + } + + /** + * Gets the VmManager object + */ + public static AvdManager getVmManager() + { + AvdManager vmManager = null; + Sdk sdk = getCurrentSdk(); + if (sdk != null) + { + vmManager = sdk.getAvdManager(); + } + + return vmManager; + } + + /** + * Gets all available Targets + */ + public static IAndroidTarget[] getAllTargets() + { + IAndroidTarget[] allTargets = null; + Sdk sdk = getCurrentSdk(); + if (sdk != null) + { + allTargets = sdk.getTargets(); + } + return allTargets; + } + + /** + * Gets a Target by name + * + * @param name the target name + */ + public static IAndroidTarget getTargetByName(String name) + { + IAndroidTarget ret = null; + + if ((name != null) && (name.length() > 0)) + { + IAndroidTarget[] allTargets = getAllTargets(); + + for (int i = 0; i < allTargets.length; i++) + { + if (name.equals(allTargets[i].getName())) + { + ret = allTargets[i]; + break; + } + } + } + + return ret; + } + + /** + * Gets all VMs + */ + public static AvdInfo[] getAllVms() + { + AvdInfo[] allVmInfo = null; + AvdManager vmManager = getVmManager(); + if (vmManager != null) + { + allVmInfo = vmManager.getAllAvds(); + } + return allVmInfo; + } + + /** + * Gets all valid VMs + */ + public static AvdInfo[] getAllValidVms() + { + AvdInfo[] validVmInfo = null; + AvdManager vmManager = getVmManager(); + if (vmManager != null) + { + validVmInfo = vmManager.getValidAvds(); + } + return validVmInfo; + } + + /** + * Gets the name of all VMs that are recognized by the configured SDK. + */ + public static Collection<String> getAllVmNames() + { + Collection<String> vmNames = new LinkedList<String>(); + for (AvdInfo vm : getAllVms()) + { + vmNames.add(vm.getName()); + } + return vmNames; + } + + /** + * Gets the name of all VMs that are recognized by the configured SDK. + */ + public static Collection<String> getAllValidVmNames() + { + Collection<String> vmNames = new LinkedList<String>(); + AvdInfo[] allAvds = getAllValidVms(); + if (allAvds != null) + { + for (AvdInfo vm : allAvds) + { + vmNames.add(vm.getName()); + } + } + + return vmNames; + } + + /** + * Gets a skin name + * + * @param vmInfo the VM to get the skin + */ + public static String getSkin(AvdInfo vmInfo) + { + String skin = ""; //$NON-NLS-1$ + File configFile = vmInfo.getConfigFile(); + Properties p = new Properties(); + InputStream configFileStream = null; + try + { + configFileStream = new FileInputStream(configFile); + p.load(configFileStream); + skin = p.getProperty(EMU_CONFIG_SKIN_NAME_PROPERTY); + } + catch (FileNotFoundException e) + { + StudioLogger + .error(SdkUtils.class, + "Error getting VM skin definition. Could not find file " + configFile.getAbsolutePath(), e); //$NON-NLS-1$ + } + catch (IOException e) + { + StudioLogger + .error(SdkUtils.class, + "Error getting VM skin definition. Could not access file " + configFile.getAbsolutePath(), e); //$NON-NLS-1$ + } + finally + { + if (configFileStream != null) + { + try + { + configFileStream.close(); + } + catch (IOException e) + { + //nothing to do + } + } + } + + return skin; + } + + /** + * Gets a VM by name. + * + * @param vmName The VM name + */ + public static AvdInfo getValidVm(String vmName) + { + AvdInfo vmInfo = null; + AvdManager vmManager = getVmManager(); + if (vmManager != null) + { + vmInfo = vmManager.getAvd(vmName, true); + } + return vmInfo; + } + + /** + * Gets a VM by name. + * + * @param vmName The VM name + */ + public static AvdInfo getVm(String vmName) + { + AvdInfo vmInfo = null; + AvdManager vmManager = getVmManager(); + if (vmManager != null) + { + vmInfo = vmManager.getAvd(vmName, false); + } + return vmInfo; + } + + /** + * Creates a new VM instance. + * + * @param folder Folder where the VM files will be stored + * @param name VM Name + * @param target VM Target represented by the IAndroidTarget object + * @param skinName VM Skin name from the VM Target + * + * @throws CoreException + */ + public static AvdInfo createVm(String folder, String name, IAndroidTarget target, + String abiType, String skinName, String useSnapshot, String sdCard) + throws CoreException + + { + AvdInfo vmInfo; + AvdManager vmManager = SdkUtils.getVmManager(); + + // get the abi type + if (abiType == null) + { + abiType = SdkConstants.ABI_ARMEABI; + } + + /* + * public VmInfo createVm(String parentFolder, String name, IAndroidTarget target, + * String skinName, String sdcard, Map hardwareConfig) + */ + vmInfo = + vmManager.createAvd(new File(folder), name, target, abiType, skinName, sdCard, + null, Boolean.parseBoolean(useSnapshot), true, false, + NullSdkLog.getLogger()); + + if (vmInfo == null) + { + String errMsg = NLS.bind(AndroidNLS.EXC_SdkUtils_CannotCreateTheVMInstance, name); + + IStatus status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, errMsg); + throw new CoreException(status); + } + + return vmInfo; + } + + /** + * Deletes a VM instance. + * + * @param name VM Name + */ + public static void deleteVm(String name) + { + + AvdManager vmManager = SdkUtils.getVmManager(); + AvdInfo avdToDelete = vmManager != null ? vmManager.getAvd(name, false) : null; + if (avdToDelete != null) + { + try + { + if ((avdToDelete.getIniFile() != null) && avdToDelete.getIniFile().exists()) + { + avdToDelete.getIniFile().delete(); + } + String path = avdToDelete.getDataFolderPath(); + if (path != null) + { + File avdDir = new File(path); + if (avdDir.exists()) + { + FileUtil.deleteDirRecursively(avdDir); + } + } + vmManager.removeAvd(avdToDelete); + + } + catch (Exception e) + { + StudioLogger.error("Could not delete AVD: " + e.getMessage()); //$NON-NLS-1$ + } + } + + } + + /** + * Get the reference to the File that points to the filesystem location of the directory + * where the user data files of the VM with the given name are stored. + * @param vmName name of the VM whose userdata directory is to be retrieved. + * @return the File object that references the filesystem location of the directory where + * the userdata files of the given VM will be stored. Returns a null reference if SDK is not configured + * or if there is no VM with the given name. + */ + public static File getUserdataDir(String vmName) + { + AvdInfo vminfo = SdkUtils.getValidVm(vmName); + File userdataDir = null; + + if (vminfo != null) + { + String vmpath = vminfo.getDataFolderPath(); + userdataDir = new File(vmpath); + } + + return userdataDir; + } + + /** + * Get the reference to the File that points to the filesystem location where the + * user data file of the VM with the given name is. + * + * @param vmName name of the VM whose userdata file is to be retrieved. + * @return the File object that references the filesystem location where the userdata + * of the given VM should be. Returns a null reference if SDK is not configured + * or if there is no VM with the given name. + */ + public static File getUserdataFile(String vmName) + { + File userdataDir = getUserdataDir(vmName); + File userdataFile = null; + + if (userdataDir != null) + { + userdataFile = new File(userdataDir, USERIMAGE_FILENAME); + } + + return userdataFile; + } + + /** + * Get the reference to the Files that point to the filesystem location where the + * state data files of the VM with the given name are. + * + * @param vmName name of the VM whose state data files is to be retrieved. + * @return the File objects that reference the filesystem location where the state data + * files of the given VM should be. Returns a null reference if SDK is not configured + * or if there is no VM with the given name. + */ + public static List<File> getStateDataFiles(String vmName) + { + File userdataDir = getUserdataDir(vmName); + List<File> stateDataFiles = null; + + if (userdataDir != null) + { + stateDataFiles = new ArrayList<File>(); + + for (int i = 0; i < STATEDATA_FILENAMES.length; i++) + { + stateDataFiles.add(new File(userdataDir, STATEDATA_FILENAMES[i])); + } + } + + return stateDataFiles; + } + + /** + * Retrieves all sample applications from a target + * + * @param target The target + * @return all sample applications from a target + */ + public static Object[] getSamples(IAndroidTarget target) + { + List<Sample> samples = new ArrayList<Sample>(); + File samplesFolder = new File(target.getPath(IAndroidTarget.SAMPLES)); + samples = findSamples(samplesFolder, target); + return samples.toArray(); + } + + /** + * Find the samples inside an specific directory (recursively) + * + * @param folder the folder that can contain samples + * @param target the target of the samples in the folder + * @return a list of samples + */ + private static List<Sample> findSamples(File folder, IAndroidTarget target) + { + + List<Sample> samples = new ArrayList<Sample>(); + + if (folder.exists() && folder.isDirectory()) + { + for (File sampleFolder : folder.listFiles()) + { + if (sampleFolder.isDirectory()) + { + if (Sample.isSample(sampleFolder)) + { + samples.add(new Sample(sampleFolder, target)); + } + else + { + samples.addAll(findSamples(sampleFolder, target)); + } + } + } + } + + return samples; + } + + /** + * Retrieves all targets for a given SDK + * + * @param sdk The sdk + * + * @return all targets for the given SDK + */ + public static Object[] getTargets(Sdk sdk) + { + Object[] targets = null; + if (sdk != null) + { + targets = sdk.getTargets(); + } + return targets; + } + + /** + * Associates a project to a target + * + * @param project The project + * @param target The target + */ + public static void associate(IProject project, IAndroidTarget target) + { + try + { + Sdk.getCurrent().initProject(project, target); + } + catch (Exception e) + { + StudioLogger.error(SdkUtils.class, "Error associating project " + project.getName() //$NON-NLS-1$ + + " with target " + target.getName()); //$NON-NLS-1$ + } + } + + /** + * Retrieves the target for a project + * + * @param project the project + * + * @return the target for the project + */ + public static IAndroidTarget getTarget(IProject project) + { + IAndroidTarget target = null; + if (project != null) + { + target = Sdk.getCurrent().getTarget(project); + } + return target; + } + + /** + * Retrieves the target for a project + * + * @param project the project + * + * @return the target for the project + */ + public static String getMinSdkVersion(IProject project) + { + String minSdkVersion = ""; + try + { + AndroidManifestFile androidManifestFile = + AndroidProjectManifestFile.getFromProject(project); + UsesSDKNode usesSdkNode = + (UsesSDKNode) androidManifestFile.getNode(AndroidManifestNode.NodeType.UsesSdk); + if (usesSdkNode != null) + { + minSdkVersion = usesSdkNode.getMinSdkVersion(); + } + + } + catch (AndroidException e) + { + StudioLogger.error("Error getting min sdk version. " + e.getMessage()); + } + catch (CoreException e) + { + StudioLogger.error("Error getting min sdk version. " + e.getMessage()); + } + return minSdkVersion; + } + + /** + * Retrieves all Activity Actions for a project. + * + * @param project The project + * + * @return all Activity Actions for the project. + */ + public static String[] getActivityActions(IProject project) + { + String[] attributeValues = new String[0]; + + if ((project != null) && project.isOpen()) + { + IAndroidTarget target = SdkUtils.getTarget(project); + AndroidTargetData targetData = Sdk.getCurrent().getTargetData(target); + + if (targetData != null) + { + attributeValues = + targetData.getAttributeValues("action", "android:name", "activity"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + } + + return attributeValues; + } + + /** + * Retrieves all Service Actions for a project. + * + * @param project The project + * + * @return all Service Actions for the project. + */ + public static String[] getServiceActions(IProject project) + { + String[] attributeValues = new String[0]; + + if ((project != null) && project.isOpen()) + { + IAndroidTarget target = SdkUtils.getTarget(project); + AndroidTargetData targetData = Sdk.getCurrent().getTargetData(target); + + if (targetData != null) + { + attributeValues = + targetData.getAttributeValues("action", "android:name", "service"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + } + + return attributeValues; + } + + /** + * Retrieves all Broadcast Receiver Actions for a project. + * + * @param project The project + * + * @return all Broadcast Receiver Actions for the project. + */ + public static String[] getReceiverActions(IProject project) + { + String[] attributeValues = new String[0]; + + if ((project != null) && project.isOpen()) + { + IAndroidTarget target = SdkUtils.getTarget(project); + AndroidTargetData targetData = Sdk.getCurrent().getTargetData(target); + + if (targetData != null) + { + attributeValues = + targetData.getAttributeValues("action", "android:name", "receiver"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + } + + return attributeValues; + } + + /** + * Retrieves all Intent Filter Actions for a project. + * + * @param project The project + * + * @return all Intent Filter Actions for the project. + */ + public static String[] getIntentFilterCategories(IProject project) + { + String[] attributeValues = new String[0]; + + if ((project != null) && project.isOpen()) + { + IAndroidTarget target = SdkUtils.getTarget(project); + AndroidTargetData targetData = Sdk.getCurrent().getTargetData(target); + + if (targetData != null) + { + attributeValues = targetData.getAttributeValues("category", "android:name"); //$NON-NLS-1$ //$NON-NLS-2$ + } + } + + return attributeValues; + } + + /** + * Get the api version number for a given project + * @param project: the project + * @return the api version number or 0 if some error occurs + */ + public static int getApiVersionNumberForProject(IProject project) + { + int api = 0; + IAndroidTarget target = SdkUtils.getTarget(project); + if (target != null) + { + AndroidVersion version = target.getVersion(); + if (version != null) + { + api = version.getApiLevel(); + } + } + return api; + } + + public static String getTargetNameForProject(IProject project) + { + IAndroidTarget target = getTarget(project); + return target != null ? target.getName() : ""; //$NON-NLS-1$ + } + + public static boolean isPlatformTarget(String avdName) + { + IAndroidTarget target = getValidVm(avdName).getTarget(); + return target != null ? target.isPlatform() : false; + } + + public static boolean isProjectTargetAPlatform(IProject project) + { + IAndroidTarget target = getTarget(project); + return target != null ? target.isPlatform() : false; + } + + public static boolean isPlatformTarget(IAndroidTarget target) + { + return target != null ? target.isPlatform() : false; + } + + /** + * Retrieves the APK configurations of a project + * + * @param project the project + * @return the APK configurations + */ + public static Map<String, String> getAPKConfigurationsForProject(IProject project) + { + + Map<String, String> apkConfigurations = null; + + if ((project != null) && project.isOpen()) + { + Sdk.getCurrent(); + //This is not supported on ADT 14 preview so let's comment it for now. + // apkConfigurations = Sdk.getProjectState(project).getApkSettings().getLocaleFilters(); + apkConfigurations = new HashMap<String, String>(0); + } + + return apkConfigurations; + + } + + public static String getBaseTarget(String name) + { + IAndroidTarget target = getValidVm(name).getTarget(); + while (!target.isPlatform()) + { + target = target.getParent(); + } + return target.getName(); + } + + /** + * Check if an SDK is an OPhone Sdk + * @return + */ + public static boolean isOphoneSDK() + { + boolean result = false; + + // check if the folder contains the oms jar + FilenameFilter omsFilenameFilter = new FilenameFilter() + { + public boolean accept(File arg0, String arg1) + { + return arg1.equals(IAndroidConstants.OPHONE_JAR); + } + }; + + Sdk sdk = getCurrentSdk(); + IAndroidTarget[] targets = sdk.getTargets(); + for (IAndroidTarget target : targets) + { + File folder = new File(target.getLocation()); + if (folder.list(omsFilenameFilter).length > 0) + { + result = true; + break; + } + } + + return result; + } + + /** + * Check if an SDK is an JIL sdk + * @return + */ + public static boolean isJILSdk() + { + boolean result = false; + + // check if the folder contains the oms jar + FilenameFilter jilFilenameFilter = new FilenameFilter() + { + + public boolean accept(File arg0, String arg1) + { + return arg1.equals(IAndroidConstants.JIL_JAR); + } + }; + + Sdk sdk = getCurrentSdk(); + if (sdk != null) + { + IAndroidTarget[] targets = sdk.getTargets(); + for (IAndroidTarget target : targets) + { + File folder = new File(target.getLocation()); + if (folder.list(jilFilenameFilter).length > 0) + { + result = true; + break; + } + } + } + + return result; + } + + public static String getEmulatorWindowName(String avdName, int port) + { + String windowName = ""; //$NON-NLS-1$ + if (isJILSdk()) + { + windowName = "JIL Emulator (" + avdName + ":" + port + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + else if (isOphoneSDK()) + { + windowName = "OPhone Emulator (" + avdName + ":" + port + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + else + { + windowName = port + ":" + avdName; //$NON-NLS-1$ + } + return windowName; + } + + public static boolean isLibraryProject(IProject project) + { + return Sdk.getProjectState(project) != null ? Sdk.getProjectState(project).isLibrary() + : false; + } + + /** + * Returns all available permissions + * + * @return String array containing the available permissions + */ + public static String[] getIntentFilterPermissions(IProject project) + { + String[] attributeValues = new String[0]; + + if ((project != null) && project.isOpen()) + { + IAndroidTarget target = SdkUtils.getTarget(project); + AndroidTargetData targetData = Sdk.getCurrent().getTargetData(target); + + if (targetData != null) + { + attributeValues = targetData.getAttributeValues("uses-permission", "android:name"); //$NON-NLS-1$ //$NON-NLS-2$ + } + } + + return attributeValues; + } + + /** + * Try to repair an AVD. Currently only avds with wrong image path are repariable. + * Display a message with the changes to the config.ini + * @param avdInfo + * @return Status ERROR if an IO exception occured. + */ + public static IStatus repairAvd(AvdInfo avdInfo) + { + IStatus status = Status.OK_STATUS; + + AvdManager avdManager = Sdk.getCurrent().getAvdManager(); + Display display = PlatformUI.getWorkbench().getDisplay(); + ISdkLog log = + new MessageBoxLog(String.format("Result of updating AVD '%s':", avdInfo.getName()), //$NON-NLS-1$ + display, false); + try + { + avdManager.updateAvd(avdInfo, log); + // display the result + if (log instanceof MessageBoxLog) + { + ((MessageBoxLog) log).displayResult(true); + } + SdkUtils.reloadAvds(); + + } + catch (IOException e) + { + status = + new Status(Status.ERROR, AndroidPlugin.PLUGIN_ID, + AndroidNLS.SdkUtils_COULD_NOT_REPAIR_AVD, e); + } + + return status; + } + + public static String getDefaultSkin(String targetName) + { + IAndroidTarget target = getTargetByName(targetName); + return target != null ? target.getDefaultSkin() : "HVGA"; + } +} |