| /* |
| * 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.updater; |
| |
| import com.android.sdklib.AndroidVersion; |
| import com.android.sdklib.internal.repository.ITask; |
| import com.android.sdklib.internal.repository.ITaskMonitor; |
| import com.android.sdklib.internal.repository.archives.Archive; |
| import com.android.sdklib.internal.repository.packages.AddonPackage; |
| import com.android.sdklib.internal.repository.packages.BuildToolPackage; |
| import com.android.sdklib.internal.repository.packages.DocPackage; |
| import com.android.sdklib.internal.repository.packages.ExtraPackage; |
| import com.android.sdklib.internal.repository.packages.IAndroidVersionProvider; |
| import com.android.sdklib.internal.repository.packages.IExactApiLevelDependency; |
| import com.android.sdklib.internal.repository.packages.IMinApiLevelDependency; |
| import com.android.sdklib.internal.repository.packages.IMinPlatformToolsDependency; |
| import com.android.sdklib.internal.repository.packages.IMinToolsDependency; |
| import com.android.sdklib.internal.repository.packages.IPlatformDependency; |
| import com.android.sdklib.internal.repository.packages.MinToolsPackage; |
| import com.android.sdklib.internal.repository.packages.Package; |
| import com.android.sdklib.internal.repository.packages.Package.UpdateInfo; |
| import com.android.sdklib.internal.repository.packages.PlatformPackage; |
| import com.android.sdklib.internal.repository.packages.PlatformToolPackage; |
| import com.android.sdklib.internal.repository.packages.SamplePackage; |
| import com.android.sdklib.internal.repository.packages.SystemImagePackage; |
| import com.android.sdklib.internal.repository.packages.ToolPackage; |
| import com.android.sdklib.internal.repository.sources.SdkSource; |
| import com.android.sdklib.internal.repository.sources.SdkSources; |
| import com.android.sdklib.repository.FullRevision; |
| import com.android.sdklib.repository.descriptors.IdDisplay; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * The logic to compute which packages to install, based on the choices |
| * made by the user. This adds required packages as needed. |
| * <p/> |
| * When the user doesn't provide a selection, looks at local package to find |
| * those that can be updated and compute dependencies too. |
| * |
| * @deprecated |
| * com.android.sdklib.internal.repository has moved into Studio as |
| * com.android.tools.idea.sdk.remote.internal. |
| */ |
| @Deprecated |
| public class SdkUpdaterLogic { |
| |
| private final IUpdaterData mUpdaterData; |
| |
| public SdkUpdaterLogic(IUpdaterData updaterData) { |
| mUpdaterData = updaterData; |
| } |
| |
| /** |
| * Retrieves an unfiltered list of all remote archives. |
| * The archives are guaranteed to be compatible with the current platform. |
| */ |
| public List<ArchiveInfo> getAllRemoteArchives( |
| SdkSources sources, |
| Package[] localPkgs, |
| boolean includeAll) { |
| |
| List<Package> remotePkgs = new ArrayList<Package>(); |
| SdkSource[] remoteSources = sources.getAllSources(); |
| fetchRemotePackages(remotePkgs, remoteSources); |
| |
| ArrayList<Archive> archives = new ArrayList<Archive>(); |
| for (Package remotePkg : remotePkgs) { |
| // Only look for non-obsolete updates unless requested to include them |
| if (includeAll || !remotePkg.isObsolete()) { |
| // Found a suitable update. Only accept the remote package |
| // if it provides at least one compatible archive |
| |
| addArchives: |
| for (Archive a : remotePkg.getArchives()) { |
| if (a.isCompatible()) { |
| |
| // If we're trying to add a package for revision N, |
| // make sure we don't also have a package for revision N-1. |
| for (int i = archives.size() - 1; i >= 0; i--) { |
| Package pkgFound = archives.get(i).getParentPackage(); |
| if (pkgFound.canBeUpdatedBy(remotePkg) == UpdateInfo.UPDATE) { |
| // This package can update one we selected earlier. |
| // Remove the one that can be updated by this new one. |
| archives.remove(i); |
| } else if (remotePkg.canBeUpdatedBy(pkgFound) == UpdateInfo.UPDATE) { |
| // There is a package in the list that is already better |
| // than the one we want to add, so don't add it. |
| break addArchives; |
| } |
| } |
| |
| archives.add(a); |
| break; |
| } |
| } |
| } |
| } |
| |
| ArrayList<ArchiveInfo> result = new ArrayList<ArchiveInfo>(); |
| |
| ArchiveInfo[] localArchives = createLocalArchives(localPkgs); |
| |
| for (Archive a : archives) { |
| insertArchive(a, |
| result, |
| archives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| false /*automated*/); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Compute which packages to install by taking the user selection |
| * and adding required packages as needed. |
| * |
| * When the user doesn't provide a selection, looks at local packages to find |
| * those that can be updated and compute dependencies too. |
| */ |
| public List<ArchiveInfo> computeUpdates( |
| Collection<Archive> selectedArchives, |
| SdkSources sources, |
| Package[] localPkgs, |
| boolean includeAll) { |
| |
| List<ArchiveInfo> archives = new ArrayList<ArchiveInfo>(); |
| List<Package> remotePkgs = new ArrayList<Package>(); |
| SdkSource[] remoteSources = sources.getAllSources(); |
| |
| // Create ArchiveInfos out of local (installed) packages. |
| ArchiveInfo[] localArchives = createLocalArchives(localPkgs); |
| |
| // If we do not have a specific list of archives to install (that is the user |
| // selected "update all" rather than request specific packages), then we try to |
| // find updates based on the *existing* packages. |
| if (selectedArchives == null) { |
| selectedArchives = findUpdates( |
| localArchives, |
| remotePkgs, |
| remoteSources, |
| includeAll); |
| } |
| |
| // Once we have a list of packages to install, we try to solve all their |
| // dependencies by automatically adding them to the list of things to install. |
| // This works on the list provided either by the user directly or the list |
| // computed from potential updates. |
| for (Archive a : selectedArchives) { |
| insertArchive(a, |
| archives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| false /*automated*/); |
| } |
| |
| // Finally we need to look at *existing* packages which are not being updated |
| // and check if they have any missing dependencies and suggest how to fix |
| // these dependencies. |
| fixMissingLocalDependencies( |
| archives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| return archives; |
| } |
| |
| private double getRevisionRank(FullRevision rev) { |
| int p = rev.isPreview() ? 999 : 999 - rev.getPreview(); |
| return rev.getMajor() + |
| rev.getMinor() / 1000.d + |
| rev.getMicro() / 1000000.d + |
| p / 1000000000.d; |
| } |
| |
| /** |
| * Finds new packages that the user does not have in his/her local SDK |
| * and adds them to the list of archives to install. |
| * <p/> |
| * The default is to only find "new" platforms, that is anything more |
| * recent than the highest platform currently installed. |
| * A side effect is that for an empty SDK install this will list *all* |
| * platforms available (since there's no "highest" installed platform.) |
| * <p/> |
| * This also adds "silent" dependencies. For example the user probably |
| * needs to have at least one version of the build-tools package although |
| * there is nothing that directly depends on it. So if the user doesn't have |
| * any installed or selected version, selected the most recent one as a |
| * candidate for install. |
| * |
| * @param archives The in-out list of archives to install. Typically the |
| * list is not empty at first as it should contain any archives that is |
| * already scheduled for install. This method will add to the list. |
| * @param sources The list of all sources, to fetch them as necessary. |
| * @param localPkgs The list of all currently installed packages. |
| * @param includeAll When true, this will list all platforms. |
| * (included these lower than the highest installed one) as well as |
| * all obsolete packages of these platforms. |
| */ |
| public void addNewPlatforms( |
| Collection<ArchiveInfo> archives, |
| SdkSources sources, |
| Package[] localPkgs, |
| boolean includeAll) { |
| |
| // Create ArchiveInfos out of local (installed) packages. |
| ArchiveInfo[] localArchives = createLocalArchives(localPkgs); |
| |
| // Find the highest platform installed |
| double currentBuildToolScore = 0; |
| double currentPlatformScore = 0; |
| double currentSampleScore = 0; |
| double currentAddonScore = 0; |
| double currentDocScore = 0; |
| HashMap<String, Double> currentExtraScore = new HashMap<String, Double>(); |
| if (!includeAll) { |
| if (localPkgs != null) { |
| for (Package p : localPkgs) { |
| double rev = getRevisionRank(p.getRevision()); |
| int api = 0; |
| boolean isPreview = false; |
| if (p instanceof IAndroidVersionProvider) { |
| AndroidVersion vers = ((IAndroidVersionProvider) p).getAndroidVersion(); |
| api = vers.getApiLevel(); |
| isPreview = vers.isPreview(); |
| } |
| |
| // The score is 1000*api + (999 if preview) + rev |
| // This allows previews to rank above a non-preview and |
| // allows revisions to rank appropriately. |
| double score = api * 1000 + (isPreview ? 999 : 0) + rev; |
| |
| if (p instanceof BuildToolPackage) { |
| currentBuildToolScore = Math.max(currentBuildToolScore, score); |
| } else if (p instanceof PlatformPackage) { |
| currentPlatformScore = Math.max(currentPlatformScore, score); |
| } else if (p instanceof SamplePackage) { |
| currentSampleScore = Math.max(currentSampleScore, score); |
| } else if (p instanceof AddonPackage) { |
| currentAddonScore = Math.max(currentAddonScore, score); |
| } else if (p instanceof ExtraPackage) { |
| currentExtraScore.put(((ExtraPackage) p).getPath(), score); |
| } else if (p instanceof DocPackage) { |
| currentDocScore = Math.max(currentDocScore, score); |
| } |
| } |
| } |
| } |
| |
| SdkSource[] remoteSources = sources.getAllSources(); |
| ArrayList<Package> remotePkgs = new ArrayList<Package>(); |
| fetchRemotePackages(remotePkgs, remoteSources); |
| |
| Package suggestedDoc = null; |
| Package suggestedBuildTool = null; |
| |
| for (Package p : remotePkgs) { |
| // Skip obsolete packages unless requested to include them. |
| if (p.isObsolete() && !includeAll) { |
| continue; |
| } |
| |
| double rev = getRevisionRank(p.getRevision()); |
| int api = 0; |
| boolean isPreview = false; |
| if (p instanceof IAndroidVersionProvider) { |
| AndroidVersion vers = ((IAndroidVersionProvider) p).getAndroidVersion(); |
| api = vers.getApiLevel(); |
| isPreview = vers.isPreview(); |
| } |
| |
| double score = api * 1000 + (isPreview ? 999 : 0) + rev; |
| |
| boolean shouldAdd = false; |
| if (p instanceof BuildToolPackage) { |
| // We don't want all the build-tool packages, only the most recent one |
| // if not is currently installed. |
| if (currentBuildToolScore == 0 && score > currentBuildToolScore) { |
| suggestedBuildTool = p; |
| currentBuildToolScore = score; |
| } |
| } else if (p instanceof PlatformPackage) { |
| shouldAdd = score > currentPlatformScore; |
| } else if (p instanceof SamplePackage) { |
| shouldAdd = score > currentSampleScore; |
| } else if (p instanceof AddonPackage) { |
| shouldAdd = score > currentAddonScore; |
| } else if (p instanceof ExtraPackage) { |
| String key = ((ExtraPackage) p).getPath(); |
| shouldAdd = !currentExtraScore.containsKey(key) || |
| score > currentExtraScore.get(key).doubleValue(); |
| } else if (p instanceof DocPackage) { |
| // We don't want all the doc, only the most recent one |
| if (score > currentDocScore) { |
| suggestedDoc = p; |
| currentDocScore = score; |
| } |
| } |
| |
| if (shouldAdd) { |
| // We should suggest this package for installation. |
| for (Archive a : p.getArchives()) { |
| if (a.isCompatible()) { |
| insertArchive(a, |
| archives, |
| null /*selectedArchives*/, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| |
| if (p instanceof PlatformPackage && (score >= currentPlatformScore)) { |
| // We just added a new platform *or* we are visiting the highest currently |
| // installed platform. In either case we want to make sure it either has |
| // its own system image or that we provide one by default. |
| PlatformPackage pp = (PlatformPackage) p; |
| if (pp.getIncludedAbi() == null) { |
| for (Package p2 : remotePkgs) { |
| if (!(p2 instanceof SystemImagePackage) || |
| ((SystemImagePackage)p2).isPlatform() || |
| (p2.isObsolete() && !includeAll)) { |
| continue; |
| } |
| SystemImagePackage sip = (SystemImagePackage) p2; |
| if (sip.getAndroidVersion().equals(pp.getAndroidVersion())) { |
| for (Archive a : sip.getArchives()) { |
| if (a.isCompatible()) { |
| insertArchive(a, |
| archives, |
| null /*selectedArchives*/, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if (suggestedDoc != null) { |
| // We should suggest this package for installation. |
| for (Archive a : suggestedDoc.getArchives()) { |
| if (a.isCompatible()) { |
| insertArchive(a, |
| archives, |
| null /*selectedArchives*/, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| |
| if (suggestedBuildTool != null) { |
| // We should suggest this package for installation. |
| for (Archive a : suggestedBuildTool.getArchives()) { |
| if (a.isCompatible()) { |
| insertArchive(a, |
| archives, |
| null /*selectedArchives*/, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Create a array of {@link ArchiveInfo} based on all local (already installed) |
| * packages. The array is always non-null but may be empty. |
| * <p/> |
| * The local {@link ArchiveInfo} are guaranteed to have one non-null archive |
| * that you can retrieve using {@link ArchiveInfo#getNewArchive()}. |
| */ |
| public ArchiveInfo[] createLocalArchives(Package[] localPkgs) { |
| |
| if (localPkgs != null) { |
| ArrayList<ArchiveInfo> list = new ArrayList<ArchiveInfo>(); |
| for (Package p : localPkgs) { |
| // Only accept packages that have one compatible archive. |
| // Local package should have 1 and only 1 compatible archive anyway. |
| for (Archive a : p.getArchives()) { |
| if (a != null && a.isCompatible()) { |
| // We create an "installed" archive info to wrap the local package. |
| // Note that dependencies are not computed since right now we don't |
| // deal with more than one level of dependencies and installed archives |
| // are deemed implicitly accepted anyway. |
| list.add(new LocalArchiveInfo(a)); |
| } |
| } |
| } |
| |
| return list.toArray(new ArchiveInfo[list.size()]); |
| } |
| |
| return new ArchiveInfo[0]; |
| } |
| |
| /** |
| * Find suitable updates to all current local packages. |
| * <p/> |
| * Returns a list of potential updates for *existing* packages. This does NOT solve |
| * dependencies for the new packages. |
| * <p/> |
| * Always returns a non-null collection, which can be empty. |
| */ |
| private Collection<Archive> findUpdates( |
| ArchiveInfo[] localArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| boolean includeAll) { |
| ArrayList<Archive> updates = new ArrayList<Archive>(); |
| |
| fetchRemotePackages(remotePkgs, remoteSources); |
| |
| for (ArchiveInfo ai : localArchives) { |
| Archive na = ai.getNewArchive(); |
| if (na == null) { |
| continue; |
| } |
| Package localPkg = na.getParentPackage(); |
| |
| for (Package remotePkg : remotePkgs) { |
| // Only look for non-obsolete updates unless requested to include them |
| if ((includeAll || !remotePkg.isObsolete()) && |
| localPkg.canBeUpdatedBy(remotePkg) == UpdateInfo.UPDATE) { |
| // Found a suitable update. Only accept the remote package |
| // if it provides at least one compatible archive |
| |
| addArchives: |
| for (Archive a : remotePkg.getArchives()) { |
| if (a.isCompatible()) { |
| |
| // If we're trying to add a package for revision N, |
| // make sure we don't also have a package for revision N-1. |
| for (int i = updates.size() - 1; i >= 0; i--) { |
| Package pkgFound = updates.get(i).getParentPackage(); |
| if (pkgFound.canBeUpdatedBy(remotePkg) == UpdateInfo.UPDATE) { |
| // This package can update one we selected earlier. |
| // Remove the one that can be updated by this new one. |
| updates.remove(i); |
| } else if (remotePkg.canBeUpdatedBy(pkgFound) == |
| UpdateInfo.UPDATE) { |
| // There is a package in the list that is already better |
| // than the one we want to add, so don't add it. |
| break addArchives; |
| } |
| } |
| |
| updates.add(a); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| return updates; |
| } |
| |
| /** |
| * Check all local archives which are NOT being updated and see if they |
| * miss any dependency. If they do, try to fix that dependency by selecting |
| * an appropriate package. |
| */ |
| private void fixMissingLocalDependencies( |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| |
| nextLocalArchive: for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| Package p = a == null ? null : a.getParentPackage(); |
| if (p == null) { |
| continue; |
| } |
| |
| // Is this local archive being updated? |
| for (ArchiveInfo ai2 : outArchives) { |
| if (ai2.getReplaced() == a) { |
| // this new archive will replace the current local one, |
| // so we don't have to care about fixing dependencies (since the |
| // new archive should already have had its dependencies resolved) |
| continue nextLocalArchive; |
| } |
| } |
| |
| // find dependencies for the local archive and add them as needed |
| // to the outArchives collection. |
| ArchiveInfo[] deps = findDependency(p, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| if (deps != null) { |
| // The already installed archive has a missing dependency, which we |
| // just selected for install. Make sure we remember the dependency |
| // so that we can enforce it later in the UI. |
| for (ArchiveInfo aid : deps) { |
| aid.addDependencyFor(ai); |
| } |
| } |
| } |
| } |
| |
| private ArchiveInfo insertArchive(Archive archive, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives, |
| boolean automated) { |
| Package p = archive.getParentPackage(); |
| |
| // Is this an update? |
| Archive updatedArchive = null; |
| for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package lp = a.getParentPackage(); |
| |
| if (lp.canBeUpdatedBy(p) == UpdateInfo.UPDATE) { |
| updatedArchive = a; |
| } |
| } |
| } |
| |
| // Find dependencies and adds them as needed to outArchives |
| ArchiveInfo[] deps = findDependency(p, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| // Make sure it's not a dup |
| ArchiveInfo ai = null; |
| |
| for (ArchiveInfo ai2 : outArchives) { |
| Archive a2 = ai2.getNewArchive(); |
| if (a2 != null && a2.getParentPackage().sameItemAs(archive.getParentPackage())) { |
| ai = ai2; |
| break; |
| } |
| } |
| |
| if (ai == null) { |
| ai = new ArchiveInfo( |
| archive, //newArchive |
| updatedArchive, //replaced |
| deps //dependsOn |
| ); |
| outArchives.add(ai); |
| } |
| |
| if (deps != null) { |
| for (ArchiveInfo d : deps) { |
| d.addDependencyFor(ai); |
| } |
| } |
| |
| return ai; |
| } |
| |
| /** |
| * Resolves dependencies for a given package. |
| * |
| * Returns null if no dependencies were found. |
| * Otherwise return an array of {@link ArchiveInfo}, which is guaranteed to have |
| * at least size 1 and contain no null elements. |
| */ |
| private ArchiveInfo[] findDependency(Package pkg, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| |
| // Current dependencies can be: |
| // - addon: *always* depends on platform of same API level |
| // - platform: *might* depends on tools of rev >= min-tools-rev |
| // - extra: *might* depends on platform with api >= min-api-level |
| |
| Set<ArchiveInfo> aiFound = new HashSet<ArchiveInfo>(); |
| |
| if (pkg instanceof IPlatformDependency) { |
| ArchiveInfo ai = findPlatformDependency( |
| (IPlatformDependency) pkg, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| if (ai != null) { |
| aiFound.add(ai); |
| } |
| } |
| |
| if (pkg instanceof IMinToolsDependency) { |
| |
| ArchiveInfo ai = findToolsDependency( |
| (IMinToolsDependency) pkg, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| if (ai != null) { |
| aiFound.add(ai); |
| } |
| } |
| |
| if (pkg instanceof IMinPlatformToolsDependency) { |
| |
| ArchiveInfo ai = findPlatformToolsDependency( |
| (IMinPlatformToolsDependency) pkg, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| if (ai != null) { |
| aiFound.add(ai); |
| } |
| } |
| |
| if (pkg instanceof IMinApiLevelDependency) { |
| |
| ArchiveInfo ai = findMinApiLevelDependency( |
| (IMinApiLevelDependency) pkg, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| if (ai != null) { |
| aiFound.add(ai); |
| } |
| } |
| |
| if (pkg instanceof IExactApiLevelDependency) { |
| |
| ArchiveInfo ai = findExactApiLevelDependency( |
| (IExactApiLevelDependency) pkg, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives); |
| |
| if (ai != null) { |
| aiFound.add(ai); |
| } |
| } |
| |
| if (!aiFound.isEmpty()) { |
| ArchiveInfo[] result = aiFound.toArray(new ArchiveInfo[aiFound.size()]); |
| Arrays.sort(result); |
| return result; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Resolves dependencies on tools. |
| * |
| * A platform or an extra package can both have a min-tools-rev, in which case it |
| * depends on having a tools package of the requested revision. |
| * Finds the tools dependency. If found, add it to the list of things to install. |
| * Returns the archive info dependency, if any. |
| */ |
| public ArchiveInfo findToolsDependency( |
| IMinToolsDependency pkg, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| // This is the requirement to match. |
| FullRevision rev = pkg.getMinToolsRevision(); |
| |
| if (rev.equals(MinToolsPackage.MIN_TOOLS_REV_NOT_SPECIFIED)) { |
| // Well actually there's no requirement. |
| return null; |
| } |
| |
| // First look in locally installed packages. |
| for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof ToolPackage) { |
| if (((ToolPackage) p).getRevision().compareTo(rev) >= 0) { |
| // We found one already installed. |
| return null; |
| } |
| } |
| } |
| } |
| |
| // Look in archives already scheduled for install |
| for (ArchiveInfo ai : outArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof ToolPackage) { |
| if (((ToolPackage) p).getRevision().compareTo(rev) >= 0) { |
| // The dependency is already scheduled for install, nothing else to do. |
| return ai; |
| } |
| } |
| } |
| } |
| |
| // Otherwise look in the selected archives. |
| if (selectedArchives != null) { |
| for (Archive a : selectedArchives) { |
| Package p = a.getParentPackage(); |
| if (p instanceof ToolPackage) { |
| if (((ToolPackage) p).getRevision().compareTo(rev) >= 0) { |
| // It's not already in the list of things to install, so add it now |
| return insertArchive(a, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| |
| // Finally nothing matched, so let's look at all available remote packages |
| fetchRemotePackages(remotePkgs, remoteSources); |
| FullRevision localRev = rev; |
| Archive localArch = null; |
| for (Package p : remotePkgs) { |
| if (p instanceof ToolPackage) { |
| FullRevision r = ((ToolPackage) p).getRevision(); |
| if (r.compareTo(localRev) >= 0) { |
| // It's not already in the list of things to install, so add the |
| // first compatible archive we can find. |
| for (Archive a : p.getArchives()) { |
| if (a.isCompatible()) { |
| localRev = r; |
| localArch = a; |
| break; |
| } |
| } |
| } |
| } |
| } |
| if (localArch != null) { |
| return insertArchive(localArch, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| |
| } |
| |
| // We end up here if nothing matches. We don't have a good platform to match. |
| // We need to indicate this extra depends on a missing platform archive |
| // so that it can be impossible to install later on. |
| return new MissingArchiveInfo(MissingArchiveInfo.TITLE_TOOL, rev); |
| } |
| |
| /** |
| * Resolves dependencies on platform-tools. |
| * |
| * A tool package can have a min-platform-tools-rev, in which case it depends on |
| * having a platform-tool package of the requested revision. |
| * Finds the platform-tool dependency. If found, add it to the list of things to install. |
| * Returns the archive info dependency, if any. |
| */ |
| public ArchiveInfo findPlatformToolsDependency( |
| IMinPlatformToolsDependency pkg, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| // This is the requirement to match. |
| FullRevision rev = pkg.getMinPlatformToolsRevision(); |
| boolean findMax = false; |
| int compareThreshold = 0; |
| ArchiveInfo aiMax = null; |
| Archive aMax = null; |
| |
| if (rev.equals(IMinPlatformToolsDependency.MIN_PLATFORM_TOOLS_REV_INVALID)) { |
| // The requirement is invalid, which is not supposed to happen since this |
| // property is mandatory. However in a typical upgrade scenario we can end |
| // up with the previous updater managing a new package and not dealing |
| // correctly with the new unknown property. |
| // So instead we parse all the existing and remote packages and try to find |
| // the max available revision and we'll use it. |
| findMax = true; |
| // When findMax is false, we want r.compareTo(rev) >= 0. |
| // When findMax is true, we want r.compareTo(rev) > 0 (so >= 1). |
| compareThreshold = 1; |
| } |
| |
| // First look in locally installed packages. |
| for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformToolPackage) { |
| FullRevision r = ((PlatformToolPackage) p).getRevision(); |
| if (findMax && r.compareTo(rev) > compareThreshold) { |
| rev = r; |
| aiMax = ai; |
| } else if (!findMax && r.compareTo(rev) >= compareThreshold) { |
| // We found one already installed. |
| return null; |
| } |
| } |
| } |
| } |
| |
| // Because of previews, we can have more than 1 choice, so get the local max. |
| FullRevision localRev = rev; |
| ArchiveInfo localAiMax = null; |
| // Look in archives already scheduled for install |
| for (ArchiveInfo ai : outArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformToolPackage) { |
| FullRevision r = ((PlatformToolPackage) p).getRevision(); |
| // If computing dependencies for a non-preview package, don't offer preview dependencies |
| if (r.isPreview() && !rev.isPreview()) { |
| continue; |
| } |
| if (r.compareTo(localRev) >= compareThreshold) { |
| localRev = r; |
| localAiMax = ai; |
| } |
| } |
| } |
| } |
| if (localAiMax != null) { |
| if (findMax) { |
| rev = localRev; |
| aiMax = localAiMax; |
| } else { |
| // The dependency is already scheduled for install, nothing else to do. |
| return localAiMax; |
| } |
| } |
| |
| |
| // Otherwise look in the selected archives. |
| localRev = rev; |
| Archive localAMax = null; |
| if (selectedArchives != null) { |
| for (Archive a : selectedArchives) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformToolPackage) { |
| FullRevision r = ((PlatformToolPackage) p).getRevision(); |
| // If computing dependencies for a non-preview package, don't offer preview dependencies |
| if (r.isPreview() && !rev.isPreview()) { |
| continue; |
| } |
| |
| if (r.compareTo(localRev) >= compareThreshold) { |
| localRev = r; |
| localAiMax = null; |
| localAMax = a; |
| } |
| } |
| } |
| if (localAMax != null) { |
| if (findMax) { |
| rev = localRev; |
| aiMax = null; |
| aMax = localAMax; |
| } else { |
| // It's not already in the list of things to install, so add it now |
| return insertArchive(localAMax, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| |
| // Finally nothing matched, so let's look at all available remote packages |
| fetchRemotePackages(remotePkgs, remoteSources); |
| localRev = rev; |
| localAMax = null; |
| for (Package p : remotePkgs) { |
| if (p instanceof PlatformToolPackage) { |
| FullRevision r = ((PlatformToolPackage) p).getRevision(); |
| // If computing dependencies for a non-preview package, don't offer preview dependencies |
| if (r.isPreview() && !rev.isPreview()) { |
| continue; |
| } |
| |
| if (r.compareTo(rev) >= 0) { |
| // Make sure there's at least one valid archive here |
| for (Archive a : p.getArchives()) { |
| if (a.isCompatible()) { |
| if (r.compareTo(localRev) >= compareThreshold) { |
| localRev = r; |
| localAiMax = null; |
| localAMax = a; |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| if (localAMax != null) { |
| if (findMax) { |
| rev = localRev; |
| aiMax = null; |
| aMax = localAMax; |
| } else { |
| // It's not already in the list of things to install, so add the |
| // first compatible archive we can find. |
| return insertArchive(localAMax, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| |
| if (findMax) { |
| if (aMax != null) { |
| return insertArchive(aMax, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } else if (aiMax != null) { |
| return aiMax; |
| } |
| } |
| |
| // We end up here if nothing matches. We don't have a good platform to match. |
| // We need to indicate this package depends on a missing platform archive |
| // so that it can be impossible to install later on. |
| return new MissingArchiveInfo(MissingArchiveInfo.TITLE_PLATFORM_TOOL, rev); |
| } |
| |
| /** |
| * Resolves dependencies on platform for an add-on. |
| * Resolves dependencies on a system-image on its base platform or add-on. |
| * |
| * An add-on depends on having a platform with the same API level. |
| * |
| * Finds the platform dependency. If found, add it to the list of things to install. |
| * Returns the archive info dependency, if any. |
| */ |
| public ArchiveInfo findPlatformDependency( |
| IPlatformDependency pkg, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| // This is the requirement to match. |
| AndroidVersion v = pkg.getAndroidVersion(); |
| |
| |
| // The dependency package must be a PlatformPackage or an AddonPackage. |
| // For an add-on, we also need to have the same vendor and name-id. |
| Class<? extends Package> expectedClass = PlatformPackage.class; |
| IdDisplay addonVendor = null; |
| IdDisplay addonTag = null; |
| if (pkg instanceof SystemImagePackage && !((SystemImagePackage) pkg).isPlatform()) { |
| expectedClass = AddonPackage.class; |
| addonVendor = ((SystemImagePackage) pkg).getAddonVendor(); |
| addonTag = ((SystemImagePackage) pkg).getTag(); |
| } |
| |
| // Find a platform or addon that would satisfy the requirement. |
| |
| // First look in locally installed packages. |
| for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (expectedClass.isInstance(p)) { |
| if (v.equals(((IAndroidVersionProvider) p).getAndroidVersion())) { |
| if (addonVendor != null && addonTag != null && p instanceof AddonPackage) { |
| if (!((AddonPackage) p).getVendorId().equals(addonVendor.getId()) || |
| !((AddonPackage) p).getNameId().equals(addonTag.getId())) { |
| continue; |
| } |
| } |
| // We found one already installed. |
| return null; |
| } |
| } |
| } |
| } |
| |
| // Look in archives already scheduled for install |
| for (ArchiveInfo ai : outArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (expectedClass.isInstance(p)) { |
| if (v.equals(((IAndroidVersionProvider) p).getAndroidVersion())) { |
| if (addonVendor != null && addonTag != null && p instanceof AddonPackage) { |
| if (!((AddonPackage) p).getVendorId().equals(addonVendor.getId()) || |
| !((AddonPackage) p).getNameId().equals(addonTag.getId())) { |
| continue; |
| } |
| } |
| // The dependency is already scheduled for install, nothing else to do. |
| return ai; |
| } |
| } |
| } |
| } |
| |
| // Otherwise look in the selected archives. |
| if (selectedArchives != null) { |
| for (Archive a : selectedArchives) { |
| Package p = a.getParentPackage(); |
| if (expectedClass.isInstance(p)) { |
| if (v.equals(((IAndroidVersionProvider) p).getAndroidVersion())) { |
| if (addonVendor != null && addonTag != null && p instanceof AddonPackage) { |
| if (!((AddonPackage) p).getVendorId().equals(addonVendor.getId()) || |
| !((AddonPackage) p).getNameId().equals(addonTag.getId())) { |
| continue; |
| } |
| } |
| // It's not already in the list of things to install, so add it now |
| return insertArchive(a, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| |
| // Finally nothing matched, so let's look at all available remote packages |
| fetchRemotePackages(remotePkgs, remoteSources); |
| for (Package p : remotePkgs) { |
| if (expectedClass.isInstance(p)) { |
| if (v.equals(((IAndroidVersionProvider) p).getAndroidVersion())) { |
| if (addonVendor != null && addonTag != null && p instanceof AddonPackage) { |
| if (!((AddonPackage) p).getVendorId().equals(addonVendor.getId()) || |
| !((AddonPackage) p).getNameId().equals(addonTag.getId())) { |
| continue; |
| } |
| } |
| // It's not already in the list of things to install, so add the |
| // first compatible archive we can find. |
| for (Archive a : p.getArchives()) { |
| if (a.isCompatible()) { |
| return insertArchive(a, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| } |
| |
| // We end up here if nothing matches. We don't have a good platform to match. |
| // We need to indicate this addon depends on a missing platform archive |
| // so that it can be impossible to install later on. |
| return new MissingPlatformArchiveInfo(pkg.getAndroidVersion()); |
| } |
| |
| /** |
| * Resolves platform dependencies for extras. |
| * An extra depends on having a platform with a minimun API level. |
| * |
| * We try to return the highest API level available above the specified minimum. |
| * Note that installed packages have priority so if one installed platform satisfies |
| * the dependency, we'll use it even if there's a higher API platform available but |
| * not installed yet. |
| * |
| * Finds the platform dependency. If found, add it to the list of things to install. |
| * Returns the archive info dependency, if any. |
| */ |
| protected ArchiveInfo findMinApiLevelDependency( |
| IMinApiLevelDependency pkg, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| |
| int api = pkg.getMinApiLevel(); |
| |
| if (api == IMinApiLevelDependency.MIN_API_LEVEL_NOT_SPECIFIED) { |
| return null; |
| } |
| |
| // Find a platform that would satisfy the requirement. |
| |
| // First look in locally installed packages. |
| for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().isGreaterOrEqualThan(api)) { |
| // We found one already installed. |
| return null; |
| } |
| } |
| } |
| } |
| |
| // Look in archives already scheduled for install |
| int foundApi = 0; |
| ArchiveInfo foundAi = null; |
| |
| for (ArchiveInfo ai : outArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().isGreaterOrEqualThan(api)) { |
| if (api > foundApi) { |
| foundApi = api; |
| foundAi = ai; |
| } |
| } |
| } |
| } |
| } |
| |
| if (foundAi != null) { |
| // The dependency is already scheduled for install, nothing else to do. |
| return foundAi; |
| } |
| |
| // Otherwise look in the selected archives *or* available remote packages |
| // and takes the best out of the two sets. |
| foundApi = 0; |
| Archive foundArchive = null; |
| if (selectedArchives != null) { |
| for (Archive a : selectedArchives) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().isGreaterOrEqualThan(api)) { |
| if (api > foundApi) { |
| foundApi = api; |
| foundArchive = a; |
| } |
| } |
| } |
| } |
| } |
| |
| // Finally nothing matched, so let's look at all available remote packages |
| fetchRemotePackages(remotePkgs, remoteSources); |
| for (Package p : remotePkgs) { |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().isGreaterOrEqualThan(api)) { |
| if (api > foundApi) { |
| // It's not already in the list of things to install, so add the |
| // first compatible archive we can find. |
| for (Archive a : p.getArchives()) { |
| if (a.isCompatible()) { |
| foundApi = api; |
| foundArchive = a; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if (foundArchive != null) { |
| // It's not already in the list of things to install, so add it now |
| return insertArchive(foundArchive, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| |
| // We end up here if nothing matches. We don't have a good platform to match. |
| // We need to indicate this extra depends on a missing platform archive |
| // so that it can be impossible to install later on. |
| return new MissingPlatformArchiveInfo(new AndroidVersion(api, null /*codename*/)); |
| } |
| |
| /** |
| * Resolves platform dependencies for add-ons. |
| * An add-ons depends on having a platform with an exact specific API level. |
| * |
| * Finds the platform dependency. If found, add it to the list of things to install. |
| * Returns the archive info dependency, if any. |
| */ |
| public ArchiveInfo findExactApiLevelDependency( |
| IExactApiLevelDependency pkg, |
| Collection<ArchiveInfo> outArchives, |
| Collection<Archive> selectedArchives, |
| Collection<Package> remotePkgs, |
| SdkSource[] remoteSources, |
| ArchiveInfo[] localArchives) { |
| |
| int api = pkg.getExactApiLevel(); |
| |
| if (api == IExactApiLevelDependency.API_LEVEL_INVALID) { |
| return null; |
| } |
| |
| // Find a platform that would satisfy the requirement. |
| |
| // First look in locally installed packages. |
| for (ArchiveInfo ai : localArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().equals(api)) { |
| // We found one already installed. |
| return null; |
| } |
| } |
| } |
| } |
| |
| // Look in archives already scheduled for install |
| |
| for (ArchiveInfo ai : outArchives) { |
| Archive a = ai.getNewArchive(); |
| if (a != null) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().equals(api)) { |
| return ai; |
| } |
| } |
| } |
| } |
| |
| // Otherwise look in the selected archives. |
| if (selectedArchives != null) { |
| for (Archive a : selectedArchives) { |
| Package p = a.getParentPackage(); |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().equals(api)) { |
| // It's not already in the list of things to install, so add it now |
| return insertArchive(a, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| |
| // Finally nothing matched, so let's look at all available remote packages |
| fetchRemotePackages(remotePkgs, remoteSources); |
| for (Package p : remotePkgs) { |
| if (p instanceof PlatformPackage) { |
| if (((PlatformPackage) p).getAndroidVersion().equals(api)) { |
| // It's not already in the list of things to install, so add the |
| // first compatible archive we can find. |
| for (Archive a : p.getArchives()) { |
| if (a.isCompatible()) { |
| return insertArchive(a, |
| outArchives, |
| selectedArchives, |
| remotePkgs, |
| remoteSources, |
| localArchives, |
| true /*automated*/); |
| } |
| } |
| } |
| } |
| } |
| |
| // We end up here if nothing matches. We don't have a good platform to match. |
| // We need to indicate this extra depends on a missing platform archive |
| // so that it can be impossible to install later on. |
| return new MissingPlatformArchiveInfo(new AndroidVersion(api, null /*codename*/)); |
| } |
| |
| /** |
| * Fetch all remote packages only if really needed. |
| * <p/> |
| * This method takes a list of sources. Each source is only fetched once -- that is each |
| * source keeps the list of packages that we fetched from the remote XML file. If the list |
| * is null, it means this source has never been fetched so we'll do it once here. Otherwise |
| * we rely on the cached list of packages from this source. |
| * <p/> |
| * This method also takes a remote package list as input, which it will fill out. |
| * If a source has already been fetched, we'll add its packages to the remote package list |
| * if they are not already present. Otherwise, the source will be fetched and the packages |
| * added to the list. |
| * |
| * @param remotePkgs An in-out list of packages available from remote sources. |
| * This list must not be null. |
| * It can be empty or already contain some packages. |
| * @param remoteSources A list of available remote sources to fetch from. |
| */ |
| protected void fetchRemotePackages( |
| final Collection<Package> remotePkgs, |
| final SdkSource[] remoteSources) { |
| if (!remotePkgs.isEmpty()) { |
| return; |
| } |
| |
| // First check if there's any remote source we need to fetch. |
| // This will bring the task window, so we rather not display it unless |
| // necessary. |
| boolean needsFetch = false; |
| for (final SdkSource remoteSrc : remoteSources) { |
| Package[] pkgs = remoteSrc.getPackages(); |
| if (pkgs == null) { |
| // This source has never been fetched. We'll do it below. |
| needsFetch = true; |
| } else { |
| // This source has already been fetched and we know its package list. |
| // We still need to make sure all of its packages are present in the |
| // remotePkgs list. |
| |
| nextPackage: for (Package pkg : pkgs) { |
| for (Archive a : pkg.getArchives()) { |
| // Only add a package if it contains at least one compatible archive |
| // and is not already in the remote package list. |
| if (a.isCompatible()) { |
| if (!remotePkgs.contains(pkg)) { |
| remotePkgs.add(pkg); |
| continue nextPackage; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if (!needsFetch) { |
| return; |
| } |
| |
| final boolean forceHttp = mUpdaterData.getSettingsController().getSettings().getForceHttp(); |
| |
| mUpdaterData.getTaskFactory().start("Refresh Sources", new ITask() { |
| @Override |
| public void run(ITaskMonitor monitor) { |
| for (SdkSource remoteSrc : remoteSources) { |
| Package[] pkgs = remoteSrc.getPackages(); |
| |
| if (pkgs == null) { |
| remoteSrc.load(mUpdaterData.getDownloadCache(), monitor, forceHttp); |
| pkgs = remoteSrc.getPackages(); |
| } |
| |
| if (pkgs != null) { |
| nextPackage: for (Package pkg : pkgs) { |
| for (Archive a : pkg.getArchives()) { |
| // Only add a package if it contains at least one compatible archive |
| // and is not already in the remote package list. |
| if (a.isCompatible()) { |
| if (!remotePkgs.contains(pkg)) { |
| remotePkgs.add(pkg); |
| continue nextPackage; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| |
| /** |
| * A {@link LocalArchiveInfo} is an {@link ArchiveInfo} that wraps an already installed |
| * "local" package/archive. |
| * <p/> |
| * In this case, the "new Archive" is still expected to be non null and the |
| * "replaced Archive" is null. Installed archives are always accepted and never |
| * rejected. |
| * <p/> |
| * Dependencies are not set. |
| */ |
| private static class LocalArchiveInfo extends ArchiveInfo { |
| |
| public LocalArchiveInfo(Archive localArchive) { |
| super(localArchive, null /*replaced*/, null /*dependsOn*/); |
| } |
| |
| /** Installed archives are always accepted. */ |
| @Override |
| public boolean isAccepted() { |
| return true; |
| } |
| |
| /** Installed archives are never rejected. */ |
| @Override |
| public boolean isRejected() { |
| return false; |
| } |
| } |
| |
| /** |
| * A {@link MissingPlatformArchiveInfo} is an {@link ArchiveInfo} that represents a |
| * package/archive that we <em>really</em> need as a dependency but that we don't have. |
| * <p/> |
| * This is currently used for addons and extras in case we can't find a matching base platform. |
| * <p/> |
| * This kind of archive has specific properties: the new archive to install is null, |
| * there are no dependencies and no archive is being replaced. The info can never be |
| * accepted and is always rejected. |
| */ |
| private static class MissingPlatformArchiveInfo extends ArchiveInfo { |
| |
| private final AndroidVersion mVersion; |
| |
| /** |
| * Constructs a {@link MissingPlatformArchiveInfo} that will indicate the |
| * given platform version is missing. |
| */ |
| public MissingPlatformArchiveInfo(AndroidVersion version) { |
| super(null /*newArchive*/, null /*replaced*/, null /*dependsOn*/); |
| mVersion = version; |
| } |
| |
| /** Missing archives are never accepted. */ |
| @Override |
| public boolean isAccepted() { |
| return false; |
| } |
| |
| /** Missing archives are always rejected. */ |
| @Override |
| public boolean isRejected() { |
| return true; |
| } |
| |
| @Override |
| public String getShortDescription() { |
| return String.format("Missing SDK Platform Android%1$s, API %2$d", |
| mVersion.isPreview() ? " Preview" : "", |
| mVersion.getApiLevel()); |
| } |
| } |
| |
| /** |
| * A {@link MissingArchiveInfo} is an {@link ArchiveInfo} that represents a |
| * package/archive that we <em>really</em> need as a dependency but that we don't have. |
| * <p/> |
| * This is currently used for extras in case we can't find a matching tool revision |
| * or when a platform-tool is missing. |
| * <p/> |
| * This kind of archive has specific properties: the new archive to install is null, |
| * there are no dependencies and no archive is being replaced. The info can never be |
| * accepted and is always rejected. |
| */ |
| private static class MissingArchiveInfo extends ArchiveInfo { |
| |
| private final FullRevision mRevision; |
| private final String mTitle; |
| |
| public static final String TITLE_TOOL = "Tools"; |
| public static final String TITLE_PLATFORM_TOOL = "Platform-tools"; |
| |
| /** |
| * Constructs a {@link MissingPlatformArchiveInfo} that will indicate the |
| * given platform version is missing. |
| * |
| * @param title Typically "Tools" or "Platform-tools". |
| * @param revision The required revision. |
| */ |
| public MissingArchiveInfo(String title, FullRevision revision) { |
| super(null /*newArchive*/, null /*replaced*/, null /*dependsOn*/); |
| mTitle = title; |
| mRevision = revision; |
| } |
| |
| /** Missing archives are never accepted. */ |
| @Override |
| public boolean isAccepted() { |
| return false; |
| } |
| |
| /** Missing archives are always rejected. */ |
| @Override |
| public boolean isRejected() { |
| return true; |
| } |
| |
| @Override |
| public String getShortDescription() { |
| return String.format("Missing Android SDK %1$s, revision %2$s", |
| mTitle, |
| mRevision.toShortString()); |
| } |
| } |
| } |
