com.android.sdklib.internal.repository.updater.PkgItem Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of sdklib Show documentation
Show all versions of sdklib Show documentation
A library to parse and download the Android SDK.
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.sdklib.internal.repository.updater;
import com.android.annotations.Nullable;
import com.android.sdklib.AndroidVersion;
import com.android.sdklib.internal.repository.IDescription;
import com.android.sdklib.internal.repository.archives.Archive;
import com.android.sdklib.internal.repository.packages.IAndroidVersionProvider;
import com.android.sdklib.internal.repository.packages.Package;
import com.android.sdklib.internal.repository.packages.Package.UpdateInfo;
import com.android.sdklib.internal.repository.sources.SdkSource;
import com.android.sdklib.repository.FullRevision;
/**
* A {@link PkgItem} represents one main {@link Package} combined with its state
* and an optional update package.
*
* The main package is final and cannot change since it's what "defines" this PkgItem.
* The state or update package can change later.
*/
public class PkgItem implements Comparable {
private final PkgState mState;
private final Package mMainPkg;
private Package mUpdatePkg;
private boolean mChecked;
/**
* The state of the a given {@link PkgItem}, that is the relationship between
* a given remote package and the local repository.
*/
public enum PkgState {
// Implementation detail: if this is changed then PackageDiffLogic#STATES
// and PackageDiffLogic#processSource() need to be changed accordingly.
/**
* Package is locally installed and may or may not have an update.
*/
INSTALLED,
/**
* There's a new package available on the remote site that isn't installed locally.
*/
NEW
}
/**
* Create a new {@link PkgItem} for this main package.
* The main package is final and cannot change since it's what "defines" this PkgItem.
* The state or update package can change later.
*/
public PkgItem(Package mainPkg, PkgState state) {
mMainPkg = mainPkg;
mState = state;
assert mMainPkg != null;
}
public boolean isObsolete() {
return mMainPkg.isObsolete();
}
public boolean isChecked() {
return mChecked;
}
public void setChecked(boolean checked) {
mChecked = checked;
}
public Package getUpdatePkg() {
return mUpdatePkg;
}
public boolean hasUpdatePkg() {
return mUpdatePkg != null;
}
public String getName() {
return mMainPkg.getListDescription();
}
public FullRevision getRevision() {
return mMainPkg.getRevision();
}
/**
* @deprecated Use {@link #getMainPackage()} with the {@link IDescription} interface instead.
*/
@Deprecated
public String getDescription() {
return mMainPkg.getLongDescription();
}
public Package getMainPackage() {
return mMainPkg;
}
public PkgState getState() {
return mState;
}
public SdkSource getSource() {
return mMainPkg.getParentSource();
}
@Nullable
public AndroidVersion getAndroidVersion() {
return mMainPkg instanceof IAndroidVersionProvider ?
((IAndroidVersionProvider) mMainPkg).getAndroidVersion() :
null;
}
public Archive[] getArchives() {
return mMainPkg.getArchives();
}
@Override
public int compareTo(PkgItem pkg) {
return getMainPackage().compareTo(pkg.getMainPackage());
}
/**
* Returns true if this package or its updating packages contains
* the exact given archive.
* Important: This compares object references, not object equality.
*/
public boolean hasArchive(Archive archive) {
if (mMainPkg.hasArchive(archive)) {
return true;
}
if (mUpdatePkg != null && mUpdatePkg.hasArchive(archive)) {
return true;
}
return false;
}
/**
* Returns true if the main package has at least one archive
* compatible with the current platform.
*/
public boolean hasCompatibleArchive() {
return mMainPkg.hasCompatibleArchive();
}
/**
* Checks whether the main packages are of the same type and are
* not an update of each other and have the same revision number.
*/
public boolean isSameMainPackageAs(Package pkg) {
if (mMainPkg.canBeUpdatedBy(pkg) == UpdateInfo.NOT_UPDATE) {
// package revision numbers must match
return mMainPkg.getRevision().equals(pkg.getRevision());
}
return false;
}
/**
* Checks whether the update packages are of the same type and are
* not an update of each other and have the same revision numbers.
*/
public boolean isSameUpdatePackageAs(Package pkg) {
if (mUpdatePkg != null && mUpdatePkg.canBeUpdatedBy(pkg) == UpdateInfo.NOT_UPDATE) {
// package revision numbers must match
return mUpdatePkg.getRevision().equals(pkg.getRevision());
}
return false;
}
/**
* Checks whether too {@link PkgItem} are the same.
* This checks both items have the same state, both main package are similar
* and that they have the same updating packages.
*/
public boolean isSameItemAs(PkgItem item) {
if (this == item) {
return true;
}
boolean same = this.mState == item.mState;
if (same) {
same = isSameMainPackageAs(item.getMainPackage());
}
if (same) {
// check updating packages are the same
Package p1 = this.mUpdatePkg;
Package p2 = item.getUpdatePkg();
same = (p1 == p2) || (p1 == null && p2 == null) || (p1 != null && p2 != null);
if (same && p1 != null) {
same = p1.canBeUpdatedBy(p2) == UpdateInfo.NOT_UPDATE;
}
}
return same;
}
/**
* Equality is defined as {@link #isSameItemAs(PkgItem)}: state, main package
* and update package must be the similar.
*/
@Override
public boolean equals(Object obj) {
return (obj instanceof PkgItem) && this.isSameItemAs((PkgItem) obj);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((mState == null) ? 0 : mState.hashCode());
result = prime * result + ((mMainPkg == null) ? 0 : mMainPkg.hashCode());
result = prime * result + ((mUpdatePkg == null) ? 0 : mUpdatePkg.hashCode());
return result;
}
/**
* Check whether the 'pkg' argument is an update for this package.
* If it is, record it as an updating package.
* If there's already an updating package, only keep the most recent update.
* Returns true if it is update (even if there was already an update and this
* ended up not being the most recent), false if incompatible or not an update.
*
* This should only be used for installed packages.
*/
public boolean mergeUpdate(Package pkg) {
if (mUpdatePkg == pkg) {
return true;
}
if (mMainPkg.canBeUpdatedBy(pkg) == UpdateInfo.UPDATE) {
if (mUpdatePkg == null) {
mUpdatePkg = pkg;
} else if (mUpdatePkg.canBeUpdatedBy(pkg) == UpdateInfo.UPDATE) {
// If we have more than one, keep only the most recent update
mUpdatePkg = pkg;
}
return true;
}
return false;
}
public void removeUpdate() {
mUpdatePkg = null;
}
/** Returns a string representation of this item, useful when debugging. */
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('<');
if (mChecked) {
sb.append(" * "); //$NON-NLS-1$
}
sb.append(mState.toString());
if (mMainPkg != null) {
sb.append(", pkg:"); //$NON-NLS-1$
sb.append(mMainPkg.toString());
}
if (mUpdatePkg != null) {
sb.append(", updated by:"); //$NON-NLS-1$
sb.append(mUpdatePkg.toString());
}
sb.append('>');
return sb.toString();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy