import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * Converts a string representation of an hexadecimal ID into an int.
 * @param value the string to convert.
 * @return the int value, or {@link IAndroidTarget#NO_USB_ID} if the conversion failed.
 */
private int convertId(@Nullable String value) {
    if (value != null && !value.isEmpty()) {
        if (PATTERN_USB_IDS.matcher(value).matches()) {
            String v = value.substring(2);
            try {
                return Integer.parseInt(v, 16);
            } catch (NumberFormatException e) {
                // this shouldn't happen since we check the pattern above, but this is safer.
                // the method will return 0 below.
            }
        }
    }

    return IAndroidTarget.NO_USB_ID;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * 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 #clearLocalPkg} is called to clear platforms
 * and/or add-ons.
 * <p/>
 * The array can be empty but not null.
 */
@NonNull
public IAndroidTarget[] getTargets() {
    synchronized (mLocalPackages) {
        if (mReloadTargets) {
            LocalPkgInfo[] pkgsInfos = getPkgsInfos(EnumSet.of(PkgType.PKG_PLATFORM,
                                                               PkgType.PKG_ADDON));
            int n = pkgsInfos.length;
            mCachedTargets.clear();
            for (int i = 0; i < n; i++) {
                LocalPkgInfo info = pkgsInfos[i];
                assert info instanceof LocalPlatformPkgInfo;
                if (info instanceof LocalPlatformPkgInfo) {
                    IAndroidTarget target = ((LocalPlatformPkgInfo) info).getAndroidTarget();
                    if (target != null) {
                        mCachedTargets.add(target);
                    }
                }
            }
        }
        return mCachedTargets.toArray(new IAndroidTarget[mCachedTargets.size()]);
    }
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * Installs the project icons.
 * @param resourceFolder the resource folder
 * @param target the target of the project.
 * @return true if any icon was installed.
 */
private boolean installIcons(File resourceFolder, IAndroidTarget target)
        throws ProjectCreateException {
    // query the target for its template directory
    String templateFolder = target.getPath(IAndroidTarget.TEMPLATES);

    boolean installedIcon = false;

    installedIcon |= installIcon(templateFolder, "ic_launcher_xhdpi.png", resourceFolder,
            "drawable-xhdpi");
    installedIcon |= installIcon(templateFolder, "ic_launcher_hdpi.png", resourceFolder,
            "drawable-hdpi");
    installedIcon |= installIcon(templateFolder, "ic_launcher_mdpi.png", resourceFolder,
            "drawable-mdpi");
    installedIcon |= installIcon(templateFolder, "ic_launcher_ldpi.png", resourceFolder,
            "drawable-ldpi");

    return installedIcon;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@Nullable
@Override
public File getDefaultSkin() {
    // only one skin? easy.
    if (mSkins.length == 1) {
        return mSkins[0];
    }

    // look for the skin name in the platform props
    String skinName = mProperties.get(SdkConstants.PROP_SDK_DEFAULT_SKIN);
    if (skinName == null) {
        // otherwise try to find a good default.
        if (mVersion.getApiLevel() >= 4) {
            // at this time, this is the default skin for all older platforms that had 2+ skins.
            skinName = "WVGA800";                                       //$NON-NLS-1$
        } else {
            skinName = "HVGA"; // this is for 1.5 and earlier.          //$NON-NLS-1$
        }
    }

    return new File(getFile(IAndroidTarget.SKINS), skinName);
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@Override
public boolean canRunOn(IAndroidTarget target) {
    // basic test
    if (target == this) {
        return true;
    }

    // if the platform has a codename (ie it's a preview of an upcoming platform), then
    // both platforms must be exactly identical.
    if (mVersion.getCodename() != null) {
        return mVersion.equals(target.getVersion());
    }

    // target is compatible wit the receiver as long as its api version number is greater or
    // equal.
    return target.getVersion().getApiLevel() >= mVersion.getApiLevel();
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@Override
public int compareTo(IAndroidTarget target) {
    // quick check.
    if (this == target) {
        return 0;
    }

    int versionDiff = mVersion.compareTo(target.getVersion());

    // only if the version are the same do we care about add-ons.
    if (versionDiff == 0) {
        // platforms go before add-ons.
        if (target.isPlatform() == false) {
            return -1;
        }
    }

    return versionDiff;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
private SamplePackage(IAndroidTarget target, Properties props) {
    super(  null,                                   //source
            props,                                  //properties
            0,                                      //revision will be taken from props
            null,                                   //license
            null,                                   //description
            null,                                   //descUrl
            target.getPath(IAndroidTarget.SAMPLES)  //archiveOsPath
            );

    mVersion = target.getVersion();

    mMinApiLevel = getPropertyInt(props, PkgProps.SAMPLE_MIN_API_LEVEL,
                                         MIN_API_LEVEL_NOT_SPECIFIED);

    mPkgDesc = PkgDesc.Builder
            .newSample(mVersion,
                      (MajorRevision) getRevision(),
                      getMinToolsRevision())
            .setDescriptions(this)
            .create();
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@VisibleForTesting(visibility=Visibility.PRIVATE)
protected PlatformPackage(@Nullable SdkSource source,
                          @NonNull IAndroidTarget target,
                          @Nullable Properties props) {
    super(  source,                     //source
            props,                      //properties
            target.getRevision(),       //revision
            null,                       //license
            target.getDescription(),    //description
            null,                       //descUrl
            target.getLocation()        //archiveOsPath
            );

    mVersion = target.getVersion();
    mVersionName  = target.getVersionName();
    mLayoutlibVersion = new LayoutlibVersionMixin(props);
    mIncludedAbi = props == null ? null : props.getProperty(PkgProps.PLATFORM_INCLUDED_ABI);

    mPkgDesc = PkgDesc.Builder
            .newPlatform(mVersion,
                         (MajorRevision) getRevision(),
                         getMinToolsRevision())
            .setDescriptions(this)
            .create();
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * Computes a potential installation folder if an archive of this package were
 * to be installed right away in the given SDK root.
 * <p/>
 * A platform package is typically installed in SDK/platforms/android-"version".
 * However if we can find a different directory under SDK/platform that already
 * has this platform version installed, we'll use that one.
 *
 * @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.
 */
@Override
public File getInstallFolder(String osSdkRoot, SdkManager sdkManager) {

    // First find if this platform is already installed. If so, reuse the same directory.
    for (IAndroidTarget target : sdkManager.getTargets()) {
        if (target.isPlatform() && target.getVersion().equals(mVersion)) {
            return new File(target.getLocation());
        }
    }

    File platforms = new File(osSdkRoot, SdkConstants.FD_PLATFORMS);
    File folder = new File(platforms,
            String.format("android-%s", getAndroidVersion().getApiString())); //$NON-NLS-1$

    return folder;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * Creates a new <em>invalid</em> AVD info. Values are immutable.
 * <p/>
 * Such an AVD is not complete and cannot be used.
 * The error string must be non-null.
 *
 * @param name The name of the AVD (for display or reference)
 * @param iniFile The path to the config.ini file
 * @param folderPath The path to the data directory
 * @param targetHash the target hash
 * @param target The target. Can be null, if the target was not resolved.
 * @param tag The tag id/display.
 * @param abiType Name of the abi.
 * @param properties The property map. If null, an empty map will be created.
 * @param status The {@link AvdStatus} of this AVD. Cannot be null.
 */
public AvdInfo(@NonNull  String name,
               @NonNull  File iniFile,
               @NonNull  String folderPath,
               @NonNull  String targetHash,
               @Nullable IAndroidTarget target,
               @NonNull  IdDisplay tag,
               @NonNull  String abiType,
               @Nullable Map<String, String> properties,
               @NonNull AvdStatus status) {
    mName       = name;
    mIniFile    = iniFile;
    mFolderPath = folderPath;
    mTargetHash = targetHash;
    mTarget     = target;
    mTag        = tag;
    mAbiType    = abiType;
    mProperties = properties == null ? Collections.<String, String>emptyMap()
                                     : Collections.unmodifiableMap(properties);
    mStatus     = status;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
public DeviceChooserDialog(@NotNull AndroidFacet facet,
                           @NotNull IAndroidTarget projectTarget,
                           boolean multipleSelection,
                           @Nullable String[] selectedSerials,
                           @Nullable Predicate<IDevice> filter) {
    super(facet.getModule().getProject(), true);
    setTitle(AndroidBundle.message("choose.device.dialog.title"));

    getOKAction().setEnabled(false);

    myDeviceChooser = new DeviceChooser(multipleSelection, getOKAction(), facet, projectTarget, filter);
    Disposer.register(myDisposable, myDeviceChooser);
    myDeviceChooser.addListener(new DeviceChooserListener() {
        @Override
        public void selectedDevicesChanged() {
            updateOkButton();

            if (deviceChooserListener != null) {
                deviceChooserListener.selectedDevicesChanged();
            }
        }
    });

    init();
    myDeviceChooser.init(selectedSerials);
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * For a given target, returns a brief user-facing string that describes the platform, including the API level, platform version number,
 * and codename. Does the right thing with pre-release platforms.
 */
@NotNull
public static String getTargetLabel(@NotNull IAndroidTarget target) {
  if (!target.isPlatform()) {
    return String.format("%1$s (API %2$s)", target.getFullName(), target.getVersion().getApiString());
  }
  AndroidVersion version = target.getVersion();
  if (version.isPreview()) {
    return String.format("API %d+: %s", target.getVersion().getApiLevel(), target.getName());
  }
  String name = SdkVersionInfo.getAndroidName(target.getVersion().getApiLevel());
  if (name != null) {
    return name;
  }
  String release = target.getProperty("ro.build.version.release"); //$NON-NLS-1$
  if (release != null) {
    return String.format("API %1$d: Android %2$s", version.getApiLevel(), release);
  }
  return String.format("API %1$d", version.getApiLevel());
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@Nullable
public static Sdk findAppropriateAndroidPlatform(@NotNull IAndroidTarget target, @NotNull AndroidSdkData sdkData, boolean forMaven) {
  for (Sdk sdk : ProjectJdkTable.getInstance().getAllJdks()) {
    String homePath = sdk.getHomePath();

    if (homePath != null && isAndroidSdk(sdk)) {
      AndroidSdkData currentSdkData = getSdkData(homePath);

      if (sdkData.equals(currentSdkData)) {
        AndroidSdkAdditionalData data = getAndroidSdkAdditionalData(sdk);
        if (data != null) {
          IAndroidTarget currentTarget = data.getBuildTarget(currentSdkData);
          if (currentTarget != null &&
              target.hashString().equals(currentTarget.hashString()) &&
              checkSdkRoots(sdk, target, forMaven)) {
            return sdk;
          }
        }
      }
    }
  }
  return null;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * Load the installed android versions from the SDK
 */
public static void loadInstalledVersions() {
  IAndroidTarget[] targets = getCompilationTargets();

  IAndroidTarget highestInstalledTarget = null;
  ourInstalledVersions.clear();
  for (IAndroidTarget target : targets) {
    if (highestInstalledTarget == null ||
        target.getVersion().getFeatureLevel() > highestInstalledTarget.getVersion().getFeatureLevel() &&
        !target.getVersion().isPreview()) {
      highestInstalledTarget = target;
    }
    if (target.getVersion().isPreview() || !target.getAdditionalLibraries().isEmpty()) {
      AndroidTargetComboBoxItem targetInfo = new AndroidTargetComboBoxItem(target);
      ourInstalledVersions.add(targetInfo.target.getVersion());
    }
  }
  ourHighestInstalledApiTarget = highestInstalledTarget;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
private TIntObjectHashMap<String> getIdMap() {
  AndroidFacet facet = null;
  for (Module m : ModuleManager.getInstance(myProject).getModules()) {
    facet = AndroidFacet.getInstance(m);
    if (facet != null) {
      break;
    }
  }

  AndroidSdkData sdkData = facet == null ? null : facet.getSdkData();
  if (sdkData == null) {
    return null;
  }

  IAndroidTarget[] targets = sdkData.getTargets();
  if (targets.length == 0) {
    return null;
  }

  return sdkData.getTargetData(targets[targets.length - 1]).getPublicIdMap();
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/** Returns whether a project with given minSdkVersion and target platform can be run on an AVD with given target platform. */
@NotNull
public static LaunchCompatibility canRunOnAvd(@NotNull AndroidVersion minSdkVersion,
                                              @NotNull IAndroidTarget projectTarget,
                                              @NotNull IAndroidTarget avdTarget) {
  AndroidVersion avdVersion = avdTarget.getVersion();
  if (!avdVersion.canRun(minSdkVersion)) {
    String reason = String.format("minSdk(%1$s) %3$s deviceSdk(%2$s)",
                                  minSdkVersion,
                                  avdVersion,
                                  minSdkVersion.getCodename() == null ? ">" : "!=");
    return new LaunchCompatibility(ThreeState.NO, reason);
  }

  return projectTarget.isPlatform() ? YES : isCompatibleAddonAvd(projectTarget, avdTarget);
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@Nullable
public static AndroidPlatform parse(@NotNull Sdk sdk) {
  if (!isAndroidSdk(sdk)) {
    return null;
  }
  AndroidSdkData sdkData = AndroidSdkData.getSdkData(sdk);
  if (sdkData != null) {
    SdkAdditionalData data = sdk.getSdkAdditionalData();
    if (data instanceof AndroidSdkAdditionalData) {
      IAndroidTarget target = ((AndroidSdkAdditionalData)data).getBuildTarget(sdkData);
      if (target != null) {
        return new AndroidPlatform(sdkData, target);
      }
    }
  }
  return null;
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@NotNull
private static String getLabel(@NotNull IAndroidTarget target) {
  if (target.isPlatform()
      && target.getVersion().getApiLevel() <= SdkVersionInfo.HIGHEST_KNOWN_API) {
    if (target.getVersion().isPreview()) {
      return target.getVersion().getApiString() + ": " + target.getName();
    }
    String name = SdkVersionInfo.getAndroidName(target.getVersion().getApiLevel());
    if (name == null) {
      return "API " + Integer.toString(target.getVersion().getApiLevel());
    } else {
      return name;
    }
  } else {
    return AndroidSdkUtils.getTargetLabel(target);
  }
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
@Override
@NonNull
public TargetInfo getTargetInfo(
        @NonNull String targetHash,
        @NonNull FullRevision buildToolRevision,
        @NonNull ILogger logger) {
    init(logger);

    IAndroidTarget target = mSdkManager.getTargetFromHashString(targetHash);
    if (target == null) {
        throw new IllegalStateException("failed to find target with hash string '" + targetHash + "' in: " + mSdkLocation);
    }

    BuildToolInfo buildToolInfo = mSdkManager.getBuildTool(buildToolRevision);
    if (buildToolInfo == null) {
        throw new IllegalStateException("failed to find Build Tools revision "
                + buildToolRevision.toString());
    }

    return new TargetInfo(target, buildToolInfo);
}
 

import com.android.sdklib.IAndroidTarget; //导入依赖的package包/类
/**
 * Returns the rendering target
 *
 * @return the target
 */
@Nullable
public IAndroidTarget getTarget() {
  if (myTarget == null) {
    IAndroidTarget target = myManager.getTarget();

    // If the project-wide render target isn't a match for the version qualifier in this layout
    // (for example, the render target is at API 11, and layout is in a -v14 folder) then pick
    // a target which matches.
    VersionQualifier version = myEditedConfig.getVersionQualifier();
    if (target != null && version != null && version.getVersion() > target.getVersion().getFeatureLevel()) {
      return myManager.getTarget(version.getVersion());
    }

    return target;
  }

  return myTarget;
}