diff options
Diffstat (limited to 'sched/src/com/android/sched/util')
4 files changed, 334 insertions, 0 deletions
diff --git a/sched/src/com/android/sched/util/SubReleaseKind.java b/sched/src/com/android/sched/util/SubReleaseKind.java new file mode 100644 index 0000000..3d1415b --- /dev/null +++ b/sched/src/com/android/sched/util/SubReleaseKind.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2015 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.sched.util; + +import javax.annotation.Nonnull; + +/** + * The kind of sub-release. + */ +public enum SubReleaseKind { + ENGINEERING, + PRE_ALPHA, + ALPHA, + BETA, + CANDIDATE, + RELEASE; + + public boolean isMoreStableThan(@Nonnull SubReleaseKind other) throws UncomparableSubReleaseKind { + if ((this == ENGINEERING && other != ENGINEERING) + || (this != ENGINEERING && other == ENGINEERING)) { + throw new UncomparableSubReleaseKind(this + " is not comparable with " + other); + } + return ordinal() > other.ordinal(); + } + +}
\ No newline at end of file diff --git a/sched/src/com/android/sched/util/UncomparableSubReleaseKind.java b/sched/src/com/android/sched/util/UncomparableSubReleaseKind.java new file mode 100644 index 0000000..5d6647e --- /dev/null +++ b/sched/src/com/android/sched/util/UncomparableSubReleaseKind.java @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2015 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.sched.util; + +import javax.annotation.Nonnull; + +/** + * Exception that means that sub release kind are not comparable. + */ +public class UncomparableSubReleaseKind extends Exception { + + private static final long serialVersionUID = 1L; + + public UncomparableSubReleaseKind(@Nonnull String message) { + super(message); + } +} diff --git a/sched/src/com/android/sched/util/UncomparableVersion.java b/sched/src/com/android/sched/util/UncomparableVersion.java new file mode 100644 index 0000000..8de26a1 --- /dev/null +++ b/sched/src/com/android/sched/util/UncomparableVersion.java @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2015 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.sched.util; + +import javax.annotation.Nonnull; + +/** + * Exception that means that versions are not comparable. + */ +public class UncomparableVersion extends Exception { + + private static final long serialVersionUID = 1L; + + public UncomparableVersion(@Nonnull String message) { + super(message); + } +} diff --git a/sched/src/com/android/sched/util/Version.java b/sched/src/com/android/sched/util/Version.java new file mode 100644 index 0000000..c1b7746 --- /dev/null +++ b/sched/src/com/android/sched/util/Version.java @@ -0,0 +1,232 @@ +/* + * Copyright (C) 2015 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.sched.util; + +import com.android.sched.util.findbugs.SuppressFBWarnings; +import com.android.sched.util.log.LoggerFactory; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; +import java.util.logging.Logger; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; + +/** + * A class describing version, release, build & code. + */ +public class Version { + @Nonnull + private static final String FILE_SUFFIX = "-version.properties"; + @Nonnull + private static final Logger logger = LoggerFactory.getLogger(); + + @Nonnull + private String version; + @Nonnull + private String releaseName; + private int releaseCode; + @Nonnull + private SubReleaseKind subReleaseKind; + private int subReleaseCode; + @CheckForNull + private String buildId; + @CheckForNull + private String codeBase; + + // FINDBUGS Fields are initialized by init() + @SuppressFBWarnings("NP_NONNULL_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR") + public Version(@Nonnull String name, @Nonnull ClassLoader loader) + throws IOException { + String resourceName = name + FILE_SUFFIX; + InputStream resourceStream = loader.getResourceAsStream(resourceName); + if (resourceStream == null) { + throw new FileNotFoundException(resourceName); + } + try { + init(resourceStream); + } finally { + try { + resourceStream.close(); + } catch (IOException e) { + // + } + } + } + + // FINDBUGS Fields are initialized by init() + @SuppressFBWarnings("NP_NONNULL_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR") + public Version(@Nonnull InputStream is) throws IOException { + init(is); + } + + public Version(int releaseCode, int subReleaseCode, @Nonnull SubReleaseKind subReleaseKind) { + this.version = "Unknown"; + this.releaseName = "Unknown"; + this.releaseCode = releaseCode; + this.subReleaseCode = subReleaseCode; + this.subReleaseKind = subReleaseKind; + } + + private void init(InputStream is) throws IOException { + Properties prop = new Properties(); + prop.load(is); + + long versionFileVersion = Long.parseLong(prop.getProperty("version-file.version.code")); + assert versionFileVersion >= 1; + + version = prop.getProperty("version"); + assert version != null; + + releaseName = prop.getProperty("version.release.name"); + assert releaseName != null; + + releaseCode = Integer.parseInt(prop.getProperty("version.release.code")); + + subReleaseCode = Integer.parseInt(prop.getProperty("version.sub-release.code")); + + subReleaseKind = + SubReleaseKind.valueOf(SubReleaseKind.class, prop.getProperty("version.sub-release.kind")); + + buildId = prop.getProperty("version.buildid"); + if (buildId != null && buildId.isEmpty()) { + buildId = null; + } + codeBase = prop.getProperty("version.sha"); + if (codeBase != null && codeBase.isEmpty()) { + codeBase = null; + } + + if (codeBase == null || buildId == null) { + subReleaseKind = SubReleaseKind.ENGINEERING; + } + } + + @Nonnull + public String getVersion() { + return version; + } + + @Nonnull + public String getReleaseName() { + return releaseName; + } + + public int getReleaseCode() { + return releaseCode; + } + + @Nonnull + public SubReleaseKind getSubReleaseKind() { + return subReleaseKind; + } + + public int getSubReleaseCode() { + return subReleaseCode; + } + + @CheckForNull + public String getBuildId() { + return buildId; + } + + @CheckForNull + public String getCodeBase() { + return codeBase; + } + + @Nonnull + public String getVerboseVersion() { + return version + " '" + releaseName + "' (" + + (buildId != null ? buildId : "engineering") + + (codeBase != null ? (' ' + codeBase) : "") + ")"; + } + + public boolean isOlderThan(@Nonnull Version other) throws UncomparableVersion { + return compareTo(other) < 0; + } + + public boolean isOlderOrEqualsThan(@Nonnull Version other) throws UncomparableVersion { + return compareTo(other) <= 0; + } + + public boolean isNewerThan(@Nonnull Version other) throws UncomparableVersion { + return compareTo(other) > 0; + } + + public boolean isNewerOrEqualsThan(@Nonnull Version other) throws UncomparableVersion { + return compareTo(other) >= 0; + } + + @Override + public final boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof Version) { + Version other = (Version) obj; + return version.equals(other.version) + && releaseName.equals(other.releaseName) + && releaseCode == other.releaseCode + && subReleaseCode == other.subReleaseCode + && subReleaseKind == other.subReleaseKind + && ((buildId != null && buildId.equals(other.buildId)) + || (buildId == null && other.buildId == null)) + && ((codeBase != null && codeBase.equals(other.codeBase)) + || (codeBase == null && other.codeBase == null)); + } + return false; + } + + @Override + public final int hashCode() { + return version.hashCode() ^ releaseName.hashCode() ^ (releaseCode * 7) ^ (subReleaseCode * 17) + ^ subReleaseKind.hashCode() ^ (buildId != null ? buildId.hashCode() : 0) + ^ (codeBase != null ? codeBase.hashCode() : 0); + } + + int compareTo(@Nonnull Version other) throws UncomparableVersion { + if ((subReleaseKind == SubReleaseKind.ENGINEERING + && other.getSubReleaseKind() != SubReleaseKind.ENGINEERING) + || releaseCode < 0 + || subReleaseCode < 0 + || (subReleaseKind != SubReleaseKind.ENGINEERING + && other.getSubReleaseKind() == SubReleaseKind.ENGINEERING) + || other.getReleaseCode() < 0 + || other.getSubReleaseCode() < 0) { + throw new UncomparableVersion( + getVerboseVersion() + " is not comparable with " + other.getVerboseVersion()); + } + + if (this.releaseCode > other.getReleaseCode() || ( + this.releaseCode == other.getReleaseCode() + && this.subReleaseCode > other.getSubReleaseCode())) { + return 1; + } + + + if (this.releaseCode < other.getReleaseCode() || ( + this.releaseCode == other.getReleaseCode() + && this.subReleaseCode < other.getSubReleaseCode())) { + return -1; + } + + return 0; + } +}
\ No newline at end of file |