A simple Eclipse Plugin to Call a FM when an editor is opened

[matt]

Introduction

Bärbel Winkler asked a question about how to trigger some kind of popup in ADT/Eclipse using information held on the backend application server.

I realise one solution would be to have some code run every time an (ABAP) editor was opened in Eclipse. This code would call a function module on the backend, which could take some information and return a message in a popup in Eclipse.

This seemed like a fun little project; this is how I did it.

Getting started

For plugin development on Eclipse, you need the PDE (Plugin Development Environment). You can get it here. I installed it in a new folder, and then installed ADT on top. This is needed so that we can easily access the backend.

Creating the project

The first step is to create a plugin project. I called it popup. When you create a project you're offered a list of templates, but I didn't want any of those. Plugins work on Extension Points built into the Eclipse software. The Extension Point I needed is org.eclipse.ui.startup. This allows me to put my own program to run when eclipse starts up.

To get that I first needed to add the dependency org.eclipse.ui, which contains the required Extension Point.

Dependencies Tab

The following dependencies are needed later in the Java classes, so must also be added.

• com.sap.adt.project


• org.eclipse.core.runtime


• org.eclipse.core.resources


• com.sap.conn.jco

When I added the Extension Point, a default startup element was created. It has one property - that name of the class that's to be used for the extension.

Extensions Tab

All I need to do now is create the class and implement my code!

Implementing the classes

The first class is RegisterListenerAtStartup.

package com.xiting.popup;



import org.eclipse.swt.widgets.Display;



public class RegisterListenerAtStartUp implements org.eclipse.ui.IStartup {



	@Override

	public void earlyStartup() {

		Display.getDefault().asyncExec(new ListenerForPopup());

	}



}

The idea is to register a class which implements IPartListener2. In Eclipse, a part is a View or an Editor. Registering the class means that the Eclipse framework will trigger my method when an event happens on a Part - specifically, I want it to trigger when a part is opened.

In order to do this, I need an object called the active workbench window. Unfortunately, at the startup, this object is not yet initialised - it is null.

The way to get round this is to use a little trick, so that when the display is ready, the listener registration code is run. I called that class ListenerForPopup

package com.xiting.popup;



import org.eclipse.ui.IPartListener2;

import org.eclipse.ui.IPartService;

import org.eclipse.ui.IWorkbenchPartReference;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PlatformUI;



public class ListenerForPopup implements Runnable, IPartListener2 {

	private static final String ADT_PREFIX = "com.sap.adt";



	@Override

	public void partOpened(IWorkbenchPartReference partRef) {

		if (!(partRef.getPart(true) instanceof IProjectProvider))

			return;

		String id = partRef.getId();

		if (id.startsWith(ADT_PREFIX)) {

			JCoDestination destination;

			try {

				destination = getDestination(partRef.getPart(true));

				String objectName = partRef.getPart(true).getTitle().substring(5); //Trim off sy-sysid

				new FunctionModuleCaller().run(objectName, destination);

			} catch (JCoException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

	}



	@Override

	public void run() {

		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();

		IPartService partService = window.getPartService();

		IPartListener2 listener = new ListenerForPopup();

		partService.addPartListener(listener);

	}



	private JCoDestination getDestination(IWorkbenchPart part) throws JCoException {

		IProjectProvider projectProvider = (IProjectProvider) part;

		IProject project = projectProvider.getProject();

		String destinationId = AdtCoreProjectServiceFactory.createCoreProjectService().getDestinationId(project);

		return JCoDestinationManager.getDestination(destinationId);

	}

}

Now, you'll see it implement Runnable (which has one method, the method run) and that's what asyncExec takes as a parameter in RegisterListenerAtStartup. 

In a more complex development, I'd probably have implemented Runnable in one class and IPartListener2 in another - but this is simple so I've put them together.

I've only overridden one method of IPartListener2, the one whichs runs when a part is opened. It checks that the id of the part begins with com.sap.adt - which all the ABAP editor types do - and that it is an IProjectProvider - this is needed to determine the destination of the backend. Then we launch the function module with the name of the object - which will of the form <SYSID> Object name. So, for example: [D01] ZMATT

The Function Module

On the backend, I created this RFC enabled function module.

FUNCTION z_matt_test1.

*"----------------------------------------------------------------------

*"*"Local Interface:

*"  IMPORTING

*"     VALUE(I_OBJECT) TYPE  PROGNAME

*"  EXPORTING

*"     VALUE(E_MESSAGE) TYPE  BAPI_MSG

*"----------------------------------------------------------------------



  e_message = `This was triggered by opening object` && i_object.



ENDFUNCTION.

Quite simple. It constructs a message based on whatever I_OBJECT contains.

I then wrote the Java class, FunctionModuleCaller using standard JCo techniques.

package com.xiting.popup;



import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.swt.widgets.Display;



import com.sap.conn.jco.JCoDestination;

import com.sap.conn.jco.JCoException;

import com.sap.conn.jco.JCoFunction;



public class FunctionModuleCaller {

	private static final String FM = "Z_MATT_TEST1";



	public void run(String objectName, JCoDestination destination) throws JCoException {

		JCoFunction function = destination.getRepository().getFunction(FM);

		function.getImportParameterList().setValue("I_OBJECT", objectName);

		function.execute(destination);

		String message = function.getExportParameterList().getString("E_MESSAGE");

		if (!(message.isBlank()))

			MessageDialog.openInformation(Display.getCurrent().getActiveShell(), "", message);

	}

}

Results

And that's it. As intended, when I open up an ABAP editor in Eclipse, I get the following result.

Of course, you can write your FM to do whatever you like!

The GIT repository is here: https://github.com/matthewdjb/JustAPopup, with all the source code, the feature project and the update site project that you'll need to be able to deploy your own version - suitable adjusted of course!

If you just want to use the code "as is", you can download com.xiting.popup.install.zip from the repository directly. Unzip it to a folder, and then point Eclipse to that as a local update site.