Find Eclipse IDE Information - Eclipse Plugin Development

This simple Eclipse plugin program shows you how to retrieve following information regarding the Eclipse IDE.

• IDE name
• IDE version (.., Kepler, Luna, Mars,..etc with version number) 
• Plugin version
• Platform user name

You can test the program by running it your RCP environment. When you ran it, click on the LakJ Comspace icon in the tool bar of Eclipse sandbox window. Then you will see the information.
Following is the java code related to the program. You can download the complete project from the github links given at the end of the tutorial.

	package com.lakj.comspace.eclipse.info;
	import org.eclipse.jface.resource.ImageDescriptor;
	import org.eclipse.ui.plugin.AbstractUIPlugin;
	import org.osgi.framework.BundleContext;
	/**
	* The activator class controls the plug-in life cycle
	*/
	public class Activator extends AbstractUIPlugin {
	// The plug-in ID
	public static final String PLUGIN_ID = "com.lakj.comspace.eclipse.info"; //$NON-NLS-1$
	// The shared instance
	private static Activator plugin;
	/**
	* The constructor
	*/
	public Activator() {
	}
	/*
	* (non-Javadoc)
	* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
	*/
	public void start(BundleContext context) throws Exception {
	super.start(context);
	plugin = this;
	}
	/*
	* (non-Javadoc)
	* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
	*/
	public void stop(BundleContext context) throws Exception {
	plugin = null;
	super.stop(context);
	}
	/**
	* Returns the shared instance
	*
	* @return the shared instance
	*/
	public static Activator getDefault() {
	return plugin;
	}
	/**
	* Returns an image descriptor for the image file at the given
	* plug-in relative path
	*
	* @param path the path
	* @return the image descriptor
	*/
	public static ImageDescriptor getImageDescriptor(String path) {
	return imageDescriptorFromPlugin(PLUGIN_ID, path);
	}
	}

view raw Activator.java hosted with ❤ by GitHub

	package com.lakj.comspace.eclipse.info.actions;
	import org.eclipse.jface.action.IAction;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.ui.IWorkbenchWindow;
	import org.eclipse.ui.IWorkbenchWindowActionDelegate;
	import org.eclipse.jface.dialogs.MessageDialog;
	/**
	* Our sample action implements workbench action delegate. The action proxy will
	* be created by the workbench and shown in the UI. When the user tries to use
	* the action, this delegate will be created and execution will be delegated to
	* it.
	*
	* @see IWorkbenchWindowActionDelegate
	*/
	public class InfoAction implements IWorkbenchWindowActionDelegate {
	private IWorkbenchWindow window;
	/**
	* The constructor.
	*/
	public InfoAction() {
	}
	/**
	* The action has been activated. The argument of the method represents the
	* 'real' action sitting in the workbench UI.
	*
	* @see IWorkbenchWindowActionDelegate#run
	*/
	public void run(IAction action) {
	String info = InfoUtil.findIdeInfo();
	MessageDialog.openInformation(window.getShell(), "Eclipse-IDE-Info", info);
	}
	/**
	* Selection in the workbench has been changed. We can change the state of
	* the 'real' action here if we want, but this can only happen after the
	* delegate has been created.
	*
	* @see IWorkbenchWindowActionDelegate#selectionChanged
	*/
	public void selectionChanged(IAction action, ISelection selection) {
	}
	/**
	* We can use this method to dispose of any system resources we previously
	* allocated.
	*
	* @see IWorkbenchWindowActionDelegate#dispose
	*/
	public void dispose() {
	}
	/**
	* We will cache window object in order to be able to provide parent shell
	* for the message dialog.
	*
	* @see IWorkbenchWindowActionDelegate#init
	*/
	public void init(IWorkbenchWindow window) {
	this.window = window;
	}
	}

view raw InfoAction.java hosted with ❤ by GitHub

	/**
	*
	*/
	package com.lakj.comspace.eclipse.info.actions;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URL;
	import java.util.PropertyResourceBundle;
	import org.eclipse.core.runtime.FileLocator;
	import org.eclipse.core.runtime.IProduct;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Platform;
	import org.osgi.framework.Version;
	import com.lakj.comspace.eclipse.info.Activator;
	/**
	* The utility class to find Eclipse IDE Information.
	*
	* @author Lak J Comspace
	*
	*/
	public class InfoUtil {
	/**
	* This method finds and shows the Eclipse IDE Information in a message box.
	*/
	public static String findIdeInfo() {
	StringBuilder infoStringBuilder = new StringBuilder();
	IProduct eclipseProduct = Platform.getProduct();
	// IDE name.
	String ideName = eclipseProduct.getName();
	infoStringBuilder.append("IDE Name: ").append(ideName).append("\n");
	// IDE version.
	// Here we use the way
	// org.eclipse.ui.internal.ProductProperties.getAboutText() has used to
	// find version number.
	URL location = FileLocator.find(eclipseProduct.getDefiningBundle(), new Path("$nl$/about.mappings"), null);
	if (location != null) {
	StringBuilder ideVersionBuilder = new StringBuilder();
	try (InputStream is = location.openStream()) {
	PropertyResourceBundle bundle = new PropertyResourceBundle(is);
	try {
	String versionName = bundle.getString("1");
	ideVersionBuilder.append(versionName);
	} catch (Exception e) {
	e.printStackTrace();
	}
	String versionNumber = null;
	try {
	versionNumber = bundle.getString("2");
	ideVersionBuilder.append(" (").append(versionNumber).append(")");
	} catch (Exception e) {
	e.printStackTrace();
	}
	// Sometimes this above step doesn't capture the version number.
	// Then we try the bellow option.
	if (versionNumber == null) {
	Version version = eclipseProduct.getDefiningBundle().getVersion();
	ideVersionBuilder.append(" (").append(version.toString()).append(")");
	}
	} catch (IOException e) {
	e.printStackTrace();
	}
	String ideVersion = ideVersionBuilder.toString();
	infoStringBuilder.append("IDE Version: ").append(ideVersion).append("\n");
	}
	// Plugin version.
	String pluginVersion = Platform.getBundle(Activator.PLUGIN_ID).getVersion().toString();
	infoStringBuilder.append("LakJ Plugin Version: ").append(pluginVersion).append("\n");
	// System user name.
	String username = System.getProperty("user.name");
	infoStringBuilder.append("System Username: ").append(username);
	return infoStringBuilder.toString();
	}
	}

view raw InfoUtil.java hosted with ❤ by GitHub

Here the InfoUtil.java does the information retrieving. Rest of the two classes (Activator and InfoAction) help the program to behave as a Eclipse plugin.

Following are the GitHub URL's for complete plugin project. You can clone the project or downolad the project as a zip file. To run the project open an Eclipse RCP environment and import the project as a maven project.

GitHub repository URL - https://github.com/lakjcomspace/Eclipse-Find-IDE-Info
GitHub HTTPS clone URL - https://github.com/lakjcomspace/Eclipse-Find-IDE-Info.git
Download Project as a Zip - https://github.com/lakjcomspace/Eclipse-Find-IDE-Info/archive/master.zip