bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/EarlyStartupRunnable.java

/*******************************************************************************
 * Copyright (c) 2004, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.ui.IStartup;
import org.osgi.framework.Bundle;

/**
 * A utility class used to call #earlyStartup on the proper instance for a given
 * configuration element. There are a few steps to the process in order to
 * ensure compatibility with pre-3.0 plugins.
 * 
 * @since 3.0
 */
public class EarlyStartupRunnable extends SafeRunnable {

    private static final String EXTENSION_CLASS = "org.eclipse.core.runtime.IExtension"; //$NON-NLS-1$

//    private static final String PLUGIN_DESC_CLASS = "org.eclipse.core.runtime.IPluginDescriptor"; //$NON-NLS-1$

    private static final String GET_PLUGIN_METHOD = "getPlugin"; //$NON-NLS-1$

    private static final String GET_DESC_METHOD = "getDeclaringPluginDescriptor"; //$NON-NLS-1$

    private static final String PI_RUNTIME_COMPATIBILITY = "org.eclipse.core.runtime.compatibility"; //$NON-NLS-1$ 

    private IExtension extension;

    /**
     * @param extension
     *            must not be null
     */
    public EarlyStartupRunnable(IExtension extension) {
        this.extension = extension;
    }

    public void run() throws Exception {
        IConfigurationElement[] configElements = extension
                .getConfigurationElements();

        // look for the startup tag in each element and run the extension
        boolean foundAtLeastOne = false;
        for (int i = 0; i < configElements.length; ++i) {
            IConfigurationElement element = configElements[i];
            if (element != null
                    && element.getName()
                            .equals(IWorkbenchConstants.TAG_STARTUP)) {
                runEarlyStartup(getExecutableExtension(element));
                foundAtLeastOne = true;
            }
        }

        // if no startup tags were found, then try the plugin object
        if (!foundAtLeastOne) {
			runEarlyStartup(getPluginForCompatibility());
		}
    }

    public void handleException(Throwable exception) {
        IStatus status = new Status(IStatus.ERROR, extension.getNamespace(), 0,
                "Unable to execute early startup code for an extension", //$NON-NLS-1$
                exception);
        WorkbenchPlugin.log("Unhandled Exception", status); //$NON-NLS-1$
    }

    private void runEarlyStartup(Object executableExtension) {
        if (executableExtension != null
                && executableExtension instanceof IStartup) {
			((IStartup) executableExtension).earlyStartup();
		} else {
            IStatus status = new Status(IStatus.ERROR,
                    extension.getNamespace(), 0,
                    "startup class must implement org.eclipse.ui.IStartup", //$NON-NLS-1$
                    null);
            WorkbenchPlugin.log("Bad extension specification", status); //$NON-NLS-1$
        }
    }

    /**
     * In 3.0 the class attribute is a mandatory element of the startup element.
     * However, 2.1 plugins should still be able to run if the compatibility
     * bundle is loaded.
     * 
     * @return an executable extension for this startup element or null if an
     *         extension (or plugin) could not be found
     */
    private Object getExecutableExtension(IConfigurationElement element)
            throws CoreException {

        String classname = element.getAttribute(IWorkbenchConstants.TAG_CLASS);

        // if class attribute is absent then try to use the compatibility
        // bundle to return the plugin object
        if (classname == null || classname.length() <= 0) {
			return getPluginForCompatibility();
		}

        // otherwise the 3.0 runtime should be able to do it
        return WorkbenchPlugin.createExtension(element,
                IWorkbenchConstants.TAG_CLASS);
    }

    /**
     * If the compatiblity bundle is loaded, then return the plugin object for
     * the extension on this runnable. Return null if the compatibility bundle
     * is not loaded or the plugin object cannot be created.
     */
    private Object getPluginForCompatibility() {
        // make sure the compatibility bundle is available
        Bundle compatBundle = Platform.getBundle(PI_RUNTIME_COMPATIBILITY);
        if (compatBundle == null) {
			return null;
		}

        // use reflection to try to access the plugin object
        try {
            // IPluginDescriptor pluginDesc =
            // 		extension.getDeclaringPluginDescriptor();
            Class extensionClass = compatBundle.loadClass(EXTENSION_CLASS);
            Method getDescMethod = extensionClass.getDeclaredMethod(
                    GET_DESC_METHOD, new Class[0]);
            Object pluginDesc = getDescMethod.invoke(extension, new Object[0]);
            if (pluginDesc == null) {
				return null;
			}

            // Plugin plugin = pluginDesc.getPlugin();
            Class pluginDescClass = pluginDesc.getClass();
            Method getPluginMethod = pluginDescClass.getDeclaredMethod(
                    GET_PLUGIN_METHOD, new Class[0]);
            return getPluginMethod.invoke(pluginDesc, new Object[0]);
        } catch (ClassNotFoundException e) {
            handleException(e);
        } catch (IllegalAccessException e) {
            handleException(e);
        } catch (InvocationTargetException e) {
            handleException(e);
        } catch (NoSuchMethodException e) {
            handleException(e);
        }

        return null;
    }
}