| /* |
| * Copyright (C) 2013 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.repository.local; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.sdklib.AndroidVersion; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.ISystemImage; |
| import com.android.sdklib.ISystemImage.LocationType; |
| import com.android.sdklib.SystemImage; |
| import com.android.sdklib.internal.androidTarget.AddOnTarget; |
| import com.android.sdklib.internal.androidTarget.PlatformTarget; |
| import com.android.sdklib.internal.project.ProjectProperties; |
| import com.android.sdklib.io.FileOp; |
| import com.android.sdklib.io.IFileOp; |
| import com.android.sdklib.repository.AddonManifestIniProps; |
| import com.android.sdklib.repository.FullRevision; |
| import com.android.sdklib.repository.MajorRevision; |
| import com.android.sdklib.repository.descriptors.*; |
| import com.android.utils.Pair; |
| import com.google.common.base.Objects; |
| import com.google.common.collect.SetMultimap; |
| import com.google.common.collect.TreeMultimap; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.util.*; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| @SuppressWarnings("MethodMayBeStatic") |
| public class LocalAddonPkgInfo extends LocalPlatformPkgInfo { |
| |
| private static final Pattern PATTERN_LIB_DATA = Pattern.compile( |
| "^([a-zA-Z0-9._-]+\\.jar);(.*)$", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$ |
| |
| // usb ids are 16-bit hexadecimal values. |
| private static final Pattern PATTERN_USB_IDS = Pattern.compile( |
| "^0x[a-f0-9]{4}$", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$ |
| |
| @NonNull |
| private final IPkgDescAddon mAddonDesc; |
| |
| public LocalAddonPkgInfo(@NonNull LocalSdk localSdk, |
| @NonNull File localDir, |
| @NonNull Properties sourceProps, |
| @NonNull AndroidVersion version, |
| @NonNull MajorRevision revision, |
| @NonNull IdDisplay vendor, |
| @NonNull IdDisplay name) { |
| super(localSdk, localDir, sourceProps, version, revision, FullRevision.NOT_SPECIFIED); |
| mAddonDesc = (IPkgDescAddon) PkgDesc.Builder.newAddon(version, revision, vendor, name) |
| .create(); |
| } |
| |
| @NonNull |
| @Override |
| public IPkgDesc getDesc() { |
| return mAddonDesc; |
| } |
| |
| /** The "path" of an add-on is its Target Hash. */ |
| @Override |
| @NonNull |
| public String getTargetHash() { |
| return getDesc().getPath(); |
| } |
| |
| //----- |
| |
| /** |
| * Computes a sanitized name-id based on an addon name-display. |
| * This is used to provide compatibility with older add-ons that lacks the new fields. |
| * |
| * @param displayName A name-display field or a old-style name field. |
| * @return A non-null sanitized name-id that fits in the {@code [a-zA-Z0-9_-]+} pattern. |
| */ |
| public static String sanitizeDisplayToNameId(@NonNull String displayName) { |
| String name = displayName.toLowerCase(Locale.US); |
| name = name.replaceAll("[^a-z0-9_-]+", "_"); //$NON-NLS-1$ //$NON-NLS-2$ |
| name = name.replaceAll("_+", "_"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| // Trim leading and trailing underscores |
| if (name.length() > 1) { |
| name = name.replaceAll("^_+", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| if (name.length() > 1) { |
| name = name.replaceAll("_+$", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| return name; |
| } |
| |
| //----- |
| |
| /** |
| * Creates the AddOnTarget. Invoked by {@link #getAndroidTarget()}. |
| */ |
| @Override |
| @Nullable |
| protected IAndroidTarget createAndroidTarget() { |
| LocalSdk sdk = getLocalSdk(); |
| IFileOp fileOp = sdk.getFileOp(); |
| |
| // Parse the addon properties to ensure we can load it. |
| Pair<Map<String, String>, String> infos = parseAddonProperties(); |
| |
| Map<String, String> propertyMap = infos.getFirst(); |
| String error = infos.getSecond(); |
| |
| if (error != null) { |
| appendLoadError("Ignoring add-on '%1$s': %2$s", getLocalDir().getName(), error); |
| return null; |
| } |
| |
| // Since error==null we're not supposed to encounter any issues loading this add-on. |
| try { |
| assert propertyMap != null; |
| |
| String api = propertyMap.get(AddonManifestIniProps.ADDON_API); |
| String name = propertyMap.get(AddonManifestIniProps.ADDON_NAME); |
| String vendor = propertyMap.get(AddonManifestIniProps.ADDON_VENDOR); |
| |
| assert api != null; |
| assert name != null; |
| assert vendor != null; |
| |
| PlatformTarget baseTarget = null; |
| |
| // Look for a platform that has a matching api level or codename. |
| LocalPkgInfo plat = sdk.getPkgInfo(PkgType.PKG_PLATFORM, |
| getDesc().getAndroidVersion()); |
| if (plat instanceof LocalPlatformPkgInfo) { |
| baseTarget = (PlatformTarget) ((LocalPlatformPkgInfo) plat).getAndroidTarget(); |
| } |
| assert baseTarget != null; |
| |
| // get the optional description |
| String description = propertyMap.get(AddonManifestIniProps.ADDON_DESCRIPTION); |
| |
| // get the add-on revision |
| int revisionValue = 1; |
| String revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION); |
| if (revision == null) { |
| revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION_OLD); |
| } |
| if (revision != null) { |
| revisionValue = Integer.parseInt(revision); |
| } |
| |
| // get the optional libraries |
| String librariesValue = propertyMap.get(AddonManifestIniProps.ADDON_LIBRARIES); |
| Map<String, String[]> libMap = null; |
| |
| if (librariesValue != null) { |
| librariesValue = librariesValue.trim(); |
| if (!librariesValue.isEmpty()) { |
| // split in the string into the libraries name |
| String[] libraries = librariesValue.split(";"); //$NON-NLS-1$ |
| if (libraries.length > 0) { |
| libMap = new HashMap<String, String[]>(); |
| for (String libName : libraries) { |
| libName = libName.trim(); |
| |
| // get the library data from the properties |
| String libData = propertyMap.get(libName); |
| |
| if (libData != null) { |
| // split the jar file from the description |
| Matcher m = PATTERN_LIB_DATA.matcher(libData); |
| if (m.matches()) { |
| libMap.put(libName, new String[] { |
| m.group(1), m.group(2) }); |
| } else { |
| appendLoadError( |
| "Ignoring library '%1$s', property value has wrong format\n\t%2$s", |
| libName, libData); |
| } |
| } else { |
| appendLoadError( |
| "Ignoring library '%1$s', missing property value", |
| libName, libData); |
| } |
| } |
| } |
| } |
| } |
| |
| // get the abi list. |
| ISystemImage[] systemImages = getAddonSystemImages(fileOp); |
| |
| // check whether the add-on provides its own rendering info/library. |
| boolean hasRenderingLibrary = false; |
| boolean hasRenderingResources = false; |
| |
| File dataFolder = new File(getLocalDir(), SdkConstants.FD_DATA); |
| if (fileOp.isDirectory(dataFolder)) { |
| hasRenderingLibrary = |
| fileOp.isFile(new File(dataFolder, SdkConstants.FN_LAYOUTLIB_JAR)); |
| hasRenderingResources = |
| fileOp.isDirectory(new File(dataFolder, SdkConstants.FD_RES)) && |
| fileOp.isDirectory(new File(dataFolder, SdkConstants.FD_FONTS)); |
| } |
| |
| AddOnTarget target = new AddOnTarget( |
| getLocalDir().getAbsolutePath(), |
| name, |
| vendor, |
| revisionValue, |
| description, |
| systemImages, |
| libMap, |
| hasRenderingLibrary, |
| hasRenderingResources, |
| baseTarget); |
| |
| // parse the legacy skins, located under SDK/addons/addon-name/skins/[skin-name] |
| // and merge with the system-image skins, if any, merging them by name. |
| File targetSkinFolder = target.getFile(IAndroidTarget.SKINS); |
| |
| Map<String, File> skinsMap = new TreeMap<String, File>(); |
| |
| for (File f : PackageParserUtils.parseSkinFolder(targetSkinFolder, fileOp)) { |
| skinsMap.put(f.getName().toLowerCase(Locale.US), f); |
| } |
| for (ISystemImage si : systemImages) { |
| for (File f : si.getSkins()) { |
| skinsMap.put(f.getName().toLowerCase(Locale.US), f); |
| } |
| } |
| |
| List<File> skins = new ArrayList<File>(skinsMap.values()); |
| Collections.sort(skins); |
| |
| // get the default skin |
| File defaultSkin = null; |
| String defaultSkinName = propertyMap.get(AddonManifestIniProps.ADDON_DEFAULT_SKIN); |
| if (defaultSkinName != null) { |
| defaultSkin = new File(targetSkinFolder, defaultSkinName); |
| } else { |
| // No default skin name specified, use the first one from the addon |
| // or the default from the platform. |
| if (skins.size() == 1) { |
| defaultSkin = skins.get(0); |
| } else { |
| defaultSkin = baseTarget.getDefaultSkin(); |
| } |
| } |
| |
| // get the USB ID (if available) |
| int usbVendorId = convertId(propertyMap.get(AddonManifestIniProps.ADDON_USB_VENDOR)); |
| if (usbVendorId != IAndroidTarget.NO_USB_ID) { |
| target.setUsbVendorId(usbVendorId); |
| } |
| |
| target.setSkins(skins.toArray(new File[skins.size()]), defaultSkin); |
| |
| return target; |
| |
| } catch (Exception e) { |
| appendLoadError("Ignoring add-on '%1$s': error %2$s.", |
| getLocalDir().getName(), e.toString()); |
| } |
| |
| return null; |
| |
| } |
| |
| /** |
| * Parses the add-on properties and decodes any error that occurs when loading an addon. |
| * |
| * @return A pair with the property map and an error string. Both can be null but not at the |
| * same time. If a non-null error is present then the property map must be ignored. The error |
| * should be translatable as it might show up in the SdkManager UI. |
| */ |
| @NonNull |
| private Pair<Map<String, String>, String> parseAddonProperties() { |
| Map<String, String> propertyMap = null; |
| String error = null; |
| |
| IFileOp fileOp = getLocalSdk().getFileOp(); |
| File addOnManifest = new File(getLocalDir(), SdkConstants.FN_MANIFEST_INI); |
| |
| do { |
| if (!fileOp.isFile(addOnManifest)) { |
| error = String.format("File not found: %1$s", SdkConstants.FN_MANIFEST_INI); |
| break; |
| } |
| |
| try { |
| propertyMap = ProjectProperties.parsePropertyStream( |
| fileOp.newFileInputStream(addOnManifest), |
| addOnManifest.getPath(), |
| null /*log*/); |
| if (propertyMap == null) { |
| error = String.format("Failed to parse properties from %1$s", |
| SdkConstants.FN_MANIFEST_INI); |
| break; |
| } |
| } catch (FileNotFoundException e) { |
| // this can happen if the system fails to open the file because of too many |
| // open files. |
| error = String.format("Failed to parse properties from %1$s: %2$s", |
| SdkConstants.FN_MANIFEST_INI, e.getMessage()); |
| break; |
| } |
| |
| // look for some specific values in the map. |
| // we require name, vendor, and api |
| String name = propertyMap.get(AddonManifestIniProps.ADDON_NAME); |
| if (name == null) { |
| error = addonManifestWarning(AddonManifestIniProps.ADDON_NAME); |
| break; |
| } |
| |
| String vendor = propertyMap.get(AddonManifestIniProps.ADDON_VENDOR); |
| if (vendor == null) { |
| error = addonManifestWarning(AddonManifestIniProps.ADDON_VENDOR); |
| break; |
| } |
| |
| String api = propertyMap.get(AddonManifestIniProps.ADDON_API); |
| if (api == null) { |
| error = addonManifestWarning(AddonManifestIniProps.ADDON_API); |
| break; |
| } |
| |
| // Look for a platform that has a matching api level or codename. |
| IAndroidTarget baseTarget = null; |
| LocalPkgInfo plat = getLocalSdk().getPkgInfo(PkgType.PKG_PLATFORM, |
| getDesc().getAndroidVersion()); |
| if (plat instanceof LocalPlatformPkgInfo) { |
| baseTarget = ((LocalPlatformPkgInfo) plat).getAndroidTarget(); |
| } |
| |
| if (baseTarget == null) { |
| error = String.format("Unable to find base platform with API level '%1$s'", api); |
| break; |
| } |
| |
| // get the add-on revision |
| String revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION); |
| if (revision == null) { |
| revision = propertyMap.get(AddonManifestIniProps.ADDON_REVISION_OLD); |
| } |
| if (revision != null) { |
| try { |
| Integer.parseInt(revision); |
| } catch (NumberFormatException e) { |
| // looks like revision does not parse to a number. |
| error = String.format("%1$s is not a valid number in %2$s.", |
| AddonManifestIniProps.ADDON_REVISION, SdkConstants.FN_BUILD_PROP); |
| break; |
| } |
| } |
| |
| } while(false); |
| |
| return Pair.of(propertyMap, error); |
| } |
| |
| /** |
| * Prepares a warning about the addon being ignored due to a missing manifest value. |
| * This string will show up in the SdkManager UI. |
| * |
| * @param valueName The missing manifest value, for display. |
| */ |
| @NonNull |
| private static String addonManifestWarning(@NonNull String valueName) { |
| return String.format("'%1$s' is missing from %2$s.", |
| valueName, SdkConstants.FN_MANIFEST_INI); |
| } |
| |
| /** |
| * Converts a string representation of an hexadecimal ID into an int. |
| * @param value the string to convert. |
| * @return the int value, or {@link IAndroidTarget#NO_USB_ID} if the conversion failed. |
| */ |
| private int convertId(@Nullable String value) { |
| if (value != null && !value.isEmpty()) { |
| if (PATTERN_USB_IDS.matcher(value).matches()) { |
| String v = value.substring(2); |
| try { |
| return Integer.parseInt(v, 16); |
| } catch (NumberFormatException e) { |
| // this shouldn't happen since we check the pattern above, but this is safer. |
| // the method will return 0 below. |
| } |
| } |
| } |
| |
| return IAndroidTarget.NO_USB_ID; |
| } |
| |
| /** |
| * Get all the system images supported by an add-on target. |
| * For an add-on, we first look in the new sdk/system-images folders then we look |
| * for sub-folders in the addon/images directory. |
| * If none are found but the directory exists and is not empty, assume it's a legacy |
| * arm eabi system image. |
| * If any given API appears twice or more, the first occurrence wins. |
| * <p/> |
| * Note that it's OK for an add-on to have no system-images at all, since it can always |
| * rely on the ones from its base platform. |
| * |
| * @param fileOp File operation wrapper. |
| * @return an array of ISystemImage containing all the system images for the target. |
| * The list can be empty but not null. |
| */ |
| @NonNull |
| private ISystemImage[] getAddonSystemImages(IFileOp fileOp) { |
| Set<ISystemImage> found = new TreeSet<ISystemImage>(); |
| SetMultimap<IdDisplay, String> tagToAbiFound = TreeMultimap.create(); |
| |
| |
| // Look in the system images folders: |
| // - SDK/system-image/platform/addon-id-tag/abi |
| // - SDK/system-image/addon-id-tag/abi (many abi possible) |
| // Optional: look for skins under |
| // - SDK/system-image/platform/addon-id-tag/abi/skins/skin-name |
| // - SDK/system-image/addon-id-tag/abi/skins/skin-name |
| // If we find multiple occurrences of the same platform/abi, the first one read wins. |
| |
| LocalPkgInfo[] sysImgInfos = getLocalSdk().getPkgsInfos(PkgType.PKG_ADDON_SYS_IMAGE); |
| for (LocalPkgInfo pkg : sysImgInfos) { |
| IPkgDesc d = pkg.getDesc(); |
| if (pkg instanceof LocalAddonSysImgPkgInfo && |
| d.hasVendor() && |
| mAddonDesc.getVendor().equals(d.getVendor()) && |
| mAddonDesc.getName().equals(d.getTag()) && |
| Objects.equal(mAddonDesc.getAndroidVersion(), pkg.getDesc().getAndroidVersion())) { |
| final IdDisplay tag = mAddonDesc.getName(); |
| final String abi = d.getPath(); |
| if (abi != null && !tagToAbiFound.containsEntry(tag, abi)) { |
| found.add(((LocalAddonSysImgPkgInfo)pkg).getSystemImage()); |
| tagToAbiFound.put(tag, abi); |
| } |
| } |
| } |
| |
| // Look for sub-directories: |
| // - SDK/addons/addon-name/images/abi (multiple abi possible) |
| // - SDK/addons/addon-name/armeabi (legacy support) |
| boolean useLegacy = true; |
| boolean hasImgFiles = false; |
| final IdDisplay defaultTag = SystemImage.DEFAULT_TAG; |
| |
| File imagesDir = new File(getLocalDir(), SdkConstants.OS_IMAGES_FOLDER); |
| File[] files = fileOp.listFiles(imagesDir); |
| for (File file : files) { |
| if (fileOp.isDirectory(file)) { |
| useLegacy = false; |
| String abi = file.getName(); |
| if (!tagToAbiFound.containsEntry(defaultTag, abi)) { |
| found.add(new SystemImage( |
| file, |
| LocationType.IN_IMAGES_SUBFOLDER, |
| SystemImage.DEFAULT_TAG, |
| mAddonDesc.getVendor(), |
| abi, |
| FileOp.EMPTY_FILE_ARRAY)); |
| tagToAbiFound.put(defaultTag, abi); |
| } |
| } else if (!hasImgFiles && fileOp.isFile(file)) { |
| if (file.getName().endsWith(".img")) { //$NON-NLS-1$ |
| // The legacy images folder is only valid if it contains some .img files |
| hasImgFiles = true; |
| } |
| } |
| } |
| |
| if (useLegacy && |
| hasImgFiles && |
| fileOp.isDirectory(imagesDir) && |
| !tagToAbiFound.containsEntry(defaultTag, SdkConstants.ABI_ARMEABI)) { |
| // We found no sub-folder system images but it looks like the top directory |
| // has some img files in it. It must be a legacy ARM EABI system image folder. |
| found.add(new SystemImage( |
| imagesDir, |
| LocationType.IN_LEGACY_FOLDER, |
| SystemImage.DEFAULT_TAG, |
| SdkConstants.ABI_ARMEABI, |
| FileOp.EMPTY_FILE_ARRAY)); |
| } |
| |
| return found.toArray(new ISystemImage[found.size()]); |
| } |
| } |
