Java tutorial
/* * Copyright (C) 2013 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.tools.idea.sdk; import com.android.SdkConstants; import com.android.sdklib.AndroidVersion; import com.android.sdklib.IAndroidTarget; import com.android.tools.idea.gradle.project.GradleProjectImporter; import com.android.tools.idea.gradle.util.LocalProperties; import com.android.tools.idea.gradle.util.Projects; import com.android.tools.idea.startup.AndroidStudioSpecificInitializer; import com.android.tools.idea.startup.ExternalAnnotationsSupport; import com.google.common.base.Strings; import com.google.common.collect.Lists; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.project.ProjectManager; import com.intellij.openapi.projectRoots.*; import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.ui.Messages; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.SystemProperties; import com.intellij.util.ui.UIUtil; import org.jetbrains.android.actions.RunAndroidSdkManagerAction; import org.jetbrains.android.sdk.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.IOException; import java.util.Collection; import java.util.Collections; import java.util.List; import static org.jetbrains.android.sdk.AndroidSdkUtils.chooseNameForNewLibrary; import static org.jetbrains.android.sdk.AndroidSdkUtils.createNewAndroidPlatform; public final class DefaultSdks { private static final Logger LOG = Logger.getInstance(DefaultSdks.class); private static final String ERROR_DIALOG_TITLE = "Project SDK Update"; private DefaultSdks() { } /** * @return what the IDE is using as the home path for the Android SDK for new projects. */ @Nullable public static File getDefaultAndroidHome() { String sdkHome = null; Sdk sdk = getFirstAndroidSdk(); if (sdk != null) { sdkHome = sdk.getHomePath(); } if (sdkHome != null) { return new File(FileUtil.toSystemDependentName(sdkHome)); } return null; } @Nullable public static File getDefaultJavaHome() { List<Sdk> androidSdks = getEligibleAndroidSdks(); if (androidSdks.isEmpty()) { // This happens when user has a fresh installation of Android Studio without an Android SDK, but with a JDK. Android Studio should // populate the text field with the existing JDK. Sdk jdk = Jdks.chooseOrCreateJavaSdk(); if (jdk != null) { String jdkHomePath = jdk.getHomePath(); if (jdkHomePath != null) { return new File(FileUtil.toSystemDependentName(jdkHomePath)); } } } else { for (Sdk sdk : androidSdks) { AndroidSdkAdditionalData data = (AndroidSdkAdditionalData) sdk.getSdkAdditionalData(); assert data != null; Sdk jdk = data.getJavaSdk(); if (jdk != null) { String jdkHomePath = jdk.getHomePath(); if (jdkHomePath != null) { return new File(FileUtil.toSystemDependentName(jdkHomePath)); } } } } return null; } /** * @return the first SDK it finds that matches our default naming convention. There will be several SDKs so named, one for each build * target installed in the SDK; which of those this method returns is not defined. */ @Nullable private static Sdk getFirstAndroidSdk() { List<Sdk> allAndroidSdks = getEligibleAndroidSdks(); if (!allAndroidSdks.isEmpty()) { return allAndroidSdks.get(0); } return null; } public static void setDefaultJavaHome(@NotNull File path) { // Set up a list of SDKs we don't need any more. At the end we'll delete them. List<Sdk> sdksToDelete = Lists.newArrayList(); if (JavaSdk.checkForJdk(path)) { File canonicalPath = resolvePath(path); // Try to set this path into the "default" JDK associated with the IntelliJ SDKs. Sdk defaultJdk = getDefaultJdk(); if (defaultJdk != null) { setJdkPath(defaultJdk, canonicalPath); // Flip through the IntelliJ SDKs and make sure they point to this JDK. updateAllSdks(defaultJdk); } else { // We didn't have a JDK set at all. Try to create one. VirtualFile virtualPath = VfsUtil.findFileByIoFile(canonicalPath, true); if (virtualPath != null) { defaultJdk = createJdk(virtualPath); } } if (AndroidStudioSpecificInitializer.isAndroidStudio()) { // Now iterate through all the JDKs and delete any that aren't the default one. List<Sdk> jdks = ProjectJdkTable.getInstance().getSdksOfType(JavaSdk.getInstance()); if (defaultJdk != null) { for (Sdk jdk : jdks) { if (jdk.getName() != defaultJdk.getName()) { sdksToDelete.add(defaultJdk); } else { // This may actually be a different copy of the SDK than what we obtained from the JDK. Set its path to be sure. setJdkPath(jdk, canonicalPath); } } } } for (final Sdk sdk : sdksToDelete) { ProjectJdkTable.getInstance().removeJdk(sdk); } } } public static List<Sdk> setDefaultAndroidHome(@NotNull File path) { return setDefaultAndroidHome(path, null); } /** * Sets the given JDK's home path to the given path, and resets all of its content roots. */ private static void setJdkPath(@NotNull Sdk sdk, @NotNull File path) { SdkModificator sdkModificator = sdk.getSdkModificator(); sdkModificator.setHomePath(path.getPath()); sdkModificator.removeAllRoots(); ExternalAnnotationsSupport.attachJdkAnnotations(sdkModificator); sdkModificator.commitChanges(); JavaSdk.getInstance().setupSdkPaths(sdk); } /** * Iterates through all Android SDKs and makes them point to the given JDK. */ private static void updateAllSdks(@NotNull Sdk jdk) { for (Sdk sdk : AndroidSdkUtils.getAllAndroidSdks()) { AndroidSdkAdditionalData oldData = (AndroidSdkAdditionalData) sdk.getSdkAdditionalData(); if (oldData == null) { continue; } oldData.setJavaSdk(jdk); SdkModificator modificator = sdk.getSdkModificator(); modificator.setSdkAdditionalData(oldData); modificator.commitChanges(); } } /** * Sets the path of Android Studio's default Android SDK. This method should be called in a write action. It is assumed that the given * path has been validated by {@link #isValidAndroidSdkPath(File)}. This method will fail silently if the given path is not valid. * * * @param path the path of the Android SDK. * @see com.intellij.openapi.application.Application#runWriteAction(Runnable) */ public static List<Sdk> setDefaultAndroidHome(@NotNull File path, @Nullable Sdk javaSdk) { if (isValidAndroidSdkPath(path)) { assert ApplicationManager.getApplication().isWriteAccessAllowed(); // Since removing SDKs is *not* asynchronous, we force an update of the SDK Manager. // If we don't force this update, AndroidSdkUtils will still use the old SDK until all SDKs are properly deleted. AndroidSdkData oldSdkData = AndroidSdkData.getSdkData(path); AndroidSdkUtils.setSdkData(oldSdkData); // Set up a list of SDKs we don't need any more. At the end we'll delete them. List<Sdk> sdksToDelete = Lists.newArrayList(); File resolved = resolvePath(path); String resolvedPath = resolved.getPath(); // Parse out the new SDK. We'll need its targets to set up IntelliJ SDKs for each. AndroidSdkData sdkData = AndroidSdkData.getSdkData(resolvedPath); if (sdkData != null) { // Iterate over all current existing IJ Android SDKs for (Sdk sdk : AndroidSdkUtils.getAllAndroidSdks()) { if (sdk.getName().startsWith(AndroidSdkUtils.SDK_NAME_PREFIX)) { sdksToDelete.add(sdk); } } } for (Sdk sdk : sdksToDelete) { ProjectJdkTable.getInstance().removeJdk(sdk); } // If there are any API targets that we haven't created IntelliJ SDKs for yet, fill those in. List<Sdk> sdks = createAndroidSdksForAllTargets(resolved, javaSdk); // Update the local.properties files for any open projects. updateLocalPropertiesAndSync(resolved); return sdks; } return Collections.emptyList(); } /** * @return {@code true} if the given Android SDK path points to a valid Android SDK. */ public static boolean isValidAndroidSdkPath(@NotNull File path) { return AndroidSdkType.validateAndroidSdk(path.getPath()).getFirst(); } @NotNull public static List<Sdk> createAndroidSdksForAllTargets(@NotNull File androidHome) { List<Sdk> sdks = createAndroidSdksForAllTargets(androidHome, null); RunAndroidSdkManagerAction.updateInWelcomePage(null); return sdks; } /** * Creates a set of IntelliJ SDKs (one for each build target) corresponding to the Android SDK in the given directory, if SDKs with the * default naming convention and each individual build target do not already exist. If IntelliJ SDKs do exist, they are not updated. */ @NotNull private static List<Sdk> createAndroidSdksForAllTargets(@NotNull File androidHome, @Nullable Sdk javaSdk) { AndroidSdkData sdkData = AndroidSdkData.getSdkData(androidHome); if (sdkData == null) { return Collections.emptyList(); } IAndroidTarget[] targets = sdkData.getTargets(); if (targets.length == 0) { return Collections.emptyList(); } List<Sdk> sdks = Lists.newArrayList(); Sdk defaultJdk = javaSdk != null ? javaSdk : getDefaultJdk(); for (IAndroidTarget target : targets) { if (target.isPlatform() && !doesDefaultAndroidSdkExist(target)) { String name = chooseNameForNewLibrary(target); Sdk sdk = createNewAndroidPlatform(target, sdkData.getLocation().getPath(), name, defaultJdk, true); sdks.add(sdk); } } return sdks; } /** * @return {@code true} if an IntelliJ SDK with the default naming convention already exists for the given Android build target. */ private static boolean doesDefaultAndroidSdkExist(@NotNull IAndroidTarget target) { for (Sdk sdk : getEligibleAndroidSdks()) { IAndroidTarget platformTarget = getTarget(sdk); AndroidVersion version = target.getVersion(); AndroidVersion existingVersion = platformTarget.getVersion(); if (existingVersion.equals(version)) { return true; } } return false; } @NotNull private static IAndroidTarget getTarget(@NotNull Sdk sdk) { AndroidSdkAdditionalData data = (AndroidSdkAdditionalData) sdk.getSdkAdditionalData(); assert data != null; AndroidPlatform androidPlatform = data.getAndroidPlatform(); assert androidPlatform != null; return androidPlatform.getTarget(); } private static void updateLocalPropertiesAndSync(@NotNull final File sdkHomePath) { ProjectManager projectManager = ApplicationManager.getApplication().getComponent(ProjectManager.class); Project[] openProjects = projectManager.getOpenProjects(); if (openProjects.length == 0) { return; } final List<String> projectsToUpdateNames = Lists.newArrayList(); List<Pair<Project, LocalProperties>> localPropertiesToUpdate = Lists.newArrayList(); for (Project project : openProjects) { if (!Projects.isGradleProject(project)) { continue; } try { LocalProperties localProperties = new LocalProperties(project); if (!FileUtil.filesEqual(sdkHomePath, localProperties.getAndroidSdkPath())) { localPropertiesToUpdate.add(Pair.create(project, localProperties)); projectsToUpdateNames.add("'" + project.getName() + "'"); } } catch (IOException e) { // Exception thrown when local.properties file exists but cannot be read (e.g. no writing permissions.) logAndShowErrorWhenUpdatingLocalProperties(project, e, "read", sdkHomePath); } } if (!localPropertiesToUpdate.isEmpty()) { if (!ApplicationManager.getApplication().isUnitTestMode()) { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { String format = "The local.properties files in projects %1$s will be modified with the path of Android Studio's default Android SDK:\n" + "'%2$s'"; Messages.showErrorDialog(String.format(format, projectsToUpdateNames, sdkHomePath), "Sync Android SDKs"); } }); } GradleProjectImporter projectImporter = GradleProjectImporter.getInstance(); for (Pair<Project, LocalProperties> toUpdate : localPropertiesToUpdate) { Project project = toUpdate.getFirst(); try { LocalProperties localProperties = toUpdate.getSecond(); if (!FileUtil.filesEqual(sdkHomePath, localProperties.getAndroidSdkPath())) { localProperties.setAndroidSdkPath(sdkHomePath); localProperties.save(); } } catch (IOException e) { logAndShowErrorWhenUpdatingLocalProperties(project, e, "update", sdkHomePath); // No point in syncing project if local.properties is pointing to the wrong SDK. continue; } if (ApplicationManager.getApplication().isUnitTestMode()) { // Don't sync in tests. For now. continue; } projectImporter.requestProjectSync(project, null); } } } private static void logAndShowErrorWhenUpdatingLocalProperties(@NotNull Project project, @NotNull Exception error, @NotNull String action, @NotNull File sdkHomePath) { LOG.info(error); String msg = String.format( "Unable to %1$s local.properties file in project '%2$s'.\n\n" + "Cause: %3$s\n\n" + "Please manually update the file's '%4$s' property value to \n" + "'%5$s'\n" + "and sync the project with Gradle files.", action, project.getName(), getMessage(error), SdkConstants.SDK_DIR_PROPERTY, sdkHomePath.getPath()); Messages.showErrorDialog(project, msg, ERROR_DIALOG_TITLE); } @NotNull private static String getMessage(@NotNull Exception e) { String cause = e.getMessage(); if (Strings.isNullOrEmpty(cause)) { cause = "[Unknown]"; } return cause; } @NotNull private static File resolvePath(@NotNull File path) { try { String resolvedPath = FileUtil.resolveShortWindowsName(path.getPath()); return new File(resolvedPath); } catch (IOException e) { //file doesn't exist yet } return path; } /** * @return the JDK with the default naming convention, creating one if it is not set up. */ @Nullable public static Sdk getDefaultJdk() { List<Sdk> androidSdks = getEligibleAndroidSdks(); if (!androidSdks.isEmpty()) { Sdk androidSdk = androidSdks.get(0); AndroidSdkAdditionalData data = (AndroidSdkAdditionalData) androidSdk.getSdkAdditionalData(); assert data != null; Sdk jdk = data.getJavaSdk(); if (jdk != null) { return jdk; } } List<Sdk> jdks = ProjectJdkTable.getInstance().getSdksOfType(JavaSdk.getInstance()); if (!jdks.isEmpty()) { return jdks.get(0); } final Collection<String> jdkPaths = JavaSdk.getInstance().suggestHomePaths(); VirtualFile javaHome = null; for (String jdkPath : jdkPaths) { javaHome = jdkPath != null ? LocalFileSystem.getInstance().findFileByPath(jdkPath) : null; if (javaHome != null) { break; } } if (javaHome == null) { javaHome = LocalFileSystem.getInstance().findFileByPath(SystemProperties.getJavaHome()); } return javaHome != null ? createJdk(javaHome) : null; } /** * Filters through all Android SDKs and returns only those that have our special name prefix and which have additional data and a * platform. */ @NotNull public static List<Sdk> getEligibleAndroidSdks() { List<Sdk> sdks = Lists.newArrayList(); for (Sdk sdk : AndroidSdkUtils.getAllAndroidSdks()) { SdkAdditionalData sdkData = sdk.getSdkAdditionalData(); if (sdkData instanceof AndroidSdkAdditionalData) { AndroidSdkAdditionalData androidSdkData = (AndroidSdkAdditionalData) sdkData; if (sdk.getName().startsWith(AndroidSdkUtils.SDK_NAME_PREFIX) && androidSdkData.getAndroidPlatform() != null) { sdks.add(sdk); } } } return sdks; } /** * Creates an IntelliJ SDK for the JDK at the given location and returns it, or {@code null} if it could not be created successfully. */ @Nullable private static Sdk createJdk(@NotNull VirtualFile homeDirectory) { Sdk newSdk = SdkConfigurationUtil.setupSdk(ProjectJdkTable.getInstance().getAllJdks(), homeDirectory, JavaSdk.getInstance(), true, null, AndroidSdkUtils.DEFAULT_JDK_NAME); if (newSdk != null) { SdkConfigurationUtil.addSdk(newSdk); } return newSdk; } }