android-6.0.0_r1/s

/*
 * 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.editors.layout.gre;

import com.android.ide.common.api.IViewRule;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.internal.sdk.ProjectState;
import com.android.ide.eclipse.adt.internal.sdk.Sdk;
import com.android.sdklib.internal.project.ProjectProperties;
import com.android.utils.Pair;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.QualifiedName;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;

/**
 * The {@link RuleLoader} is responsible for loading (and unloading)
 * {@link IViewRule} classes. There is typically one {@link RuleLoader}
 * per project.
 */
public class RuleLoader {
    /**
     * Qualified name for the per-project non-persistent property storing the
     * {@link RuleLoader} for this project
     */
    private final static QualifiedName RULE_LOADER = new QualifiedName(AdtPlugin.PLUGIN_ID,
            "ruleloader"); //$NON-NLS-1$

    private final IProject mProject;
    private ClassLoader mUserClassLoader;
    private List<Pair<File, Long>> mUserJarTimeStamps;
    private long mLastCheckTimeStamp;

    /**
     * Flag set when we've attempted to initialize the {@link #mUserClassLoader}
     * already
     */
    private boolean mUserClassLoaderInited;

    /**
     * Returns the {@link RuleLoader} for the given project
     *
     * @param project the project the loader is associated with
     * @return an {@RuleLoader} for the given project,
     *         never null
     */
    public static RuleLoader get(IProject project) {
        RuleLoader loader = null;
        try {
            loader = (RuleLoader) project.getSessionProperty(RULE_LOADER);
        } catch (CoreException e) {
            // Not a problem; we will just create a new one
        }
        if (loader == null) {
            loader = new RuleLoader(project);
            try {
                project.setSessionProperty(RULE_LOADER, loader);
            } catch (CoreException e) {
                AdtPlugin.log(e, "Can't store RuleLoader");
            }
        }
        return loader;
    }

    /** Do not call; use the {@link #get} factory method instead. */
    private RuleLoader(IProject project) {
        mProject = project;
    }

    /**
     * Find out whether the given project has 3rd party ViewRules, and if so
     * return a ClassLoader which can locate them. If not, return null.
     * @param project The project to load user rules from
     * @return A class loader which can user view rules, or otherwise null
     */
    private ClassLoader computeUserClassLoader(IProject project) {
        // Default place to locate layout rules. The user may also add to this
        // path by defining a config property specifying
        // additional .jar files to search via a the layoutrules.jars property.
        ProjectState state = Sdk.getProjectState(project);
        ProjectProperties projectProperties = state.getProperties();

        // Ensure we have the latest & greatest version of the properties.
        // This allows users to reopen editors in a running Eclipse instance
        // to get updated view rule jars
        projectProperties.reload();

        String path = projectProperties.getProperty(
                ProjectProperties.PROPERTY_RULES_PATH);

        if (path != null && path.length() > 0) {

            mUserJarTimeStamps = new ArrayList<Pair<File, Long>>();
            mLastCheckTimeStamp = System.currentTimeMillis();

            List<URL> urls = new ArrayList<URL>();
            String[] pathElements = path.split(File.pathSeparator);
            for (String pathElement : pathElements) {
                pathElement = pathElement.trim(); // Avoid problems with trailing whitespace etc
                File pathFile = new File(pathElement);
                if (!pathFile.isAbsolute()) {
                    pathFile = new File(project.getLocation().toFile(), pathElement);
                }
                // Directories and jar files are okay. Do we need to
                // validate the files here as .jar files?
                if (pathFile.isFile() || pathFile.isDirectory()) {
                    URL url;
                    try {
                        url = pathFile.toURI().toURL();
                        urls.add(url);

                        mUserJarTimeStamps.add(Pair.of(pathFile, pathFile.lastModified()));
                    } catch (MalformedURLException e) {
                        AdtPlugin.log(IStatus.WARNING,
                                "Invalid URL: %1$s", //$NON-NLS-1$
                                e.toString());
                    }
                }
            }

            if (urls.size() > 0) {
                return new URLClassLoader(urls.toArray(new URL[urls.size()]),
                        RulesEngine.class.getClassLoader());
            }
        }

        return null;
    }

    /**
     * Return the class loader to use for custom views, or null if no custom
     * view rules are registered for the project. Note that this class loader
     * can change over time (if the jar files are updated), so callers should be
     * prepared to unload previous instances.
     *
     * @return a class loader to use for custom view rules, or null
     */
    public ClassLoader getClassLoader() {
        if (mUserClassLoader == null) {
            // Only attempt to load rule paths once.
            // TODO: Check the timestamp on the project.properties file so we can dynamically
            // pick up cases where the user edits the path
            if (!mUserClassLoaderInited) {
                mUserClassLoaderInited = true;
                mUserClassLoader = computeUserClassLoader(mProject);
            }
        } else {
            // Check the timestamp on the jar files in the custom view path to see if we
            // need to reload the classes (but only do this at most every 3 seconds)
            if (mUserJarTimeStamps != null) {
                long time = System.currentTimeMillis();
                if (time - mLastCheckTimeStamp > 3000) {
                    mLastCheckTimeStamp = time;
                    for (Pair<File, Long> pair : mUserJarTimeStamps) {
                        File file = pair.getFirst();
                        Long prevModified = pair.getSecond();
                        long modified = file.lastModified();
                        if (prevModified.longValue() != modified) {
                            mUserClassLoaderInited = true;
                            mUserJarTimeStamps = null;
                            mUserClassLoader = computeUserClassLoader(mProject);
                        }
                    }
                }
            }
        }

        return mUserClassLoader;
    }
}