/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/actions/AddSupportJarAction.java

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
 *
 * 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.ide.eclipse.adt.internal.actions;

import com.android.SdkConstants;
import com.android.annotations.Nullable;
import com.android.ide.eclipse.adt.AdtConstants;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.AdtUtils;
import com.android.ide.eclipse.adt.internal.sdk.AdtConsoleSdkLog;
import com.android.ide.eclipse.adt.internal.sdk.ProjectState;
import com.android.ide.eclipse.adt.internal.sdk.Sdk;
import com.android.sdklib.SdkManager;
import com.android.sdklib.internal.project.ProjectProperties;
import com.android.sdklib.internal.project.ProjectProperties.PropertyType;
import com.android.sdklib.internal.project.ProjectPropertiesWorkingCopy;
import com.android.sdklib.io.FileOp;
import com.android.sdkuilib.internal.repository.ui.AdtUpdateDialog;
import com.android.utils.NullLogger;
import com.android.utils.Pair;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.IFileSystem;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;

/**
 * An action to add the android-support-v4.jar support library
 * to the selected project.
 * <p/>
 * This should be used by the GLE. The action itself is currently more
 * like an example of how to invoke the new {@link AdtUpdateDialog}.
 * <p/>
 * TODO: make this more configurable.
 */
public class AddSupportJarAction implements IObjectActionDelegate {

    /** The vendor ID of the support library. */
    private static final String VENDOR_ID = "android";                             //$NON-NLS-1$
    /** The path ID of the support library. */
    private static final String SUPPORT_ID = "support";                            //$NON-NLS-1$
    /** The path ID of the compatibility library (which was its id for releases 1-3). */
    private static final String COMPATIBILITY_ID = "compatibility";                //$NON-NLS-1$
    private static final String FD_GRIDLAYOUT = "gridlayout";                      //$NON-NLS-1$
    private static final String FD_V7 = "v7";                                      //$NON-NLS-1$
    private static final String FD_V4 = "v4";                                      //$NON-NLS-1$
    private static final String ANDROID_SUPPORT_V4_JAR = "android-support-v4.jar"; //$NON-NLS-1$
    private ISelection mSelection;

    /**
     * @see IObjectActionDelegate#setActivePart(IAction, IWorkbenchPart)
     */
    @Override
    public void setActivePart(IAction action, IWorkbenchPart targetPart) {
    }

    @Override
    public void run(IAction action) {
        if (mSelection instanceof IStructuredSelection) {

            for (Iterator<?> it = ((IStructuredSelection) mSelection).iterator();
                    it.hasNext();) {
                Object element = it.next();
                IProject project = null;
                if (element instanceof IProject) {
                    project = (IProject) element;
                } else if (element instanceof IAdaptable) {
                    project = (IProject) ((IAdaptable) element)
                            .getAdapter(IProject.class);
                }
                if (project != null) {
                    install(project);
                }
            }
        }
    }

    @Override
    public void selectionChanged(IAction action, ISelection selection) {
        mSelection = selection;
    }

    /**
     * Install the support jar into the given project.
     *
     * @param project The Android project to install the support jar into
     * @return true if the installation was successful
     */
    public static boolean install(final IProject project) {
        File jarPath = installSupport(-1);
        if (jarPath != null) {
            try {
                return copyJarIntoProject(project, jarPath) != null;
            } catch (Exception e) {
                AdtPlugin.log(e, null);
            }
        }

        return false;
    }

    /**
     * Installs the Android Support library into the SDK extras/ folder. If a minimum
     * revision number is specified, this method will check whether the package is already
     * installed, and if the installed revision is at least as high as the requested revision,
     * this method will exit without performing an update.
     *
     * @param minimumRevision a minimum revision, or -1 to upgrade
     *            unconditionally. Note that this does <b>NOT</b> specify which
     *            revision to install; the latest version will always be
     *            installed.
     * @return the location of the support jar file, or null if something went
     *            wrong
     */
    @Nullable
    public static File installSupport(int minimumRevision) {

        final Sdk sdk = Sdk.getCurrent();
        if (sdk == null) {
            AdtPlugin.printErrorToConsole(
                    AddSupportJarAction.class.getSimpleName(),   // tag
                    "Error: Android SDK is not loaded yet."); //$NON-NLS-1$
            return null;
        }

        String sdkLocation = sdk.getSdkLocation();
        if (minimumRevision > 0) {
            File path = getSupportJarFile();
            if (path != null) {
                assert path.exists(); // guaranteed by the getSupportJarFile call
                int installedRevision = getInstalledRevision();
                if (installedRevision != -1 && minimumRevision <= installedRevision) {
                    return path;
                }
            }
        }

        // TODO: For the generic action, check the library isn't in the project already.

        // First call the package manager to make sure the package is installed
        // and get the installation path of the library.

        AdtUpdateDialog window = new AdtUpdateDialog(
                AdtPlugin.getShell(),
                new AdtConsoleSdkLog(),
                sdkLocation);

        Pair<Boolean, File> result = window.installExtraPackage(VENDOR_ID, SUPPORT_ID);

        // TODO: Make sure the version is at the required level; we know we need at least one
        // containing the v7 support

        if (!result.getFirst().booleanValue()) {
            AdtPlugin.printErrorToConsole("Failed to install Android Support library");
            return null;
        }

        // TODO these "v4" values needs to be dynamic, e.g. we could try to match
        // vN/android-support-vN.jar. Eventually we'll want to rely on info from the
        // package manifest anyway so this is irrelevant.

        File path = new File(result.getSecond(), FD_V4);
        final File jarPath = new File(path, ANDROID_SUPPORT_V4_JAR);

        if (!jarPath.isFile()) {
            AdtPlugin.printErrorToConsole("Android Support Jar not found:",
                    jarPath.getAbsolutePath());
            return null;
        }

        return jarPath;
    }

    /**
     * Returns the installed revision number of the Android Support
     * library, or -1 if the package is not installed.
     *
     * @return the installed revision number, or -1
     */
    public static int getInstalledRevision() {
        final Sdk sdk = Sdk.getCurrent();
        if (sdk != null) {
            String sdkLocation = sdk.getSdkLocation();
            SdkManager manager = SdkManager.createManager(sdkLocation, NullLogger.getLogger());
            Map<String, Integer> versions = manager.getExtrasVersions();
            Integer version = versions.get(VENDOR_ID + '/' + SUPPORT_ID);
            if (version == null) {
                // Check the old compatibility library. When the library is updated in-place
                // the manager doesn't change its folder name (since that is a source of
                // endless issues on Windows.)
                version = versions.get(VENDOR_ID + '/' + COMPATIBILITY_ID);
            }
            if (version != null) {
                return version.intValue();
            }
        }

       return -1;
    }

    /**
     * Similar to {@link #install}, but rather than copy a jar into the given
     * project, it creates a new library project in the workspace for the
     * support library, and adds a library dependency on the newly
     * installed library from the given project.
     *
     * @param project the project to add a dependency on the library to
     * @param waitForFinish If true, block until the task has finished
     * @return true if the installation was successful (or if
     *         <code>waitForFinish</code> is false, if the installation is
     *         likely to be successful - e.g. the user has at least agreed to
     *         all installation prompts.)
     */
    public static boolean installGridLayoutLibrary(final IProject project, boolean waitForFinish) {
        final IJavaProject javaProject = JavaCore.create(project);
        if (javaProject != null) {

            File supportPath = getSupportPackageDir();
            if (!supportPath.isDirectory()) {
                File path = installSupport(8); // GridLayout arrived in rev 7 and fixed in rev 8
                if (path == null) {
                    return false;
                }
                assert path.equals(supportPath);
            }
            File libraryPath = new File(supportPath, FD_V7 + File.separator + FD_GRIDLAYOUT);
            if (!libraryPath.isDirectory()) {
                // Upgrade support package: it's out of date. The SDK manager will
                // perform an upgrade to the latest version if the package is already installed.
                File path = installSupport(-1);
                if (path == null) {
                    return false;
                }
                assert path.equals(libraryPath) : path;
            }

            // Create workspace copy of the project and add library dependency
            IProject libraryProject = createLibraryProject(libraryPath, project, waitForFinish);
            if (libraryProject != null) {
                return addLibraryDependency(libraryProject, project, waitForFinish);
            }
        }

        return false;
    }

    /**
     * Returns the directory containing the support libraries (v4, v7, v13,
     * ...), which may or may not exist
     *
     * @return a path to the support library or null
     */
    private static File getSupportPackageDir() {
        final Sdk sdk = Sdk.getCurrent();
        if (sdk != null) {
            String sdkLocation = sdk.getSdkLocation();
            SdkManager manager = SdkManager.createManager(sdkLocation, NullLogger.getLogger());
            Map<String, Integer> versions = manager.getExtrasVersions();
            Integer version = versions.get(VENDOR_ID + '/' + SUPPORT_ID);
            if (version != null) {
                File supportPath = new File(sdkLocation,
                        SdkConstants.FD_EXTRAS + File.separator
                        + VENDOR_ID + File.separator
                        + SUPPORT_ID);
                return supportPath;
            }

            // Check the old compatibility library. When the library is updated in-place
            // the manager doesn't change its folder name (since that is a source of
            // endless issues on Windows.)
            version = versions.get(VENDOR_ID + '/' + COMPATIBILITY_ID);
            if (version != null) {
                File supportPath = new File(sdkLocation,
                        SdkConstants.FD_EXTRAS + File.separator
                        + VENDOR_ID + File.separator
                        + COMPATIBILITY_ID);
                return supportPath;
            }
        }
        return null;
    }

    /**
     * Returns a path to the installed jar file for the support library,
     * or null if it does not exist
     *
     * @return a path to the v4.jar or null
     */
    @Nullable
    public static File getSupportJarFile() {
        File supportDir = getSupportPackageDir();
        if (supportDir != null) {
            File path = new File(supportDir, FD_V4 + File.separator + ANDROID_SUPPORT_V4_JAR);
            if (path.exists()) {
                return path;
            }
        }

        return null;
    }

    /**
     * Creates a library project in the Eclipse workspace out of the grid layout project
     * in the SDK tree.
     *
     * @param libraryPath the path to the directory tree containing the project contents
     * @param project the project to copy the SDK target out of
     * @param waitForFinish whether the operation should finish before this method returns
     * @return a library project, or null if it fails for some reason
     */
    private static IProject createLibraryProject(
            final File libraryPath,
            final IProject project,
            boolean waitForFinish) {

        // Install a new library into the workspace. This is a copy rather than
        // a reference to the support library version such that modifications
        // do not modify the pristine copy in the SDK install area.

        final IProject newProject;
        try {
            IProgressMonitor monitor = new NullProgressMonitor();
            IWorkspace workspace = ResourcesPlugin.getWorkspace();
            IWorkspaceRoot root = workspace.getRoot();

            String name = AdtUtils.getUniqueProjectName(
                    "gridlayout_v7", "_"); //$NON-NLS-1$ //$NON-NLS-2$
            newProject = root.getProject(name);
            IProjectDescription description = workspace.newProjectDescription(name);
            String[] natures = new String[] { AdtConstants.NATURE_DEFAULT, JavaCore.NATURE_ID };
            description.setNatureIds(natures);
            newProject.create(description, monitor);

            // Copy in the files recursively
            IFileSystem fileSystem = EFS.getLocalFileSystem();
            IFileStore sourceDir = fileSystem.getStore(libraryPath.toURI());
            IFileStore destDir = fileSystem.getStore(newProject.getLocationURI());
            sourceDir.copy(destDir, EFS.OVERWRITE, null);

            // Make sure the src folder exists
            destDir.getChild("src").mkdir(0, null /*monitor*/);

            // Set the android platform to the same level as the calling project
            ProjectState state = Sdk.getProjectState(project);
            String target = state.getProperties().getProperty(ProjectProperties.PROPERTY_TARGET);
            if (target != null && target.length() > 0) {
                ProjectProperties properties = ProjectProperties.load(libraryPath.getPath(),
                        PropertyType.PROJECT);
                ProjectPropertiesWorkingCopy copy = properties.makeWorkingCopy();
                copy.setProperty(ProjectProperties.PROPERTY_TARGET, target);
                try {
                    copy.save();
                } catch (Exception e) {
                    AdtPlugin.log(e, null);
                }
            }

            newProject.open(monitor);

            return newProject;
        } catch (CoreException e) {
            AdtPlugin.log(e, null);
            return null;
        }
    }

    /**
     * Adds a library dependency on the given library into the given project.
     *
     * @param libraryProject the library project to depend on
     * @param dependentProject the project to write the dependency into
     * @param waitForFinish whether this method should wait for the job to
     *            finish
     * @return true if the operation succeeded
     */
    public static boolean addLibraryDependency(
            final IProject libraryProject,
            final IProject dependentProject,
            boolean waitForFinish) {

        // Now add library dependency

        // Run an Eclipse asynchronous job to update the project
        Job job = new Job("Add Support Library Dependency to Project") {
            @Override
            protected IStatus run(IProgressMonitor monitor) {
                try {
                    monitor.beginTask("Add library dependency to project build path", 3);
                    monitor.worked(1);

                    // TODO: Add library project to the project.properties file!
                    ProjectState state = Sdk.getProjectState(dependentProject);
                    ProjectPropertiesWorkingCopy mPropertiesWorkingCopy =
                            state.getProperties().makeWorkingCopy();

                    // Get the highest version number of the libraries; there cannot be any
                    // gaps so we will assign the next library the next number
                    int nextVersion = 1;
                    for (String property : mPropertiesWorkingCopy.keySet()) {
                        if (property.startsWith(ProjectProperties.PROPERTY_LIB_REF)) {
                            String s = property.substring(
                                    ProjectProperties.PROPERTY_LIB_REF.length());
                            int version = Integer.parseInt(s);
                            if (version >= nextVersion) {
                                nextVersion = version + 1;
                            }
                        }
                    }

                    IPath relativePath = libraryProject.getLocation().makeRelativeTo(
                            dependentProject.getLocation());

                    mPropertiesWorkingCopy.setProperty(
                            ProjectProperties.PROPERTY_LIB_REF + nextVersion,
                            relativePath.toString());
                    try {
                        mPropertiesWorkingCopy.save();
                        IResource projectProp = dependentProject.findMember(
                                SdkConstants.FN_PROJECT_PROPERTIES);
                        projectProp.refreshLocal(IResource.DEPTH_ZERO, new NullProgressMonitor());
                    } catch (Exception e) {
                        String msg = String.format(
                                "Failed to save %1$s for project %2$s",
                                SdkConstants.FN_PROJECT_PROPERTIES, dependentProject.getName());
                        AdtPlugin.log(e, msg);
                    }

                    // Project fix-ups
                    Job fix = FixProjectAction.createFixProjectJob(libraryProject);
                    fix.schedule();
                    fix.join();

                    monitor.worked(1);

                    return Status.OK_STATUS;
                } catch (Exception e) {
                    return new Status(Status.ERROR, AdtPlugin.PLUGIN_ID, Status.ERROR,
                                      "Failed", e); //$NON-NLS-1$
                } finally {
                    if (monitor != null) {
                        monitor.done();
                    }
                }
            }
        };
        job.schedule();

        if (waitForFinish) {
            try {
                job.join();
                return job.getState() == IStatus.OK;
            } catch (InterruptedException e) {
                AdtPlugin.log(e, null);
            }
        }

        return true;
    }

    private static IResource copyJarIntoProject(
            IProject project,
            File jarPath) throws IOException, CoreException {
        IFolder resFolder = project.getFolder(SdkConstants.FD_NATIVE_LIBS);
        if (!resFolder.exists()) {
            resFolder.create(IResource.FORCE, true /*local*/, null);
        }

        IFile destFile = resFolder.getFile(jarPath.getName());
        IPath loc = destFile.getLocation();
        File destPath = loc.toFile();

        // Only modify the file if necessary so that we don't trigger unnecessary recompilations
        FileOp f = new FileOp();
        if (!f.isFile(destPath) || !f.isSameFile(jarPath, destPath)) {
            f.copyFile(jarPath, destPath);
            // Make sure Eclipse discovers java.io file changes
            resFolder.refreshLocal(1, new NullProgressMonitor());
        }

        return destFile;
    }

    /**
     * @see IWorkbenchWindowActionDelegate#init
     */
    public void init(IWorkbenchWindow window) {
        // pass
    }

}