bundles/org.eclipse.equinox.app/src/org/eclipse/equinox/internal/app/Activator.java

/*******************************************************************************
 * Copyright (c) 2005, 2007 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.equinox.internal.app;

import java.security.AccessController;
import java.security.PrivilegedAction;
import org.eclipse.core.runtime.IContributor;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.spi.RegistryContributor;
import org.eclipse.osgi.framework.log.FrameworkLog;
import org.eclipse.osgi.framework.log.FrameworkLogEntry;
import org.eclipse.osgi.service.debug.DebugOptions;
import org.eclipse.osgi.service.environment.EnvironmentInfo;
import org.osgi.framework.*;
import org.osgi.service.packageadmin.PackageAdmin;
import org.osgi.util.tracker.ServiceTracker;
import org.osgi.util.tracker.ServiceTrackerCustomizer;

public class Activator implements BundleActivator, ServiceTrackerCustomizer {
	public static final String PI_APP = "org.eclipse.equinox.app"; //$NON-NLS-1$
	public static boolean DEBUG = false;
	private static BundleContext context;
	// PackageAdmin is a system service that never goes away as long 
	// as the framwork is active.  No need to track it!!
	private static PackageAdmin packageAdmin;
	private static EclipseAppContainer container;
	// tracks the FrameworkLog service
	private static ServiceTracker frameworkLog;
	// tracks the extension registry and app launcher services
	private ServiceTracker registryTracker;
	private IExtensionRegistry registry;

	public void start(BundleContext bc) {
		context = bc;
		// doing simple get service here because we expect the PackageAdmin service to always be available
		ServiceReference ref = context.getServiceReference(PackageAdmin.class.getName());
		if (ref != null)
			packageAdmin = (PackageAdmin) context.getService(ref);
		getDebugOptions(context);
		processCommandLineArgs();
		// set the app manager context before starting the container
		AppPersistence.start(context);
		// we must have an extension registry started before we can start the container
		registryTracker = new ServiceTracker(context, IExtensionRegistry.class.getName(), this);
		registryTracker.open();
		// start the app commands for the console
		try {
			AppCommands.create(context);
		} catch (NoClassDefFoundError e) {
			// catch incase CommandProvider is not available
		}
	}

	public void stop(BundleContext bc) {
		// stop the app commands for the console
		try {
			AppCommands.destroy(context);
		} catch (NoClassDefFoundError e) {
			// catch incase CommandProvider is not available
		}
		// close the registry tracker; this will stop the container if it was started
		registryTracker.close();
		registryTracker = null;
		// unset the app manager context after the container has been stopped
		AppPersistence.stop();
		if (frameworkLog != null) {
			frameworkLog.close();
			frameworkLog = null;
		}
		packageAdmin = null; // we do not unget PackageAdmin here; let the framework do it for us
		context = null;
	}

	private void getDebugOptions(BundleContext context) {
		ServiceReference debugRef = context.getServiceReference(DebugOptions.class.getName());
		if (debugRef == null)
			return;
		DebugOptions debugOptions = (DebugOptions) context.getService(debugRef);
		DEBUG = debugOptions.getBooleanOption(PI_APP + "/debug", false); //$NON-NLS-1$
		context.ungetService(debugRef);
	}

	private void processCommandLineArgs() {
		ServiceReference infoRef = context.getServiceReference(EnvironmentInfo.class.getName());
		if (infoRef == null)
			return;
		EnvironmentInfo envInfo = (EnvironmentInfo) context.getService(infoRef);
		if (envInfo == null)
			return;
		String[] args = envInfo.getNonFrameworkArgs();
		context.ungetService(infoRef);
		CommandLineArgs.processCommandLine(args);
	}

	public Object addingService(ServiceReference reference) {
		if (container != null)
			return null; // container is already started; do nothing
		Object service = context.getService(reference);
		if (registry == null && service instanceof IExtensionRegistry) {
			registry = (IExtensionRegistry) service;
			// create and start the app container
			container = new EclipseAppContainer(context, registry);
			container.start();
			return service;
		}
		// this means there is more than one registry; we don't need a second one
		context.ungetService(reference);
		return null;
	}

	public void modifiedService(ServiceReference reference, Object service) {
		// do nothing
	}

	public void removedService(ServiceReference reference, Object service) {
		// either the registry or launcher is going away
		if (service == registry)
			registry = null;
		if (container == null)
			return; // do nothing; we have not started the container yet
		// stop the app container
		container.stop();
		container = null;
	}

	// helper used to protect callers from permission checks when opening service trackers
	static void openTracker(final ServiceTracker tracker, final boolean allServices) {
		if (System.getSecurityManager() == null)
			tracker.open(allServices);
		else
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					tracker.open(allServices);
					return null;
				}
			});
	}

	// helper used to protect callers from permission checks when get services
	static Object getService(final ServiceTracker tracker) {
		if (System.getSecurityManager() == null)
			return tracker.getService();
		return AccessController.doPrivileged(new PrivilegedAction() {
			public Object run() {
				return tracker.getService();
			}
		});
	}

	// helper used to protect callers from permission checks when getting locations
	static String getLocation(final Bundle bundle) {
		if (System.getSecurityManager() == null)
			return bundle.getLocation();
		return (String) AccessController.doPrivileged(new PrivilegedAction() {
			public Object run() {
				return bundle.getLocation();
			}
		});
	}

	// helper method to get a bundle from a contributor.
	static Bundle getBundle(IContributor contributor) {
		if (contributor instanceof RegistryContributor) {
			try {
				long id = Long.parseLong(((RegistryContributor) contributor).getActualId());
				if (context != null)
					return context.getBundle(id);
			} catch (NumberFormatException e) {
				// try using the name of the contributor below
			}
		}
		if (packageAdmin == null)
			return null;
		Bundle[] bundles = packageAdmin.getBundles(contributor.getName(), null);
		if (bundles == null)
			return null;
		//Return the first bundle that is not installed or uninstalled
		for (int i = 0; i < bundles.length; i++)
			if ((bundles[i].getState() & (Bundle.INSTALLED | Bundle.UNINSTALLED)) == 0)
				return bundles[i];
		return null;
	}

	static BundleContext getContext() {
		return context;
	}

	public static EclipseAppContainer getContainer() {
		return container;
	}

	static void log(FrameworkLogEntry entry) {
		BundleContext bc = context;
		if (bc == null)
			return;
		ServiceReference ref = null;
		try {
			ref = bc.getServiceReference(FrameworkLog.class.getName());
			if (ref == null)
				return;
			FrameworkLog log = (FrameworkLog) context.getService(ref);
			if (log != null)
				log.log(entry);
		} finally {
			if (ref != null)
				bc.ungetService(ref);
		}
	}
}