SdkManager.java

/*
 * Copyright (C) 2008 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;

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.prefs.AndroidLocation;
import com.android.prefs.AndroidLocation.AndroidLocationException;
import com.android.sdklib.internal.androidTarget.AddOnTarget;
import com.android.sdklib.internal.androidTarget.PlatformTarget;
import com.android.sdklib.repository.FullRevision;
import com.android.sdklib.repository.descriptors.IPkgDesc;
import com.android.sdklib.repository.descriptors.PkgType;
import com.android.sdklib.repository.local.LocalExtraPkgInfo;
import com.android.sdklib.repository.local.LocalPkgInfo;
import com.android.sdklib.repository.local.LocalSdk;
import com.android.utils.ILogger;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * The SDK manager parses the SDK folder and gives access to the content.
 * @see PlatformTarget
 * @see AddOnTarget
 */
public class SdkManager {

    @SuppressWarnings("unused")
    private static final boolean DEBUG = System.getenv("SDKMAN_DEBUG") != null;        //$NON-NLS-1$

    /** Preference file containing the usb ids for adb */
    private static final String ADB_INI_FILE = "adb_usb.ini";                          //$NON-NLS-1$
       //0--------90--------90--------90--------90--------90--------90--------90--------9
       private static final String ADB_INI_HEADER =
        "# ANDROID 3RD PARTY USB VENDOR ID LIST -- DO NOT EDIT.\n" +                   //$NON-NLS-1$
        "# USE 'android update adb' TO GENERATE.\n" +                                  //$NON-NLS-1$
        "# 1 USB VENDOR ID PER LINE.\n";                                               //$NON-NLS-1$

    /** Embedded reference to the new local SDK object. */
    private final LocalSdk mLocalSdk;

    /**
     * Create a new {@link SdkManager} instance.
     * External users should use {@link #createManager(String, ILogger)}.
     *
     * @param osSdkPath the location of the SDK.
     */
    @VisibleForTesting(visibility=Visibility.PRIVATE)
    protected SdkManager(@NonNull String osSdkPath) {
        mLocalSdk = new LocalSdk(new File(osSdkPath));
    }

    /**
     * Creates an @{linkplain SdkManager} for an existing @{link LocalSdk}.
     *
     * @param localSdk the SDK to use with the SDK manager
     */
    private SdkManager(@NonNull LocalSdk localSdk) {
        mLocalSdk = localSdk;
    }

    /**
     * Creates an {@link SdkManager} for a given sdk location.
     * @param osSdkPath the location of the SDK.
     * @param log the ILogger object receiving warning/error from the parsing.
     * @return the created {@link SdkManager} or null if the location is not valid.
     */
    @Nullable
    public static SdkManager createManager(
            @NonNull String osSdkPath,
            @NonNull ILogger log) {
        try {
            SdkManager manager = new SdkManager(osSdkPath);
            manager.reloadSdk(log);

            return manager;
        } catch (Throwable throwable) {
            log.error(throwable, "Error parsing the sdk.");
        }

        return null;
    }

    /**
     * Creates an @{linkplain SdkManager} for an existing @{link LocalSdk}.
     *
     * @param localSdk the SDK to use with the SDK manager
     */
    @NonNull
    public static SdkManager createManager(@NonNull LocalSdk localSdk) {
        return new SdkManager(localSdk);
    }

    @NonNull
    public LocalSdk getLocalSdk() {
        return mLocalSdk;
    }

    /**
     * Reloads the content of the SDK.
     *
     * @param log the ILogger object receiving warning/error from the parsing.
     */
    public void reloadSdk(@NonNull ILogger log) {
        mLocalSdk.clearLocalPkg(PkgType.PKG_ALL);
    }

    /**
     * Checks whether any of the SDK platforms/add-ons/build-tools have changed on-disk
     * since we last loaded the SDK. This does not reload the SDK nor does it
     * change the underlying targets.
     *
     * @return True if at least one directory or source.prop has changed.
     */
    public boolean hasChanged() {
        return hasChanged(null);
    }

    /**
     * Checks whether any of the SDK platforms/add-ons/build-tools have changed on-disk
     * since we last loaded the SDK. This does not reload the SDK nor does it
     * change the underlying targets.
     *
     * @param log An optional logger used to print verbose info on what changed. Can be null.
     * @return True if at least one directory or source.prop has changed.
     */
    public boolean hasChanged(@Nullable ILogger log) {
        return mLocalSdk.hasChanged(EnumSet.of(PkgType.PKG_PLATFORM,
                                               PkgType.PKG_ADDON,
                                               PkgType.PKG_BUILD_TOOLS));
    }

    /**
     * Returns the location of the SDK.
     */
    @NonNull
    public String getLocation() {
        File f = mLocalSdk.getLocation();
        // Our LocalSdk is created with a file path, so we know the location won't be null.
        assert f != null;
        return f.getPath();
    }

    /**
     * Returns the targets (platforms & addons) that are available in the SDK.
     * The target list is created on demand the first time then cached.
     * It will not refreshed unless {@link #reloadSdk(ILogger)} is called.
     * <p/>
     * The array can be empty but not null.
     */
    @NonNull
    public IAndroidTarget[] getTargets() {
        return mLocalSdk.getTargets();
    }

    /**
     * Returns an unmodifiable set of known build-tools revisions. Can be empty but not null.
     * Deprecated. I don't think anything uses this.
     */
    @Deprecated
    @NonNull
    public Set<FullRevision> getBuildTools() {
        LocalPkgInfo[] pkgs = mLocalSdk.getPkgsInfos(PkgType.PKG_BUILD_TOOLS);
        TreeSet<FullRevision> bt = new TreeSet<FullRevision>();
        for (LocalPkgInfo pkg : pkgs) {
            IPkgDesc d = pkg.getDesc();
            if (d.hasFullRevision()) {
                bt.add(d.getFullRevision());
            }
        }
        return Collections.unmodifiableSet(bt);
    }

    /**
     * Returns the highest build-tool revision known. Can be null.
     *
     * @return The highest build-tool revision known, or null.
     */
    @Nullable
    public BuildToolInfo getLatestBuildTool() {
        return mLocalSdk.getLatestBuildTool();
    }

    /**
     * Returns the {@link BuildToolInfo} for the given revision.
     *
     * @param revision The requested revision.
     * @return A {@link BuildToolInfo}. Can be null if {@code revision} is null or is
     *  not part of the known set returned by {@link #getBuildTools()}.
     */
    @Nullable
    public BuildToolInfo getBuildTool(@Nullable FullRevision revision) {
        return mLocalSdk.getBuildTool(revision);
    }

    /**
     * Returns a target from a hash that was generated by {@link IAndroidTarget#hashString()}.
     *
     * @param hash the {@link IAndroidTarget} hash string.
     * @return The matching {@link IAndroidTarget} or null.
     */
    @Nullable
    public IAndroidTarget getTargetFromHashString(@Nullable String hash) {
        return mLocalSdk.getTargetFromHashString(hash);
    }

    /**
     * Updates adb with the USB devices declared in the SDK add-ons.
     * @throws AndroidLocationException
     * @throws IOException
     */
    public void updateAdb() throws AndroidLocationException, IOException {
        FileWriter writer = null;
        try {
            // get the android prefs location to know where to write the file.
            File adbIni = new File(AndroidLocation.getFolder(), ADB_INI_FILE);
            writer = new FileWriter(adbIni);

            // first, put all the vendor id in an HashSet to remove duplicate.
            HashSet<Integer> set = new HashSet<Integer>();
            IAndroidTarget[] targets = getTargets();
            for (IAndroidTarget target : targets) {
                if (target.getUsbVendorId() != IAndroidTarget.NO_USB_ID) {
                    set.add(target.getUsbVendorId());
                }
            }

            // write file header.
            writer.write(ADB_INI_HEADER);

            // now write the Id in a text file, one per line.
            for (Integer i : set) {
                writer.write(String.format("0x%04x\n", i));                            //$NON-NLS-1$
            }
        } finally {
            if (writer != null) {
                writer.close();
            }
        }
    }

    /**
     * Returns the greatest {@link LayoutlibVersion} found amongst all platform
     * targets currently loaded in the SDK.
     * <p/>
     * We only started recording Layoutlib Versions recently in the platform meta data
     * so it's possible to have an SDK with many platforms loaded but no layoutlib
     * version defined.
     *
     * @return The greatest {@link LayoutlibVersion} or null if none is found.
     * @deprecated This does NOT solve the right problem and will be changed later.
     */
    @Deprecated
    @Nullable
    public LayoutlibVersion getMaxLayoutlibVersion() {
        LayoutlibVersion maxVersion = null;

        for (IAndroidTarget target : getTargets()) {
            if (target instanceof PlatformTarget) {
                LayoutlibVersion lv = ((PlatformTarget) target).getLayoutlibVersion();
                if (lv != null) {
                    if (maxVersion == null || lv.compareTo(maxVersion) > 0) {
                        maxVersion = lv;
                    }
                }
            }
        }

        return maxVersion;
    }

    /**
     * Returns a map of the <em>root samples directories</em> located in the SDK/extras packages.
     * No guarantee is made that the extras' samples directory actually contain any valid samples.
     * The only guarantee is that the root samples directory actually exists.
     * The map is { File: Samples root directory => String: Extra package display name. }
     *
     * @return A non-null possibly empty map of extra samples directories and their associated
     *   extra package display name.
     */
    @NonNull
    public Map<File, String> getExtraSamples() {

        LocalPkgInfo[] pkgsInfos = mLocalSdk.getPkgsInfos(PkgType.PKG_EXTRA);
        Map<File, String> samples = new HashMap<File, String>();

        for (LocalPkgInfo info : pkgsInfos) {
            assert info instanceof LocalExtraPkgInfo;

            File root = info.getLocalDir();
            File path = new File(root, SdkConstants.FD_SAMPLES);
            if (path.isDirectory()) {
                samples.put(path, info.getListDescription());
                continue;
            }
            // Some old-style extras simply have a single "sample" directory.
            // Accept it if it contains an AndroidManifest.xml.
            path = new File(root, SdkConstants.FD_SAMPLE);
            if (path.isDirectory() &&
                    new File(path, SdkConstants.FN_ANDROID_MANIFEST_XML).isFile()) {
                samples.put(path, info.getListDescription());
            }
        }

        return samples;
    }

    /**
     * Returns a map of all the extras found in the <em>local</em> SDK with their major revision.
     * <p/>
     * Map keys are in the form "vendor-id/path-id". These ids uniquely identify an extra package.
     * The version is the incremental integer major revision of the package.
     *
     * @return A non-null possibly empty map of { string "vendor/path" => integer major revision }
     * @deprecated Starting with add-on schema 6, extras can have full revisions instead of just
     *   major revisions. This API only returns the major revision. Callers should be modified
     *   to use the new {code LocalSdk.getPkgInfo(PkgType.PKG_EXTRAS)} API instead.
     */
    @Deprecated
    @NonNull
    public Map<String, Integer> getExtrasVersions() {
        LocalPkgInfo[] pkgsInfos = mLocalSdk.getPkgsInfos(PkgType.PKG_EXTRA);
        Map<String, Integer> extraVersions = new TreeMap<String, Integer>();

        for (LocalPkgInfo info : pkgsInfos) {
            assert info instanceof LocalExtraPkgInfo;
            if (info instanceof LocalExtraPkgInfo) {
                LocalExtraPkgInfo ei = (LocalExtraPkgInfo) info;
                IPkgDesc d = ei.getDesc();
                String vendor = d.getVendor().getId();
                String path   = d.getPath();
                int majorRev  = d.getFullRevision().getMajor();

                extraVersions.put(vendor + '/' + path, majorRev);
            }
        }

        return extraVersions;
    }

    /** Returns the platform tools version if installed, null otherwise. */
    @Nullable
    public String getPlatformToolsVersion() {
        LocalPkgInfo info = mLocalSdk.getPkgInfo(PkgType.PKG_PLATFORM_TOOLS);
        IPkgDesc d = info == null ? null : info.getDesc();
        if (d != null && d.hasFullRevision()) {
            return d.getFullRevision().toShortString();
        }

        return null;
    }


    // -------------

    public static class LayoutlibVersion implements Comparable<LayoutlibVersion> {
        private final int mApi;
        private final int mRevision;

        public static final int NOT_SPECIFIED = 0;

        public LayoutlibVersion(int api, int revision) {
            mApi = api;
            mRevision = revision;
        }

        public int getApi() {
            return mApi;
        }

        public int getRevision() {
            return mRevision;
        }

        @Override
        public int compareTo(@NonNull LayoutlibVersion rhs) {
            boolean useRev = this.mRevision > NOT_SPECIFIED && rhs.mRevision > NOT_SPECIFIED;
            int lhsValue = (this.mApi << 16) + (useRev ? this.mRevision : 0);
            int rhsValue = (rhs.mApi  << 16) + (useRev ? rhs.mRevision  : 0);
            return lhsValue - rhsValue;
        }
    }
}