Developing and deploying rich client applications on desktops and mobile devices using IBM Lotus Expeditor V6.1

Learn how to use the new IBM Lotus Expeditor V6.1 framework to create many views of the same application. Componentize your services in compliance with SOA and build a Rich Client Platform (RCP) application that can run on either a desktop computer or a mobile device.

Share:

Shiva Nistala, Advisory Software Engineer, IBM

Shiva Nistala is an Advisory Software Engineer with IBM Developer Relations. Shiva is actively involved with technical enablement of IBM Business Partners who use IBM WebSphere Portal, IBM Lotus Connections, and related technologies and tools. Shiva has written and spoken on several topics related to WebSphere Portal and Lotus Collaborative technologies. You can reach him at shivan@us.ibm.com.



Ricardo Rossi (rjrossi@us.ibm.com), Advisory Software Engineer, IBM

Ricardo Rossi is an Advisory Software Engineer at IBM Innovation Center in Dallas, Texas. He is responsible for developing and teaching IBM Lotus Expeditor and IBM Lotus Notes workshops as well as participating in proof-of-concept and other customer engagements. He holds a Master of Science degree in Information Technology & Management from the University of Texas at Dallas.



06 February 2008 (First published 01 May 2007)

Also available in Russian

Have you ever wondered how to expand the reach of your applications to multiple client devices? Try the new IBM Lotus Expeditor V6.1 framework to create multiple views of the same application that allow smart phones, PDAs, and mobile devices to interact with your software systems seamlessly. The Lotus Expeditor framework supports a multitude of open standard technologies, such as Web services, messaging, and enterprise service bus (ESB), enabling you to componentize and choreograph your services in compliance with Service-Oriented Architecture (SOA). In this article we describe how to build a Rich Client Platform (RCP) application that can be run either on a traditional computer or on a mobile device. Keeping in line with MVC architecture, we create multiple views for the same model and display the correct view based on the type of invoking client.

Although this article is introductory in nature, we assume that you are familiar with Java programming and at a minimum, have basic exposure to one of the Java IDEs such as Eclipse or IBM Rational Application Developer.

IBM Lotus Expeditor

IBM Lotus Expeditor is the new name for IBM WebSphere Everyplace Deployment. It is a comprehensive runtime and supporting environment to enable the development, deployment, and execution of client-side applications that extend the Service-Oriented Architecture beyond the existing network boundaries. Using Lotus Expeditor, you can empower your users with high-performing, secure, robust, rich user interface applications that can work even while on limited network connectivity. This can improve user productivity dramatically and, at the same time, reduce network traffic. Lotus Expeditor can be split into server and client components.

The server components are there purely to support the clients. Services offered by the Lotus Expeditor server include:

  • Database Synchronization Server
  • MQ Everyplace Server
  • Device Management Server

On the Lotus Expeditor client, the runtime environment includes:

  • A Web container (for execution of JSPs 1.2 and 2.0 and Servlets 2.3 and 2.4)
  • An embedded transaction container (which is a limited version of a J2EE Enterprise Java Bean container)
  • A rich client UI
  • A portlet container (new in Lotus Expeditor V6.1 for the remote deployment of JSR168 portlets)
  • Local Web services client and server capabilities
  • Lightweight assured messaging (MQ Everyplace)
  • Lightweight JDBC accessible databases (IBM Cloudscape or IBM DB2 Everyplace on PC class devices and DB2 Everyplace on handheld devices)
  • A device management agent to enable the remote auditing of the client as well as the over-the-air deployment of new or updated applications

Lotus Expeditor is built on top of Eclipse 3.2, an open development platform. You can get full details on Eclipse at the Eclipse Web site. For the purposes of this article, the two names Lotus Expeditor client toolkit and toolkit are interchangeable and represent the same thing. You can install the toolkit on top of Eclipse 3.2 and Web Tools Project 1.5.1, or you can install the toolkit on top of IBM Rational Application Developer V7.0 (which is built on Eclipse 3.2).

In this article we describe how to use the Lotus Expeditor client toolkit to develop an RCP application that can run either on a desktop or on a mobile device.

To make the description easier to follow, we provide screen captures and step-by-step instructions on how to create a sample RCP application. The actual sample application contains several Java class files, but we ask you to code only a few important methods that are specific to the overall understanding of building an application for the Lotus Expeditor client. Therefore, we include a starter application that has the business logic coded for you. You have to import this starter application as a part of completing the application. Refer to the Downloads section of this article for links to the starter application and the completed application.

We assume that you have already installed Lotus Expeditor on Rational Application Developer 7.0 or on IBM Rational Software Architect. See the Resources section for further information on how to install Lotus Expeditor. Although the screen captures we show are related to Rational Software Architect, the outline of the steps and the concepts remain more or less the same if you were to choose any of the other foundation products required for the Lotus Expeditor toolkit to run.

Download a trial version of

Rational Software Architect

and a trial version of

Rational Application Developer for WebSphere Software V7.0

.

To create an application and to deploy it on the Lotus Expeditor client, you need to complete the following tasks:

  • Create a Client Services project.
  • Write a simple rich client plug-in.
  • Add required extension points.
  • Run the RCP application on Lotus Expeditor.
  • Configure the RCP project to support devices.
  • Run the RCP application on the jclDevice workbench.
  • Deploy and run the RCP application on a device.

Create a Client Services project

The first step toward creating an RCP application is creating a Client Services project. In this activity, you simply create a Client Services project, which acts as a container for a rich client plug-in.

Create a new workspace

Before you create any type of project in an Eclipse-based development environment, you must choose a workspace area to store all your project-related files and configuration. Select a workspace to store your files, and change to the perspective suitable for a Client Services project.

  1. Open Rational Software Architect or Rational Application Developer. Throughout this article, we assume that you use the toolkit that has already been installed in Rational Software Architect.
  2. When you are prompted to select a workspace, enter a new workspace name.
  3. When the prompt shown in figure 1 appears asking you to automatically set the preferences for the Lotus Expeditor toolkit, click OK and wait for the process to complete.
Figure 1. Setting preferences
Setting preferences
  1. When your workspace opens, close the Welcome page and switch to the Plug-in Development perspective by choosing Window - Open Perspective - Other from the menu.
  2. Select the Plug-in Development perspective and click OK.

Create a new Client Services project

The Lotus Expeditor toolkit adds capabilities to create Client Services types of projects for your existing development environment (Rational Application Developer, Rational Software Architect, or Eclipse). In this step, you create a Client Services project.

  1. Choose File - New - Project from the menu.
  2. In the Select a Wizard window, expand the Client Services folder, and then select Client Services Project.
  3. Click Next.
  4. Enter com.ibm.lotusphere.rcp for Project name and use defaults for other settings in the "Create a new Client Services Plug-in Project" window. Click Next.
  5. Accept defaults. Enter the data required to generate the plug-in and click Next.
  6. In the window Select the Target Definition and Target Features for this project, ensure that the Target drop-down shows Default Target, and click Finish to create the new project.

Write a simple rich client plug-in

In this activity, you import the starter application into the Client Services project that you created in the previous step. This import creates an RCP plug-in in the existing Client Services project. After the import is completed, you also implement the Views and UI classes that represent the application’s user interface. Before you proceed with this step, download the starter application RCP_Files.zip (see the Downloads section of this article) to a temporary directory such as C:\temp.

Import resources

The Eclipse architecture provides a way to export and import project files to facilitate portability and ease of development. We created the starter application and exported it as RCP_Files.zip. In this section, you import this file to get all the business logic and the configuration. Feel free to explore all the XML files and the Java files to better understand the application.

  1. Select the com.ibm.lotusphere.rcp project in the Package Explorer, right-click, and choose Import.
  2. In the next window, expand the General node and select the Archive File wizard.
  3. Click Next.
  4. In the next window, browse for the archive file you have downloaded, RCP_Files.zip, and make sure the root node is selected as shown in figure 2.
Figure 2. Select the archive files to import
Select the archive files to import
  1. Click Finish to import the files into the project.

Create the user interface

In this activity, you create a view for your application. Views vary for different types of devices. Such differences in the screen rendering are already taken care of by Lotus Expeditor. You should ensure, though, that any branding material, such as an image, is suitable for a particular target device. In the sample application we show four items, a label, a drop-down list, an image, and a text box. The image file represents the flag of a particular country selected in the drop-down list. We created two flag images for each country, one slightly larger than the other; otherwise, they are identical. The larger image should be displayed for a desktop client; the smaller image should be displayed for a mobile client. In the following steps, you create a UI Java class that encapsulates the user interface. This UI class is used by both the mobile client and the desktop client. To distinguish different types of clients (in this case, we have only two), you create an instance variable isDesktop. This variable is programmatically set by a calling Java class (also coded in a later step) that depends upon the type of client.

  1. Expand the com.ibm.lotusphere.rcp project in the Package Explorer View, and then expand the src folder.
  2. Select the com.ibm.lotusphere.rcp package, right-click, and then choose New - Class from the menu.
  3. In the New Java Class dialog box, make sure com.ibm.lotusphere.rcp is selected as the package name and enter UI as the new class name.
  4. Click the Add button, type org.eclipse.swt.events.SelectionListener in the Choose interfaces field, click the Add button, and then click the OK button.
  5. Make sure that Inherited abstract methods is selected as shown in figure 3.
Figure 3. Create the UI Java class
Create the UI Java class
  1. Click Finish to view the newly created user interface class UI.java in the editor area of the workbench.
  2. Add the following instance variables right after the class definition as shown in listing 1.
Listing 1. Instance variables in class
private Composite c;
private Label flag;
private Combo combo;
private boolean isDesktop = true;
private Text results;
  1. Right-click anywhere in the Java editor and choose Source - Organize Imports from the context menu.
  2. If prompted, select the org.eclipse.swt.widgets.Text class and click Finish.
  3. In the UI Java class editor, create a new constructor with an argument as shown in the code that follows:

    public UI (boolean isDesktop) {
    this.isDesktop = isDesktop;
    }
  4. Next, create the makeUI() method in the UI Java class with the content shown in listing 2.
Listing 2. Method that creates the UI for the application
public Composite makeUI (Composite parent)  {
 
c = new Composite (parent, SWT.NONE);
GridLayout grid = new GridLayout ();
grid.numColumns = 1;
c.setLayout (grid);
			 
final Label label = new Label (c, SWT.NONE);
label.setText ("Select a country from the list:");
	
combo = new Combo (c, SWT.READ_ONLY);
Utils.loadCountryList (combo);
combo.addSelectionListener (this);
	
flag = new Label (c, SWT.FLAT);
	
results = new 
Text (c, SWT.WRAP | SWT.READ_ONLY | SWT.V_SCROLL);
	
GridData gridData = new GridData ();
gridData.grabExcessHorizontalSpace = true;
gridData.grabExcessVerticalSpace = true;
gridData.verticalAlignment = GridData.FILL;
gridData.horizontalAlignment = GridData.FILL;
results.setLayoutData (gridData);
	
return c;
}
  1. Right-click anywhere in the editor area and choose Source - Organize Imports.
  2. Change the widgetSelected() method to include the following lines of code as shown in listing 3.
Listing 3. Change WidgetSelected Method
public void widgetSelected (SelectionEvent arg0)  {
	// TODO Auto-generated method stub
	Utils.loadFlag (flag, combo.getSelectionIndex (), isDesktop);
	c.layout ();
	String countryStats = "";
	int idx = combo.getSelectionIndex () - 1;
	if (idx >= 0)  {
		Countries stats = new Countries(idx);
		countryStats = 
			"Capital: " + stats.getCapital () +
			"\nPopulation: " + stats.getPopulation () +
			"\nArea: " + stats.getArea () +
			"\nCurrency: " + stats.getCurrency () +
			"\nGDP: " + stats.getGDP () +
			"\nPer Capita GDP: " + stats.getPerCapitaGDP () +
			"\nGrowth Rate: " + stats.getGrowthRate () +
			"\nInflation: " + stats.getInflation () +
			"\nEthnicity: " + stats.getEthnicity () +
			"\nLanguages: " + stats.getLanguages () +
			"\nReligions: " + stats.getReligions ();
	}

	results.setText (countryStats);
	c.layout ();
}
  1. Change the widgetDefaultSelected() method to include code shown in listing 4.
Listing 4. widgetDefaultSelected Method
public void widgetDefaultSelected (SelectionEvent arg0)  {
	// TODO Auto-generated method stub
	widgetSelected (arg0) ;
}
  1. Save and close UI.java.

Create the desktop view

The sample application can be accessed by a desktop client as well as by a mobile client. You start by creating a desktop view class that calls the UI class created earlier.

  1. Select the com.ibm.lotusphere.rcp package in the Package Explorer, then right-click and choose New - Class from the menu.
  2. In the New Java Class dialog box, make sure com.ibm.lotusphere.rcp is selected as the package and type DesktopView as the new class name and type org.eclipse.ui.part.ViewPart as its superclass. See figure 4.
Figure 4. Create a DesktopView class
Create a DesktopView class
  1. Make sure Inherited abstract methods is selected.
  2. Click Finish to generate the new class. At this time, the DesktopView.java should be viewable in the editor area of the workbench.
  3. In DesktopView.java change createPartControl() method to call the UI class method as shown in listing 5.
Listing 5. createPartControl() method in DestopView class
public void createPartControl (Composite parent) {
	UI ui = new UI (true);
	ui.makeUI (parent);
}
  1. Save and close DesktopView.java.

Create the device view

In this activity, you create a mobile client view that calls the UI Java class created earlier.

  1. Select the com.ibm.lotusphere.rcp package in the Package Explorer, then right-click and choose New - Class from the menu.
  2. In the New Java Class dialog box, select the com.ibm.lotusphere.rcp package, type DeviceView as the new class name and type org.eclipse.ui.part.ViewPart as its superclass.
  3. Make sure the Inherited abstract methods option is selected.
  4. Click Finish to generate the new class. At this time, the DeviceView.java should be viewable in the editor area of the workbench.
  5. In DeviceView.java, change createPartControl() method to call the UI class method as shown in listing 6.
Listing 6. createPartControl() method in DeviceView class
public void createPartControl (Composite parent) {
	UI ui = new UI (false);
	ui.makeUI (parent);
}
  1. Save and close DeviceView.java.

Add required extension points

Eclipse extensions and extension points are used to extend the functionality of the platform or other plug-ins (applications or services). In this activity, you add the required extension to the plug-in in the view classes you created in the last section.

  1. Open the plug-in descriptor file MANIFEST.MF located under the META-INF folder using the Package Explorer view. Once it is opened, select the Extensions tab.
  2. Click the Add button to open the New Extension wizard.
  3. In the wizard, type org.eclipse.ui.views in the Extension Point Filter field, and then select it from the results box as shown in figure 5.
Figure 5. Add the views extension point
Add the views extension point
  1. Click Finish to create the extension.
  2. In the plug-in descriptor file, select the newly created extension org.eclipse.ui.views from the All Extensions list, right-click it, and then choose New - View from the menu.
  3. Change the extension element details to the following values as shown in figure 6.

    • id: com.ibm.lotusphere.rcp.DesktopView
    • name: Desktop View
    • class: com.ibm.lotusphere.rcp.DesktopView
    • category: org.eclipse.ercp.eworkbench.viewCategory
Figure 6. DesktopView extension properties
DesktopView extension properties
  1. In the plug-in descriptor file, select again the extension point org.eclipse.ui.views from the All Extensions list, right-click it, and then choose New - View from the menu.
  2. Change the values for the new extension element to the following values as shown in figure 7.

    • id: com.ibm.lotusphere.rcp.DeviceView
    • name: Device View
    • class: com.ibm.lotusphere.rcp.DeviceView
    • category: org.eclipse.ercp.eworkbench.viewCategory
Figure 7. DeviceView extension properties
DeviceView extension properties
  1. In the plug-in descriptor file, click the Add button again to open the New Extension wizard.
  2. In the wizard, deselect the “Show only extension points from the required plug-ins” option. In the Extension Point Filter field, type org.eclipse.ercp.eworkbench.applications and select it from the results. See figure 8.
Figure 8. Add the application extensions point
Add the application extensions point
  1. Click Finish to add it and click No if you receive a prompt asking if you want the handler plug-in to be added to the dependencies.
  2. Back in the Extensions tab of the plugin descriptor file, select and right-click org.eclipse.ercp.eworkbench.applications from the list, and then choose New - Application from the menu.
  3. Change the values of the following elements as shown in figure 9 and save the changes:

    • id: com.ibm.lotusphere.rcp
    • name: Geo Info App
Figure 9. Change properties for application
Change properties for application
  1. Expand org.eclipse.ercp.eworkbench.applications, right-click the Geo Info App node, and choose New - Views from the menu.
  2. Change the values of the views element to the following values as shown in figure 10 and save the changes.

    • normal: com.ibm.lotusphere.rcp.DeviceView
    • large: com.ibm.lotusphere.rcp.DesktopView
Figure 10. View extension properties
View extension properties
  1. Switch now to the plugin.xml tab, which shows you the source of the file. After you added the extension point in the previous steps, the source should look like the code shown in listing 7.
Listing 7. Plug-in descriptor file
<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.2"?>
<plugin>
	<extension
		point="org.eclipse.ui.views">
		<view
			category="org.eclipse.ercp.eworkbench.viewCategory"
			class="com.ibm.lotusphere.rcp.DesktopView"
			id="com.ibm.lotusphere.rcp.DesktopView"
			name="Desktop View"/>
		<view
			category="org.eclipse.ecrp.eworkbench.viewCategory"
			class="com.ibm.lotusphere.rcp.DeviceView"
			id="com.ibm.lotusphere.rcp.DeviceView"
			name="Device View"/>
	</extension>
	<extension
		point="org.eclipse.ercp.eworkbench.applications">
		<application
			id="com.ibm.lotusphere.rcp"
			name="Geo Info App">
			<views
				large="com.ibm.lotusphere.rcp.DesktopView"
				normal="com.ibm.lotusphere.rcp.DeviceView"/>
		</application>
	</extension>

</plugin>
  1. Save and close the editor.

Run the RCP application on Lotus Expeditor

Next, you create a launch configuration to run your RCP application on Lotus Expeditor.

  1. Choose Run - Run on the Rational Software Architect menu.
  2. Select Client Services on the left, right-click, and then choose New from the contextual menu to create a new launch configuration for your application.
  3. Enter Geo Info App on Desktop as the name of your launch configuration.
  4. Click Apply, and then click Run to launch Lotus Expeditor.
  5. When Lotus Expeditor starts for the first time, you must enter a password, which is used by the Lotus Expeditor KeyStore. Enter any password of your choice and remember to note it because you will have to enter it in future launches.
  6. Click Login.
  7. Select your RCP application by clicking the Launch button at the top left section of Lotus Expeditor, and then by selecting Geo Info App from the application list.
  8. Your RCP application starts, and it should look like figure 11.
Figure 11. Running the RCP application
Running the RCP application
  1. If you select a country from the drop-down list, you see the corresponding country flag showing below the name of the country.
  2. Exit Lotus Expeditor.

Configure the RCP project to support devices

Now, you modify the existing project to add support for devices.

Change the project preferences

By default, the preferences of the base platform are set to apply to a desktop client. The Lotus Expeditor toolkit facilitates application development for client devices by providing pre-built configurations applicable for a client device. All you have to do is set the appropriate values in preferences; then you are ready to run the same application on a device.

  1. Choose Window - Preferences from the Rational Software Architect menu.
  2. In the left column, select Client Services and then change the Default Target Selection to Default Device Target.
  3. In the left column, choose Java - Installed JREs, and then cselect jclDevice Win32 x86 in the pane on the right side.
  4. In the left column, select Plug-in Development - Target Platform. Look for the Pre-defined Target section in the right pane. Then, select Default Device Target from the drop-down list, and click the Load Target button to load the required plugins for a device target. See figure 12.
Figure 12. Loading device target
Loading device target
  1. Click OK to save and exit the project preferences.

    NOTE: You see a few errors in your project. We correct these errors in the next steps.

Modify plugin.xml

When the default device target is loaded, the plug-ins available at runtime for the application also change. Some of the plug-ins that were available before are no longer available for the Geo Info application. Therefore, modify plugin.xml to import the required packages.

  1. Open plugin.xml.
  2. In the Dependencies tab, under Imported Packages, click Add. Then, add these packages as shown in the figure 13:

    • org.eclipse.swt
    • org.eclipse.swt.events
    • org.eclipse.swt.graphics
    • org.eclipse.swt.layout
    • org.eclipse.swt.widgets
    • org.eclipse.ui.part
    • org.eclipse.ui.plugin
Figure 13. Adding imported packages
Adding imported packages
  1. Save and close plugin.xml.

    NOTE: All errors should now be resolved.

Run the RCP application on the jclDevice workbench

Now you run the RCP application using a jclDevice launch configuration from within Rational Software Architect to test the application using the device runtimes.

  1. Choose Run - Run from the Rational Software Architect menu.
  2. Choose Client Services, right-click, and then choose New from the contextual menu to create a new launch configuration for your application.
  3. Enter RCP Application on Device as the name of your launch configuration.
  4. Click Apply, and then click Run to launch the RCP application on the eWorkbench.
  5. You should see your RCP application listed on the eWorkbench as shown in figure 14. Click to run it and test it by selecting country names from the list as shown in figures 15 and 16.
Figure 14. eWorkbench view
eWorkbench view
Figure 15. Running the application
Running the application
Figure 16. Viewing country data
Viewing country data
  1. Exit Lotus Expeditor.

Deploy and run the RCP application on devices

In this activity, you package the RCP plug-in as a feature, and then deploy it with an update site, which you transfer to the device file system so that you can perform a local installation using the Application Manager.

Create a Feature project

Features are containers of plug-ins and logically represent functionality of a particular product. You use features to package your plug-ins and to deliver a product. In this section, you export the sample application as a feature.

  1. Choose File - New - Project to access the project wizards.
  2. Under Plug-in Development, select Feature Project.
  3. Click Next.
  4. In the Project name field, type Geo Info App.
  5. Click Finish to create the Feature project. At this time, the Feature project’s feature.xml file should have been opened in the editor area of the workbench.
  6. In the feature.xml file, select the Plug-ins tab.
  7. Click the Add button next to Plug-ins and Fragments and add the plug-in com.ibm.lotusphere.rcp to the list.
  8. Save and close feature.xml.

Create an Update Site project

Update Site projects allow you to create a repository of all the necessary features and plug-ins, and they are used as mechanisms to install features and/or plug-ins.

  1. Choose File - New - Project to access the project wizards.
  2. Under Plug-in Development, select Update Site Project.
  3. Click Next.
  4. In the Project name field, type Geo Info App UpdateSite.
  5. Click Finish to create the Update Site project. At this time, the site project’s site.xml should have been opened in the editor area of the workbench.
  6. Select the Site Map tab in the site.xml if it is not already selected.
  7. Click New Category.
  8. In the Category Properties section of the window, enter My Apps for both the category name and label shown in figure 17.
Figure 17. Adding categories
Adding categories
  1. Click Add Feature and enter Geo_Info_App as shown in figure 18.
Figure 18. Adding features to update site
Adding features to update site
  1. Make sure that the feature was added under the category. If not, drag and drop Geo_Info_App into the My Apps category.
  2. Click Build All.
  3. In the site.xml file, go to the site.xml tab and add the type attribute to the site node as shown in the code in listing 8.
Listing 8. Updating the XML file
 <?xml version="1.0" encoding="UTF-8"?>
 <site type="org.eclipse.ercp.update.http">
 <feature url="features/Geo_Info_App_1.0.0.jar" id="Geo_Info_App" version="1.0.0">
 <category name="My Apps"/>
 </feature>
 <category-def name="My Apps" label="My Apps"/>
 </site>
 </code>
  1. Save and close site.xml.

Export and install from the update site on devices

To prepare to install the sample application on a device, export the required features, plug-ins, and site-related files to a local directory. Before you pick a device, ensure that you are using one of the supported devices as detailed in the InfoCenter (see the Resources section of this article). Install the IBM Lotus Expeditor client on the device if it is not installed already.

  1. Right-click the My Update Site project and select Export.
  2. Under General, select File System.
  3. Click Next.
  4. Select or browse to a directory to export, and then click Finish.
  5. To install your RCP application on the device, make sure the device is connected using USB. Using File Explorer, navigate to Mobile Device and then to \My Documents\Personal.
  6. Copy the exported files - the site.xml file, the features and plugins directories - to the device’s \My Documents\Personal directory as shown in figure 19.
Figure 19. Update site files
Update site files
  1. On the device, open Lotus Expeditor.
  2. Inside Lotus Expeditor, run the Application Manager and select Install New Applications/Features.
  3. Click OK at the prompt, "You can create a new location by Command>Add Location."
  4. Select Command - Add Location and select Local site.
  5. Click Next.
  6. Select the Personal folder and click the site entry.
  7. Click Finish.
  8. Select the new local site and click Next.
  9. Expand the site and select Geo_Info_App_Feature.
  10. Click Next, accept the terms, and click OK to restart Lotus Expeditor.
  11. Wait while the Application Manager restarts, and then click OK to close it. After a few seconds, you should now see the Geo Info App application installed on the device's eWorkbench.
  12. Run the application and test its functionality as you have done previously.

You have now successfully run the application on a device client. Although we could have enhanced our application to include design patterns and other backend infrastructure such as MQe, Web services, and DB2e in our application, we chose not to do so to keep everything very simple. The focus of the sample is to give you a high-level overview of the steps required to create an application that can be run on a desktop as well as on a device client.


Conclusion

We have shown you how to develop a simple RCP sample using the Lotus Expeditor client toolkit and how to deploy it on a mobile device. Applying the same approach, you can easily port existing applications to mobile devices by creating new views and reusing existing business logic and data. Although this sample does not utilize the advanced features of Lotus Expeditor such as online/offline support, transaction support, messaging, composite applications, and database synchronization, you can easily start adding these features and services on top of the existing code.


Downloads

DescriptionNameSize
Code sampleRCP_Files.zip669KB
Code sampleGeoInfoAppDesktop.zip1.36MB
Code sampleGeoInfoAppUpdateSite.zip591KB

Resources

Learn

Get products and technologies

Discuss

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into IBM collaboration and social software on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Lotus
ArticleID=216497
ArticleTitle=Developing and deploying rich client applications on desktops and mobile devices using IBM Lotus Expeditor V6.1
publish-date=02062008