We start with creating a new eclipse plugin project and create our wizard class. The NewElementWizard we want to extend resides in the org.eclipse.jdt.ui bundle. So we add both org.eclipse.jdt.ui and org.eclipse.jdt.core to our plugin manifest:

Then we create a new class "NewActivityWizard":

package newwizard;

import org.eclipse.jdt.internal.ui.wizards.NewElementWizard;

public class NewActivityWizard extends NewElementWizard {

}

First thing we get is a warning
"Discouraged access: The type NewElementWizard is not accessible due to restriction on required library /Applications/eclipse/plugins/org.eclipse.jdt.ui_3.5.1.r351_v20090821-0800.jar".

The NewElementWizard belongs to an internal package and is only exported (using the 'xfriends' directive) to some chosen bundles. So we have the choice to have a look at the code of NewElementWizard and implement our wizard by extending org.eclipse.jface.wizard.Wizard instead, or we could make our plugin a fragment. Fragments are part of the OSGi R4 release and according to the specification a fragment is “a bundle that is attached to a host bundle”, adding content to the target bundle. For now we choose the later alternative, just because it requires less work.

Next thing we have to do is to override some methods of the superclass and of course we want to add our own wizard page. Our wizardpage will extend the org.eclipse.jdt.ui.wizards.NewTypeWizardPage. The following code is pretty much the same as in the wizards used internally in JDT as for example org.eclipse.jdt.internal.ui.wizards.NewClassCreationWizard.

public class NewActivityWizard extends NewElementWizard {

	private NewActivityWizardPage newActivityPage = null;

	public NewActivityWizard() {
        setWindowTitle("My new Android Activity");
        newActivityPage = new NewActivityWizardPage();
    }

	@Override
	public void addPages() {
        addPage(newActivityPage);
    }

    @Override
	 public void init(IWorkbench workbench, IStructuredSelection selection) {
    	newActivityPage.init(selection);
    }

    @Override
	public boolean canFinish() {
       return super.canFinish() &&
                   getContainer().getCurrentPage() == newActivityPage;
    }

	@Override
	protected void finishPage(IProgressMonitor monitor)	throws InterruptedException, CoreException {
		newActivityPage.createType(monitor);
	}

	@Override
	public IJavaElement getCreatedElement() {
		return newActivityPage.getCreatedType();
	}
}

Next we have to define the extension in the fragment.xml:

The most interesting part of the wizard page is the code generation part. We want to generate a onCreate method that takes a android.os.Bundle as argument:

private void generateOnCreate(IType type, ImportsManager imports) throws CoreException, JavaModelException {
	StringBuilder buf = new StringBuilder();
	final String delim = "\n";
	buf.append("@Override");
	buf.append(lineDelim);
	buf.append("public void onCreate(");
	buf.append(imports.addImport("android.os.Bundle"));
	buf.append(" savedInstanceState) {");
	buf.append(lineDelim);
	buf.append("super.onCreate(savedInstanceState);");
	buf.append(lineDelim);
	final String content =
            CodeGeneration.getMethodBodyContent(type.getCompilationUnit(),
               type.getTypeQualifiedName('.'), "onCreate", false, "", delim);
	if (content != null && content.length() != 0)
		buf.append(content);
	buf.append(lineDelim);
	buf.append("}"); //$NON-NLS-1$
	type.createMethod(buf.toString(), null, false, null);
}

This is just the basic version of the new wizard, we also want to add intent actions and categories and update the Android manifest file. The complete source is available at http://github.com/kobmic/adt-extensions.

So how do we update the android manifest? As a Java programmer dom4j and XStream are some of my favourite XML frameworks - but I'm quite enthusiastic about Scala and Scala provides XML support baked into the language. The XML generation code for a new Android activtiy with a given list of intent actions and categories in Scala looks like this:

def createXML(activityName: String, intentActions: List[String], intentCategories: List[String]) : Node = {
  val xml =
    
         {for(action <- intentActions)
             yield {}}
	 {for(category <- intentCategories)
             yield {}}
      
    
   xml
}

Putting it all together

I chose to do the XML manipulation (written in Scala) and the Wizard (written in Java) in different OSGi bundles. If you don't have the eclipse Scala IDE installed you even need the Scala library 2.7.7 as OSGi bundle. You can download the wizard with or without Scala dependencies from http://github.com/kobmic/adt-extensions/downloads.

The complete wizard looks like this:

At time of writing there's a new version of MOTODEV studio available, now even as a set of plugins to eclipse:
http://developer.motorola.com/docstools/library/Installing_MOTODEV_Studio_for_Android/#installingStudioPlugins

The Eclipse plug-in MouseFeed, written by Andriy Palamarchuk, will repeatedly nag you with what keyboard shortcuts you can use instead of using the mouse to perform actions. For example, if you constantly left-mouse-click the "step-over" button in the debug perspective, the MouseFeed plug-in will pop-up a notification window telling you to instead press "F6" on your keyboard.

You can also make the plug-in even more annoying by having MouseFeed canceling the mouse operation so that you have to use the keyboard shortcut.

I have installed it and forgotten about it until today, when it gently reminded me that collapsing all nodes in the Package Explorer view could be issued by "Shift-Command Numpad_Divide" on Mac OS X. Unfortunately my laptop does not come with a numeric keyboard so I have better to remap the shortcut if I find myself collapsing nodes often.

The MouseFeed home page can be found at: http://www.mousefeed.com
The SourceForge project page: http://sourceforge.net/projects/mousefeed

I unpack it in "C:\Program Files\Subversion". To get the commands to work you have to add the bin to your path. In my case I add "C:\Program Files\Subversion\svn-win32-1.5.6\bin" to the path. After this I open up a command window and do the following:

mkdir subversionRepository
cd subversionRepository
svnadmin create project1

Now, in order to make Subversion work in Eclipse I add http://subclipse.tigris.org/update_1.6.x to my update sites. After downloading this I restart my Eclipse and go to Window -> Show View ->Other->SVN -> SVN Repositories.
I right click in the opened view and create a new repository location. Instead of writing a http adress in the URL window I now type "file:///C:/subversionRepository/project1". Notice the three forward slashes after "file:".

I now have an empty repository that I want to put my project into so I right click on the repository and add a new remote folder that I call trunk. Right clicking on the trunk I can now import my project by importing the folder that contains the .project file. I hit F5 to refresh the view and can see that the trunk is now filled with my first version of my project.

But I also have to associate the repository version with Eclipse, so now I right click in the Package Explorer and choose Import -> SVN -> Checkout Projects from SVN. I pick my previously created repository, click next, mark the trunk and then click finish. I get a question if I want to overwrite my previously created project with the same name and say ok. I won't need that now that I got a versioning system!

I can now finally continue my studies of the tool I was looking into.

One interesting problem was that in some of my tests, I had to mock the org.eclipse.core.resources.IResource interface. Nothing too hard about that, just write the following code, using EasyMock 2.4:

 
@Override
protected void setUp() throws Exception {
   super.setUp();
   resource1 = createMock("resource1", IResource.class);
   resource2 = createMock("resource2", IResource.class);
}
 

Now to my problem. First, I will discuss what the IResource.accept(IResourceVisitor visitor) metod does:
The IResource.accept(...) method traverses the directory structure under the resource. For each resource found, starting with the IResource on which accept() was called, the visitor.visit(IResource resource) method is called. If the visit(...) method returns true, the directory structure under the resource is traversed, otherwise traversing stops for that specific resource. This way parts of the directory structure under an IResource can be visited.

The problem I encountered was that since I have an IResource mock, there is no code for the accept() method. The mock will just register that there has been a call for accept(), but the code in the IResourceVisitor.visit(IResource resource), which I want tested, is never called.

What to do? There are different solutions, one example is to use an implementation of IResource, for example org.eclipse.core.internal.resources.Folder, and create a partially mocked object and keep the code for accept(). Not a nice solution though, my test would depend on internal code in the Eclipse project. What I did instead was to use the org.easymock.EasyMock.expectLastCall().andAnswer(IAnswer answer) functionality. The andAnswer() method takes an IAnswer callback implementation, like this:

 
public void testCollectRefreshStatus() throws CoreException {
   // Normal mock expects
   expect(resource1.getLocation()).andReturn(iPath1);
   expect(iPath1.toOSString()).andReturn(RESOURCE_PATH_1).times(2);
 
   // Provide code for accept(...)
   resource1.accept(isA(IResourceVisitor.class));
   expectLastCall().andAnswer(new IAnswer() {
      public Object answer() throws Throwable { // 1.
        IResourceVisitor visitor = (IResourceVisitor) EasyMock.getCurrentArguments()[0]; // 2.
        visitor.visit(resource2); // 3.
        return null;
      }
   });
   expect(resource2.getName()).andReturn("file.txt"); // 4.
 
   replayMocks();
 
   // Perform test
   myTestTarget.someMethod();
 
   // Verify test
   assertEquals(1, myTestTarget.getNumberOfResources());
   verifyMocks();
}
 

Here are some comments to the marked lines in the code above:

1. The answer() method is dictated by the IAnswer interface.
2. EasyMock provides a method to get access to the objects sent as parameters for the expected call. In this case, the call is resource1.accept(...) and the parameter is the IResourceVisitor implementation defined in myTestTarget, which is the code that should be tested.
3. Here the test code has control of the call to the IResourceVisitor.visit() and a mock IResource is provided as parameter. To make the test even better, the boolean return value from the visit() call should be saved and asserted for the correct value to ensure that the intended traversing works as expected.
4. Here the expectations on the mock IResource, for the visit(IResource ...) call, is defined. In this case myTestTarget calls getName() on IResource for some reason, so expectations for that is defined together with a resulting return value that would steer the logic in some direction.

This way the test has full control of the visitor implementation and it is fairly easy to test all the criterias that makes the IResourceVisitor.visit(...) implementation return true or false. Also, the visit() method often changes state of something else, and here it is also possible to test that the state is changed correctly by simulating multiple visit(...) calls, by adding more calls to visit at 3. in the code above.

/Tobias Södergren

Lots of tutorials

The first day was the tutorial day with 22 simultaneous labs and tutorials. All in
all there were about 80 sessions that you could attend, including “An introduction
to Pax tools for OSGi” hosted by Stuart. Unfortunately we did not have time to
see all of the tutorials, and it was often difficult deciding which ones to attend.

The sessions ranged from “introduction” to “advanced” in both core Eclipse, such as Equinox and the Debugger frameworks, and in the variety of sub-projects such as GMF, eRCP, BIRT etc. One interesting session was about the new debugger service framework, abbreviated as DSF, which supports asynchronous calls to and callbacks from the debug target. Much of the framework is dealing with the issues that stem from working asynchronously.

The framework is created by Windriver, a big player in C/C++ development for embedded devices, because debugging embedded devices in most cases has a different nature than debugging Java code. Embedded devices often have slow communication links and the response often come in data chunks because of optimization issues. These characteristics do not fit well with the standard debugging framework in Eclipse.

The OSGi tutorials were well attended, with the Spring Dynamic Modules tutorial almost standing room only. It was also good to see a lot of interest in the OSGi service registry from plugin developers, who are more used to the Eclipse extension point registry. The overall feeling was that most people knew the basics of OSGi and were now eager to learn best practices and more advanced use.

Fake Steve Jobs

Tuesday was the starting day of the “ordinary” conference. The keynote speaker was Dan Lyon a.k.a Fake Steve Jobs. Dan Lyon has been working as a tech writer for many years, and started his blog called Fake Steve Jobs where he was writing tech articles as he thought Steve Job would have written them. After a while, people started to try and guess who this Fake Steve guy was and ultimately his own boss was discussing it openly, to his surprise. Dan had no choice but to come clean, but the popularity of the blog still remained. Sun, Microsoft, Oracle and even Eclipse get hit by his wild bashes, where the latter was something he was nervous about, being a keynote speaker at EclipseCon. But not everything is fictional and as he put it: - People are returning because I occasionally put some seriousness in my blog entries.

Services vs. Extensions

Among the interesting sessions for the day, was a session by Neil Bartlett regarding how to integrate Eclipse Extensions in OSGi services and vice versa. Eclipse extensions are the base for how plug-ins extend the Eclipse platform, such as adding menu entries, dialogs, wizards etc. to the workbench. OSGi is the platform on which Eclipse plug-ins are implemented, and it provides modularity and dynamic services. By using extensions and OSGi services it is possible to write very modular applications which supports lazy loading, being robust and dynamic in nature.

Services + Extensions using dependency injection

Neil also gave a talk on how dependency injection could bridge the gap between extension points and services. This is a very promising approach because it would free developers from having to decide which one to use in their components, and this decision could then be made at configuration/ deployment time. The prototype work is now being continued in an official Eclipse incubator project.

Automatically repairing pre-OSGi code

Erik Wistrand from Makewave (Knopflerfish framework) had a short talk on using bytecode manipulation at load-time to automatically detect and repair potentially problematic legacy code. This is a popular topic at the moment, as many people are looking at how to migrate their current applications to OSGi so they can start taking advantage of OSGi for new components.

OSGi on Android

In another session, Neil Bartlett and BJ Hargrave, a senior manager at IBM, were
presenting how they got two different open-source OSGi containers running on the Google Android mobile platform. Both Equinox, the OSGi container developed by Eclipse, and Concierge which is a small container and a research project developed at ETH Zurich, were running on the Android emulator.

Other OSGi frameworks able to run on Android are Apache Felix, which was the first container running on it, and mBedded Server, which is a commercial OSGi container developed by ProSyst. Being able to run is not the same as being supported by Google though, but it is interesting to see that there was not that much work involved in introducing OSGi to Android.

Open Source Microsoft

Wednesday started off with a keynote from Sam Ramji, director of the Open Source Software Lab at Microsoft. Knowing that the audience was probably quite skeptical about Microsoft’s relationship with open-source Sam’s first slide was about project “Supernova”, where Microsoft decides to buy Eclipse and use it for Visual Studio because they really love Java! After that ice-breaker, Sam went on to discuss some of the open-source projects his lab works on, such as dynamic languages, and how Microsoft has much more focus on interoperability these days. He already has developers working with Mozilla and Apache, but more relevant for Eclipse, they are looking at helping with SWT (Standard Widget Toolkit) support for WPF (Windows Presentation Foundation).However, during the Q&A session Sam said there’s no plan for Microsoft to join Eclipse, or even have their developers become committers, which made this sound like a token effort.

Eclipse 4.0

The initial work of Eclipse 4.0 was presented by Mike Wilson, Jochen Krause, Jeff McAffer and Steve Northover. The current state is “wild ideas” and the trends getting focus in this release are that Java software development is moving into Rich Web GUI backed by services, and that the IDE will move to be a mix of web and desktop targets. The presenters want to see an effort to take what currently exists and put it “in the web space”.

The community work in Eclipse is quite good today, but people need to be much more involved in the future platform.

They also want to see that work is put into making it easier to create plug-
ins with a more uniform API in Eclipse. There will probably be some kind of dependency injection framework available to make it easier to use services and resources. The platform should be better documented, the API should be reasonably sized, and the API should be RESTful and accessible by JavaScript.

The timeline for e4 (Eclipse 4.0 platform) is that the project will be proposed and started after the Eclipse Summit later this year. Until now, everything is ideas that may or may not be included in the project. There will be regular platform builds of e4, including milestones, and it will be ready within 2 years from start.

It will not be an easy task to create the next version of the Eclipse platform, because of its widespread use and the many wills of the multitude of Eclipse projects. The time when Eclipse was just a Java IDE is now long gone and there are a lot of people that have invested a lot, both in time and money, in their existing projects.

API Tooling

Among the things that make OSGi, and also the plug-in concept of Eclipse, great is the possibility of having different versions of the same functionality available for applications without conflict. One application might need version 1.x of a jar file while another requires an API incompatible version 2.x, and with proper versions on the packages there will be no conflict. Although being a good thing, it can be quite challenging to keep the versions correctly updated. Sometimes the changes you do to a code base might break an API compatibility, sometimes not. To remedythe situation in Eclipse, there is a new toolkit called “API Tooling”. The description, which is taken directly from the developer site, states: “API tooling will assist developers in API maintenance by reporting API defects such as binary incompatibilities, incorrect plug-in version numbers, missing or incorrect @since tags, and usage of non-API code between plug-ins”. An example of functionality in the toolkit is that offending code is marked in eclipse and quick-fix will be provided for changes that can be automated. The tools are scheduled to be included in the Eclipse Ganymede release in June.

Information Economy

Thursday’s keynote was given by Cory Doctorow about the “information economy” where information is a commodity, and you should therefore try to keep the cost of “creating” information low. This was a very entertaining talk where he stressed the importance of collaboration over restricting access. With collaboration you can (hopefully) still maintain a competitive edge - while restricting access to information is a temporary solution that often drives up costs, like old fashioned protectionism. Cory finished by asking everyone to help preserve their existing freedoms, such as the freedom on the Internet.

Some reflections

It was nice to see that that OSGi as a concept has matured among both the speakers and visitors as opposed to last years EclipseCon where it was more in a state of hype and excitement. It was also interesting that OSGi is creeping into mobile phones, Spring revealed their Titan platform for Windows Mobile phones containing an OSGi container besides being MIDP compatible. Another announcement made during the conference was that EclipseLink has been chosen as the JPA 2.0 Reference implementation.

Tobias Södergren and Stuart McCulloch

Originally published in JayView.