Java tutorial
/* * Copyright (C) 2009 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.internal.repository.packages; import com.android.SdkConstants; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.annotations.VisibleForTesting; import com.android.annotations.VisibleForTesting.Visibility; import com.android.sdklib.AndroidVersion; import com.android.sdklib.SdkManager; import com.android.sdklib.repository.IDescription; import com.android.sdklib.repository.IListDescription; import com.android.sdklib.internal.repository.ITaskMonitor; import com.android.sdklib.internal.repository.archives.Archive; import com.android.sdklib.internal.repository.sources.SdkAddonSource; import com.android.sdklib.internal.repository.sources.SdkRepoSource; import com.android.sdklib.internal.repository.sources.SdkSource; import com.android.sdklib.io.IFileOp; import com.android.sdklib.repository.*; import com.android.sdklib.repository.descriptors.IPkgDesc; import com.android.sdklib.repository.descriptors.PkgDesc; import org.apache.commons.compress.archivers.zip.ZipArchiveEntry; import org.w3c.dom.Node; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Map; import java.util.Properties; /** * A {@link Package} is the base class for "something" that can be downloaded from * the SDK repository. * <p/> * A package has some attributes (revision, description) and a list of archives * which represent the downloadable bits. * <p/> * Packages are contained by a {@link SdkSource} (a download site). * <p/> * Derived classes must implement the {@link IDescription} methods. * * @deprecated * com.android.sdklib.internal.repository has moved into Studio as * com.android.tools.idea.sdk.remote.internal. */ @Deprecated public abstract class Package implements IDescription, IListDescription, Comparable<Package> { private final String mObsolete; private final License mLicense; private final String mListDisplay; private final String mDescription; private final String mDescUrl; @Deprecated private final String mReleaseNote; @Deprecated private final String mReleaseUrl; private final Archive[] mArchives; private final SdkSource mSource; // figure if we'll need to set the unix permissions private static final boolean sUsingUnixPerm = SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN || SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_LINUX; /** * Enum for the result of {@link Package#canBeUpdatedBy(Package)}. This used so that we can * differentiate between a package that is totally incompatible, and one that is the same item * but just not an update. * @see #canBeUpdatedBy(Package) */ public enum UpdateInfo { /** Means that the 2 packages are not the same thing */ INCOMPATIBLE, /** Means that the 2 packages are the same thing but one does not upgrade the other. * </p> * TODO: this name is confusing. We need to dig deeper. */ NOT_UPDATE, /** Means that the 2 packages are the same thing, and one is the upgrade of the other */ UPDATE } /** * Creates a new package from the attributes and elements of the given XML node. * This constructor should throw an exception if the package cannot be created. * * @param source The {@link SdkSource} where this is loaded from. * @param packageNode The XML element being parsed. * @param nsUri The namespace URI of the originating XML document, to be able to deal with * parameters that vary according to the originating XML schema. * @param licenses The licenses loaded from the XML originating document. */ Package(SdkSource source, Node packageNode, String nsUri, Map<String, String> licenses) { mSource = source; mListDisplay = PackageParserUtils.getXmlString(packageNode, SdkRepoConstants.NODE_LIST_DISPLAY); mDescription = PackageParserUtils.getXmlString(packageNode, SdkRepoConstants.NODE_DESCRIPTION); mDescUrl = PackageParserUtils.getXmlString(packageNode, SdkRepoConstants.NODE_DESC_URL); mReleaseNote = PackageParserUtils.getXmlString(packageNode, SdkRepoConstants.NODE_RELEASE_NOTE); mReleaseUrl = PackageParserUtils.getXmlString(packageNode, SdkRepoConstants.NODE_RELEASE_URL); mObsolete = PackageParserUtils.getOptionalXmlString(packageNode, SdkRepoConstants.NODE_OBSOLETE); mLicense = parseLicense(packageNode, licenses); mArchives = parseArchives(PackageParserUtils.findChildElement(packageNode, SdkRepoConstants.NODE_ARCHIVES)); } /** * Manually create a new package with one archive and the given attributes. * This is used to create packages from local directories in which case there must be * one archive which URL is the actual target location. * <p/> * Properties from props are used first when possible, e.g. if props is non null. * <p/> * By design, this creates a package with one and only one archive. */ public Package(SdkSource source, Properties props, int revision, String license, String description, String descUrl, String archiveOsPath) { if (description == null) { description = ""; } if (descUrl == null) { descUrl = ""; } license = getProperty(props, PkgProps.PKG_LICENSE, license); if (license != null) { mLicense = new License(license, getProperty(props, PkgProps.PKG_LICENSE_REF, null)); } else { mLicense = null; } mListDisplay = getProperty(props, PkgProps.PKG_LIST_DISPLAY, ""); //$NON-NLS-1$ mDescription = getProperty(props, PkgProps.PKG_DESC, description); mDescUrl = getProperty(props, PkgProps.PKG_DESC_URL, descUrl); mReleaseNote = getProperty(props, PkgProps.PKG_RELEASE_NOTE, ""); //$NON-NLS-1$ mReleaseUrl = getProperty(props, PkgProps.PKG_RELEASE_URL, ""); //$NON-NLS-1$ mObsolete = getProperty(props, PkgProps.PKG_OBSOLETE, null); // If source is null and we can find a source URL in the properties, generate // a dummy source just to store the URL. This allows us to easily remember where // a package comes from. String srcUrl = getProperty(props, PkgProps.PKG_SOURCE_URL, null); if (props != null && source == null && srcUrl != null) { // Both Addon and Extra packages can come from an addon source. // For Extras, we can tell by looking at the source URL. if (this instanceof AddonPackage || ((this instanceof ExtraPackage) && srcUrl.endsWith(SdkAddonConstants.URL_DEFAULT_FILENAME))) { source = new SdkAddonSource(srcUrl, null /*uiName*/); } else { source = new SdkRepoSource(srcUrl, null /*uiName*/); } } mSource = source; // Note: if archiveOsPath is non-null, this makes a local archive (e.g. a locally // installed package.) If it's null, this makes a remote archive. mArchives = initializeArchives(props, archiveOsPath); } /** * Returns the {@link IPkgDesc} describing this package's meta data. * * @return A non-null {@link IPkgDesc}. */ @NonNull public abstract IPkgDesc getPkgDesc(); /** * Called by the constructor to get the initial {@link #mArchives} array. * <p/> * This is invoked by the local-package constructor and allows mock testing * classes to override the archives created. * This is an <em>implementation</em> details and clients must <em>not</em> * rely on this. * * @return Always return a non-null array. The array may be empty. */ @VisibleForTesting(visibility = Visibility.PRIVATE) protected Archive[] initializeArchives(Properties props, String archiveOsPath) { return new Archive[] { new Archive(this, props, archiveOsPath) }; } /** * Utility method that returns a property from a {@link Properties} object. * Returns the default value if props is null or if the property is not defined. * * @param props The {@link Properties} to search into. * If null, the default value is returned. * @param propKey The name of the property. Must not be null. * @param defaultValue The default value to return if {@code props} is null or if the * key is not found. Can be null. * @return The string value of the given key in the properties, or null if the key * isn't found or if {@code props} is null. */ @Nullable static String getProperty(@Nullable Properties props, @NonNull String propKey, @Nullable String defaultValue) { return PackageParserUtils.getProperty(props, propKey, defaultValue); } /** * Utility method that returns an integer property from a {@link Properties} object. * Returns the default value if props is null or if the property is not defined or * cannot be parsed to an integer. * * @param props The {@link Properties} to search into. * If null, the default value is returned. * @param propKey The name of the property. Must not be null. * @param defaultValue The default value to return if {@code props} is null or if the * key is not found. Can be null. * @return The integer value of the given key in the properties, or the {@code defaultValue}. */ static int getPropertyInt(@Nullable Properties props, @NonNull String propKey, int defaultValue) { return PackageParserUtils.getPropertyInt(props, propKey, defaultValue); } /** * Save the properties of the current packages in the given {@link Properties} object. * These properties will later be give the constructor that takes a {@link Properties} object. */ public void saveProperties(@NonNull Properties props) { if (mLicense != null) { String license = mLicense.getLicense(); if (license != null && !license.isEmpty()) { props.setProperty(PkgProps.PKG_LICENSE, license); } String licenseRef = mLicense.getLicenseRef(); if (licenseRef != null && !licenseRef.isEmpty()) { props.setProperty(PkgProps.PKG_LICENSE_REF, licenseRef); } } if (mListDisplay != null && !mListDisplay.isEmpty()) { props.setProperty(PkgProps.PKG_LIST_DISPLAY, mListDisplay); } if (mDescription != null && !mDescription.isEmpty()) { props.setProperty(PkgProps.PKG_DESC, mDescription); } if (mDescUrl != null && !mDescUrl.isEmpty()) { props.setProperty(PkgProps.PKG_DESC_URL, mDescUrl); } if (mReleaseNote != null && !mReleaseNote.isEmpty()) { props.setProperty(PkgProps.PKG_RELEASE_NOTE, mReleaseNote); } if (mReleaseUrl != null && !mReleaseUrl.isEmpty()) { props.setProperty(PkgProps.PKG_RELEASE_URL, mReleaseUrl); } if (mObsolete != null) { props.setProperty(PkgProps.PKG_OBSOLETE, mObsolete); } if (mSource != null) { props.setProperty(PkgProps.PKG_SOURCE_URL, mSource.getUrl()); } } /** * Parses the uses-licence node of this package, if any, and returns the license * definition if there's one. Returns null if there's no uses-license element or no * license of this name defined. */ @Nullable private License parseLicense(@NonNull Node packageNode, @NonNull Map<String, String> licenses) { Node usesLicense = PackageParserUtils.findChildElement(packageNode, SdkRepoConstants.NODE_USES_LICENSE); if (usesLicense != null) { Node ref = usesLicense.getAttributes().getNamedItem(SdkRepoConstants.ATTR_REF); if (ref != null) { String licenseRef = ref.getNodeValue(); return new License(licenses.get(licenseRef), licenseRef); } } return null; } /** * Parses an XML node to process the <archives> element. * Always return a non-null array. The array may be empty. */ @NonNull private Archive[] parseArchives(@NonNull Node archivesNode) { ArrayList<Archive> archives = new ArrayList<Archive>(); if (archivesNode != null) { String nsUri = archivesNode.getNamespaceURI(); for (Node child = archivesNode.getFirstChild(); child != null; child = child.getNextSibling()) { if (child.getNodeType() == Node.ELEMENT_NODE && nsUri.equals(child.getNamespaceURI()) && SdkRepoConstants.NODE_ARCHIVE.equals(child.getLocalName())) { archives.add(parseArchive(child)); } } } return archives.toArray(new Archive[archives.size()]); } /** * Parses one <archive> element from an <archives> container. */ @NonNull private Archive parseArchive(@NonNull Node archiveNode) { Archive a = new Archive(this, PackageParserUtils.parseArchFilter(archiveNode), PackageParserUtils.getXmlString(archiveNode, SdkRepoConstants.NODE_URL), PackageParserUtils.getXmlLong(archiveNode, SdkRepoConstants.NODE_SIZE, 0), PackageParserUtils.getXmlString(archiveNode, SdkRepoConstants.NODE_CHECKSUM)); return a; } /** * Returns the source that created (and owns) this package. Can be null. */ @Nullable public SdkSource getParentSource() { return mSource; } /** * Returns true if the package is deemed obsolete, that is it contains an * actual <code><obsolete></code> element. */ public boolean isObsolete() { return mObsolete != null; } /** * Returns the revision, an int > 0, for all packages (platform, add-on, tool, doc). * Can be 0 if this is a local package of unknown revision. */ @NonNull public abstract FullRevision getRevision(); /** * Returns the optional description for all packages (platform, add-on, tool, doc) or * for a lib. It is null if the element has not been specified in the repository XML. */ @Nullable public License getLicense() { return mLicense; } /** * Returns the optional description for all packages (platform, add-on, tool, doc) or * for a lib. This is the raw description available from the XML meta data and is typically * only used internally. * <p/> * For actual display in the UI, use the methods from {@link IDescription} instead. * <p/> * Can be empty but not null. */ @NonNull public String getDescription() { return mDescription; } /** * Returns the optional list-display for all packages as defined in the XML meta data * and is typically only used internally. * <p/> * For actual display in the UI, use {@link IListDescription} instead. * <p/> * Can be empty but not null. */ @NonNull public String getListDisplay() { return mListDisplay; } /** * Returns the optional description URL for all packages (platform, add-on, tool, doc). * Can be empty but not null. */ @NonNull public String getDescUrl() { return mDescUrl; } /** * Returns the optional release note for all packages (platform, add-on, tool, doc) or * for a lib. Can be empty but not null. */ @NonNull public String getReleaseNote() { return mReleaseNote; } /** * Returns the optional release note URL for all packages (platform, add-on, tool, doc). * Can be empty but not null. */ @NonNull public String getReleaseNoteUrl() { return mReleaseUrl; } /** * Returns the archives defined in this package. * Can be an empty array but not null. */ @NonNull public Archive[] getArchives() { return mArchives; } /** * Returns true if this package contains the exact given archive. * Important: This compares object references, not object equality. */ public boolean hasArchive(Archive archive) { for (Archive a : mArchives) { if (a == archive) { return true; } } return false; } /** * Returns whether the {@link Package} has at least one {@link Archive} compatible with * the host platform. */ public boolean hasCompatibleArchive() { for (Archive archive : mArchives) { if (archive.isCompatible()) { return true; } } return false; } /** * Returns a short, reasonably unique string identifier that can be used * to identify this package when installing from the command-line interface. * {@code 'android list sdk'} will show these IDs and then in turn they can * be provided to {@code 'android update sdk --no-ui --filter'} to select * some specific packages. * <p/> * The identifiers must have the following properties: <br/> * - They must contain only simple alphanumeric characters. <br/> * - Commas, whitespace and any special character that could be obviously problematic * to a shell interface should be avoided (so dash/underscore are OK, but things * like colon, pipe or dollar should be avoided.) <br/> * - The name must be consistent across calls and reasonably unique for the package * type. Collisions can occur but should be rare. <br/> * - Different package types should have a clearly different name pattern. <br/> * - The revision number should not be included, as this would prevent updates * from being automated (which is the whole point.) <br/> * - It must remain reasonably human readable. <br/> * - If no such id can exist (for example for a local package that cannot be installed) * then an empty string should be returned. Don't return null. * <p/> * Important: This is <em>not</em> a strong unique identifier for the package. * If you need a strong unique identifier, you should use {@link #comparisonKey()} * and the {@link Comparable} interface. */ @NonNull public abstract String installId(); /** * Returns the short description of the source, if not null. * Otherwise returns the default Object toString result. * <p/> * This is mostly helpful for debugging. * For UI display, use the {@link IDescription} interface. */ @NonNull @Override public String toString() { String s = getShortDescription(); if (s != null) { return s; } return super.toString(); } /** * Returns a description of this package that is suitable for a list display. * Should not be empty. Can never be null. * <p/> * Derived classes should use {@link #getListDisplay()} if it's not empty. * <p/> * When it is empty, the default behavior is to recompute a string that depends * on the package type. * <p/> * In both cases, the string should indicate whether the package is marked as obsolete. * <p/> * Note that this is the "base" name for the package with no specific revision nor API * mentioned as this is likely used in a table that will already provide these details. * In contrast, {@link #getShortDescription()} should be used if you want more details * such as the package revision number or the API, if applicable, all in the same string. */ @NonNull @Override public abstract String getListDescription(); /** * Returns a short description for an {@link IDescription}. * Can be empty but not null. */ @NonNull @Override public abstract String getShortDescription(); /** * Returns a long description for an {@link IDescription}. * Can be empty but not null. */ @NonNull @Override public String getLongDescription() { StringBuilder sb = new StringBuilder(); String s = getDescription(); if (s != null) { sb.append(s); } if (sb.length() > 0) { sb.append("\n"); } sb.append(String.format("Revision %1$s%2$s", getRevision().toShortString(), isObsolete() ? " (Obsolete)" : "")); s = getDescUrl(); if (s != null && !s.isEmpty()) { sb.append(String.format("\n\nMore information at %1$s", s)); } s = getReleaseNote(); if (s != null && !s.isEmpty()) { sb.append("\n\nRelease note:\n").append(s); } s = getReleaseNoteUrl(); if (s != null && !s.isEmpty()) { sb.append("\nRelease note URL: ").append(s); } return sb.toString(); } /** * A package is local (that is 'installed locally') if it contains a single * archive that is local. If not local, it's a remote package, only available * on a remote source for download and installation. */ public boolean isLocal() { return mArchives.length == 1 && mArchives[0].isLocal(); } /** * Computes a potential installation folder if an archive of this package were * to be installed right away in the given SDK root. * <p/> * Some types of packages install in a fix location, for example docs and tools. * In this case the returned folder may already exist with a different archive installed * at the desired location. <br/> * For other packages types, such as add-on or platform, the folder name is only partially * relevant to determine the content and thus a real check will be done to provide an * existing or new folder depending on the current content of the SDK. * <p/> * Note that the installer *will* create all directories returned here just before * installation so this method must not attempt to create them. * * @param osSdkRoot The OS path of the SDK root folder. * @param sdkManager An existing SDK manager to list current platforms and addons. * @return A new {@link File} corresponding to the directory to use to install this package. */ @NonNull public abstract File getInstallFolder(String osSdkRoot, SdkManager sdkManager); /** * Hook called right before an archive is installed. The archive has already * been downloaded successfully and will be installed in the directory specified by * <var>installFolder</var> when this call returns. * <p/> * The hook lets the package decide if installation of this specific archive should * be continue. The installer will still install the remaining packages if possible. * <p/> * The base implementation always return true. * <p/> * Note that the installer *will* create all directories specified by * {@link #getInstallFolder} just before installation, so they must not be * created here. This is also called before the previous install dir is removed * so the previous content is still there during upgrade. * * @param archive The archive that will be installed * @param monitor The {@link ITaskMonitor} to display errors. * @param osSdkRoot The OS path of the SDK root folder. * @param installFolder The folder where the archive will be installed. Note that this * is <em>not</em> the folder where the archive was temporary * unzipped. The installFolder, if it exists, contains the old * archive that will soon be replaced by the new one. * @return True if installing this archive shall continue, false if it should be skipped. */ public boolean preInstallHook(Archive archive, ITaskMonitor monitor, String osSdkRoot, File installFolder) { // Nothing to do in base class. return true; } /** * Hook called right after a file has been unzipped (during an install). * <p/> * The base class implementation makes sure to properly adjust set executable * permission on Linux and MacOS system if the zip entry was marked as +x. * * @param archive The archive that is being installed. * @param monitor The {@link ITaskMonitor} to display errors. * @param fileOp The {@link IFileOp} used by the archive installer. * @param unzippedFile The file that has just been unzipped in the install temp directory. * @param zipEntry The {@link ZipArchiveEntry} that has just been unzipped. */ public void postUnzipFileHook(Archive archive, ITaskMonitor monitor, IFileOp fileOp, File unzippedFile, ZipArchiveEntry zipEntry) { // if needed set the permissions. if (sUsingUnixPerm && fileOp.isFile(unzippedFile)) { // get the mode and test if it contains the executable bit int mode = zipEntry.getUnixMode(); if ((mode & 0111) != 0) { try { fileOp.setExecutablePermission(unzippedFile); } catch (IOException ignore) { } } } } /** * Hook called right after an archive has been installed. * * @param archive The archive that has been installed. * @param monitor The {@link ITaskMonitor} to display errors. * @param installFolder The folder where the archive was successfully installed. * Null if the installation failed, in case the archive needs to * do some cleanup after <code>preInstallHook</code>. */ public void postInstallHook(Archive archive, ITaskMonitor monitor, File installFolder) { // Nothing to do in base class. } /** * Returns whether the give package represents the same item as the current package. * <p/> * Two packages are considered the same if they represent the same thing, except for the * revision number. * @param pkg the package to compare. * @return true if the item as equivalent. */ public abstract boolean sameItemAs(Package pkg); /** * Computes whether the given package is a suitable update for the current package. * <p/> * An update is just that: a new package that supersedes the current one. If the new * package does not represent the same item or if it has the same or lower revision as the * current one, it's not an update. * * @param replacementPackage The potential replacement package. * @return One of the {@link UpdateInfo} values. * * @see #sameItemAs(Package) */ @NonNull public abstract UpdateInfo canBeUpdatedBy(Package replacementPackage); /** * Returns an ordering <b>suitable for display</b> like this: <br/> * - Tools <br/> * - Platform-Tools <br/> * - Built-Tools <br/> * - Docs. <br/> * - Platform n preview <br/> * - Platform n <br/> * - Platform n-1 <br/> * - Samples packages <br/> * - Add-on based on n preview <br/> * - Add-on based on n <br/> * - Add-on based on n-1 <br/> * - Extra packages <br/> * <p/> * Important: this must NOT be used to compare if two packages are the same thing. * This is achieved by {@link #sameItemAs(Package)} or {@link #canBeUpdatedBy(Package)}. * <p/> * The order done here is suitable for display, and this may not be the appropriate * order when comparing whether packages are equal or of greater revision -- if you need * to compare revisions, then use {@link #getRevision()}{@code .compareTo(rev)} directly. * <p/> * This {@link #compareTo(Package)} method is purely an implementation detail to * perform the right ordering of the packages in the list of available or installed packages. * <p/> * <em>Important</em>: Derived classes should consider overriding {@link #comparisonKey()} * instead of this method. */ @Override public int compareTo(Package other) { String s1 = this.comparisonKey(); String s2 = other.comparisonKey(); int r = s1.compareTo(s2); return r; } /** * Computes a comparison key for each package used by {@link #compareTo(Package)}. * The key is a string. * The base package class return a string that encodes the package type, * the revision number and the platform version, if applicable, in the form: * <pre> * t:N|v:NNNN.P|r:NNNN| * </pre> * All fields must start by a "letter colon" prefix and end with a vertical pipe (|, ASCII 124). * <p/> * The string format <em>may</em> change between releases and clients should not * store them outside of the session or expect them to be consistent between * different releases. They are purely an internal implementation details of the * {@link #compareTo(Package)} method. * <p/> * Derived classes should get the string from the super class and then append * or <em>insert</em> their own |-separated content. * For example an extra vendor name & path can be inserted before the revision * number, since it has more sorting weight. */ @NonNull protected String comparisonKey() { StringBuilder sb = new StringBuilder(); sb.append("t:"); //$NON-NLS-1$ if (this instanceof ToolPackage) { sb.append(0); } else if (this instanceof PlatformToolPackage) { sb.append(1); } else if (this instanceof BuildToolPackage) { sb.append(2); } else if (this instanceof DocPackage) { sb.append(3); } else if (this instanceof PlatformPackage) { sb.append(4); } else if (this instanceof SamplePackage) { sb.append(5); } else if ((this instanceof SystemImagePackage) && ((SystemImagePackage) this).isPlatform()) { sb.append(6); } else if (this instanceof AddonPackage) { sb.append(7); } else if (this instanceof SystemImagePackage) { sb.append(8); } else { // extras and everything else sb.append(9); } // We insert the package version here because it is more important // than the revision number. // In the list display, we want package version to be sorted // top-down, so we'll use 10k-api as the sorting key. The day we // reach 10k APIs, we'll need to revisit this. sb.append("|v:"); //$NON-NLS-1$ if (this instanceof IAndroidVersionProvider) { AndroidVersion v = ((IAndroidVersionProvider) this).getAndroidVersion(); sb.append(String.format("%1$04d.%2$d", //$NON-NLS-1$ 10000 - v.getApiLevel(), v.isPreview() ? 1 : 0)); } // Append revision number // Note: pad revision numbers to 4 digits (e.g. make sure 12>3 by comparing 0012 and 0003) sb.append("|r:"); //$NON-NLS-1$ FullRevision rev = getRevision(); sb.append(String.format("%1$04d.%2$04d.%3$04d.", //$NON-NLS-1$ rev.getMajor(), rev.getMinor(), rev.getMicro())); // Hack: When comparing packages for installation purposes, we want to treat // "final releases" packages as more important than rc/preview packages. // However like for the API level above, when sorting for list display purposes // we want the final release package listed before its rc/preview packages. if (rev.isPreview()) { sb.append(rev.getPreview()); } else { sb.append('0'); // 0=Final (!preview), to make "18.0" < "18.1" (18 Final < 18 RC1) } sb.append('|'); return sb.toString(); } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(mArchives); result = prime * result + ((mObsolete == null) ? 0 : mObsolete.hashCode()); result = prime * result + getRevision().hashCode(); result = prime * result + ((mSource == null) ? 0 : mSource.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof Package)) { return false; } Package other = (Package) obj; if (!Arrays.equals(mArchives, other.mArchives)) { return false; } if (mObsolete == null) { if (other.mObsolete != null) { return false; } } else if (!mObsolete.equals(other.mObsolete)) { return false; } if (!getRevision().equals(other.getRevision())) { return false; } if (mSource == null) { if (other.mSource != null) { return false; } } else if (!mSource.equals(other.mSource)) { return false; } return true; } // TODO(jbakermalone): This is moved here from the more logical location in PkgDesc.Builder since Package will soon be forked into // studio and this version deprecated, whereas PkgDesc will not. protected PkgDesc.Builder setDescriptions(PkgDesc.Builder builder) { builder.setDescriptionShort(getShortDescription()); builder.setDescriptionUrl(getDescUrl()); builder.setListDisplay(getListDisplay()); builder.setIsObsolete(isObsolete()); builder.setLicense(getLicense()); return builder; } }