LSBG Vårseminar, maj 2011 Larvik, Norge

Transcription

1 LSBG Vårseminar, maj 2011 Larvik, Norge Plug yourself in and your applications will never be the same! (An introduction to plugin development for Lotus Notes, Domino and Sametime)

2 About me Developer: Notes / Domino / Sametime / Java / DB2 / WebSphere / web / plug-ins Design Partner for Domino NEXT and Lotus Connections 3.0 Active blogger: lekkimworld.com Speaker at Lotusphere Articles for THE VIEW mh@intravision.dk.com/lekkim

3 What I do! Well plugins of course... But plugins are a many-headed beast! It's not just stuff for the Notes sidebar It's about extending the UI in Notes, Sametime and Symphony It's about delivering a UI capable of doing stuff you cannot do in traditional Notes It's about developing custom components for the XPages Extensibility Library It's about DOTS (previously JAVADDIN) and OSGi on the Lotus Domino Server

4 Why I do it! Plugin development is often about integration You often build extensions to existing applications to add functionality Eclipse and therefore Expeditor, Notes, Symphony, and Sametime, are built to allow for extensibility Plugin development has several advantages Java Mature Well Adopted Multi-platform Libraries Eclipse Community Web Services Web Applications Database Integrations etc...

5 What's possible with plugins Torsdag, sal 1, 11:20-12:00 - Ta samarbeid og planlegging til neste nivå

6 RedWiki for plugin development Lotus Notes and Domino Application Development wiki / IBM Redbook Publications Table_of_Contents_Developing_Customized_Components_for_Lotus_Notes_S ametime_and_symphony...or use the bit.ly link >>

7 What I'm going to build (if time permits) Sidebar panel containing A list box Three buttons at the bottom One button reads from a web service One button reads contacts from names.nsf One button creates a new Reads recipient from list Create document Set subject Add data from web service call to body Create a feature for the plugin Create an update site with the feature Create a widget for the feature from the update site

8 Agenda About Eclipse and Lotus Expeditor Toolkit Installing Lotus Expeditor Toolkit Plugin Development Basics Building UI's with SWT and JFace Jobs, Jobs, Jobs Logging APIs Debugging Deployment Resources / Q&A

9 Eclipse architecture JFace provides components to make it easier to write a GUI e.g. wizards, preference pages, actions, dialogs Workbench is desktop UI and customizable Workbench JFace SWT provides uniform UI API across multiple OS that calls OS UI API for native look and feel Service Framework supports registration and lifecycle management of plug-ins Extension Point Plug-in Extension Point SWT Plug-in Extension Pt. Core Extension Point Framework Service Framework RCP allows you to build GUI apps on multiple OS Extension Point declares contract to extend plug-in functionality Extension code extends this functionality Extension Point Rich Client Platform A software component in Eclipse Plug-in

10 IBM Lotus Clients built on Eclipse Portal ecosystem of partners collaborative services open and extensible Browser Desktop Mobile Apps and Plug-ins (ISV + Customer) Symphony Sametime Notes Expeditor Security Multiplatform support Scalability Industry knowledge and experience Integrated applications

11 Eclipse workbench

12 Notes workbench s

13 Lotus Expeditor (XPD) Toolkit An integrated set of tools to develop, test, and deploy applications built on top of Expeditor Supports Expeditor, Sametime, Notes and Symphony FREE! No charge to use the Expeditor toolkit Supported on Windows and Linux operating systems Benefits Of Using The Toolkit Easily configure your development environment to develop for the platforms above Takes ~ 1 minute to configure your environment Set your target environment Point to the target locations on your machine Provides a new launcher to launch products built on top of Expeditor Create a new launch configuration to launch the application from Eclipse Provides numerous samples to get your started developing for Expeditor based products

14 Installing XPD Toolkit (1) Download the XPD Toolkit Unzip In Eclipse 3.4(.2) Help Software Updates...

15 Installing XPD Toolkit (2) Click New Local Site... Browse to unziped update site Select OK

16 Installing XPD Toolkit (3) Select The XPD Toolkit Click Install...

17 Installing XPD Toolkit (4) Agree to the license agreement Install all features Restart

18 Installing XPD Toolkit (5) Start IDE Select Test Environment Notes, Sametime, Symphony, XPD Specify Target Location Point to target runtime <install>/framework/rcp/eclipse Click OK Run Run Configuration Double Click Client Services Give The Configuration A Name Select Run

19 Installing XPD Toolkit Demo Start IDE Select Test Environment Symphony, Sametime, Notes, Expeditor Specify Target Location Point to target runtime <install>/framework/rcp/eclipse Click OK Run Run Configuration Double Click Client Services Give The Configuration A Name Select Run

20 What are plugins? Plugins are the building blocks of Eclipse based applications At their core a plugin is some code plus some declarations (extension points) By themselves plugins may not do anything, but when you start combining plugins you can build very powerful applications Examples: Eclipse, Notes, Sametime, Symphony Plugin Application

21 Anatomy of a plugin Java code (optional) Manifest.mf Basic properties of a plugin Specifies dependencies this plugin has Plugin.xml Extension points the plugin uses / defines Build.properties Manages the build configuration of the plugin Resources (optional) Jars the plugin may need Files used for translation Images etc...

22 Demo: Creating a plugin project File New Project Plugin Development Select Plug-in Project

23 Extension Points Extension points make plugins pluggable Plugins define extension points for other plugins to use Examples: sidebar, toolbar buttons, right click menus... Extension points allow the platform to be more performant Eclipse has a nice editor for adding and defining extension points How do I know what extension points are available? Eclipse.org and the Expeditor wiki are your friends Using Extension Point Plugin Extension Point Definition

24 Key Extension Points org.eclipse.ui.views Registers a view part with the platform View parts can be used inside perspectives or in the sidebar com.ibm.rcp.ui.shelfview An Expeditor extension point Used to add a view part to the sidebar org.eclipse.ui.actionsets Used to add top level toolbars and menus org.eclipse.ui.menus Used to add context menus org.eclipse.ui.preferencepages Used to add preference pages to the preferences

25 The arcane art of building UI's

26 UI's are built using code UI's are built using Java code adding widgets (controls) to containes (composites) custom drawn using Java code to listen for paint events In either case it isn't WYSIWYG :-(

27 Standard Widget Toolkit (SWT) Platform native look and feel Protection from OS Level Changes Very responsive Resulting UI looks like native platform applications

28 JFace UI toolkit built on top of SWT without hiding it Provides coarser grained components than SWT Dialogs Image / Font Registries Wizards Viewers

29 Meet WindowBuilder!

30 Demo: Create a sidebar plugin Add org.eclipse.ui.views extension point Create view part class Add com.ibm.rcp.ui.shelfview extension point Use WindowBuilder to create UI Try It Out!

31 All The APIs You Need Do not reinvent the wheel! Java and Eclipse contains a rich set of API's that you can use when developing plugins for Lotus clients Knowing the API's available to you is crucial We'll cover Jobs (threading) Logging Notes backend Notes frontend

32 Threading lightly A thread is an abstraction in computers to allow programs to perform multiple operations simultaneously Avoid tying up the program with background operations Two ways to call other code Synchronously == blocking Blocks current code until call is done and then returns to continue processing Like you're used to from LotusScript Asynchronously == non-blocking The calling code continues to run you now have two pieces of code running To tell the caller we're done we use callbacks or listeners Harder to grasp Used in AJAX you request data in the background and once the data has been fetched you are told

33 Jobs, jobs, jobs - lets vote for jobs! Eclipse Job Framework java.lang.thread is way too low-level and error prone Allows for easy background processing Very simple to use Allows scheduling of jobs ( run this code in 2 minutes ) Allows weaving of jobs Allows for listening to job status etc. Standard UI for manipulating jobs Two types of Job Job for background processing UIJob for user interface updates Both are abstract classes and normally used as anonymous inner classes

34 There can be only one Any Eclipse application only has ONE thread that may update the user interface It's surprise, surprise called the UI thread This means that Tying up the UI thread will render the entire client unresponsive Attempts to access the UI (i.e. set the text of a label) outside the UI thread will fail with an exception You need a way to do stuff in the UI thread To do stuff in the UI thread you use an UIJob from the Job API

35 Using Job in code public void fireontheempire(int initdelay, final final String jediname) { // create recurring job to poll web service new Job("Poll the Force!") { protected IStatus run(iprogressmonitor monitor) { // invoke endpoint using input String srvc = ; WSFacade facade = new WSFacade(srvc); String result = facade.fire(jediname); // do something with the result... // reschedule this job (in 5 mintues) this.schedule(5 * 60 * 1000); // return return Status.OK_STATUS; } } }.schedule(initialdelay * 60 * 1000);

36 Using UIJob in code final List lstjedis = new List(parent, SWT.NONE);... public void psssst(final String[] jedis) { // since we're called in a background process // use that UIJob we learned about to update the UI new UIJob("Load Jedis") { public IStatus runinuithread(iprogressmonitor monitor) { // update UI for (String jedi : jedis) { lstjedis.add(jedi); } // return status return Status.OK_STATUS; } }.schedule(); }

37 Avoid Spinning Wheel of Death public void createpartcontrol(composite parent) { final Label txt = new Label(parent, SWT.NONE); new UIJob("Indicate job starting") { public IStatus runinuithread(iprogressmonitor monitor) { txt.settext("turning star cruiser (" + new Date() + ")..."); // do long running task == BAD!! try { Thread.sleep(5000); } catch (Exception e) {} txt.settext("done turning star cruiser (" + new Date() + ")..."); // reschedule and return this.schedule(5000); return Status.OK_STATUS; } }.schedule(5000); }

38 Weaving Jobs Most operations usually include a UI and a background component so you need to weave jobs A typical operation from the user consists of 3 steps: 1) Usually you start of with a UI call (button click i.e. button selection) 2) You perform some background operation (e.g. load data from a web service or similar) 3) You need to call back into the UI and update or inform We call this to weave job We do it by nesting Job instances

39 Do it right! public void widgetselected(selectionevent event) { list.add("starting to run code (" + new Date() + ")...", 0); new Job("Long running job") { protected IStatus run(iprogressmonitor monitor) { downloadentiregooglesearchindex(); // call back into UI to tell user we're done new UIJob("Update UI") { public IStatus runinuithread(iprogressmonitor monitor) { list.add("done running code (" + new Date() + ")...", 0); return Status.OK_STATUS; } }.schedule(); return Status.OK_STATUS; } }.schedule(); }

40 Demo: Using jobs in your code Adding a button for background operation Add selection listener Load data from the web Once call is done update the UI

41 Logging System.out.println is NEVER the solution! Seems easy at first but 99% of the time it's easier to just use logging from the beginning Lotus Expeditor / Notes comes with many supported logging mechanisms The one to use is java.util.logging as it's built-in and easy to use and configure Logging is done through the Logger class and at a specified Level Level (SEVERE, WARNING, INFO, FINE, FINER, FINEST, CONFIG) Expensive logging may be guarded using isloggable(level) Loggers are hierarchically named and level is set hierarchically as well

42 Logging Example package com.example.demo1; public class MainViewPart extends ViewPart { private static final Logger logger = Logger.getLogger (MainViewPart.class.getPackage().getName()); public MainViewPart() { try { logger.info("main view part instantiated"); String senatecount = this.countsenators(); if (logger.isloggable(level.finest)) { logger.finest("found + senatecount + senators (" + this + ) ); } } catch (Throwable t) { logger.severe( There was a disturbance in the Force!, t); } } }

43 Logging getting at it Logging output goes to client log Help > Support > View Log/Trace Configured using OSGi console Edit <Notes data>/workspace/.config/ rcpinstall.properties and add <logger name>.level=<level> at the end com.lekkimworld.twitnotes2.level=finest

44 Demo: Adding logging to the code Add a logger to our view part Log the current sunrise and sunset Enable logging

45 Notes backend API You have access to the Notes Java API you know and love! Basic usage is almost the same as you know and love To get access to the classes you DO NOT import notes.jar as you normally do DO depend on the com.ibm.notes.java.api plugin To access Notes data you DO NOT use NotesThread.sinitThread DO use the Job API and the supplied NotesSessionJob

46 Notes backend API in code new NotesSessionJob("Access Notes data") { public IStatus runinnotesthread(session session, IProgressMonitor monitor) throws NotesException { // print username System.out.println(session.getDatabase(null, names.nsf ).gettitle()); // return return Status.OK_STATUS; } }.schedule();

47 Notes frontend API Modeled pretty much like the LotusScript UI API NotesUIWorkspace, NotesUIView, NotesUIDocument, Should run in the UI thread Bridges a MAJOR gap in the Notes product as it gives us access to the Notes UI from Java Been with us for a while Added in Notes 8.5 as beta Supported from Notes More functionality added in Notes To use it add a dependency on com.ibm.notes.java.ui Example project available from OpenNTF.org ( Java UI API Exerciser )

48 Notes frontend API (cont.) NotesUIWorkspace Entry point Access to run an agent with context (access to LotusScript!) NotesUIView Most functionality added in Notes Listen for selection events and view entries Works for Java and traditional views NotesUIDocument You can work in the document on the glass Access to backend document Edit / Field / Modify listeners Access to copy/paste, refresh, reload Data classes for easy access (i.e. NotesViewData)

49 Demo: Use the Notes APIs Use NotesSessionJob to access the user's name.nsf file Place the addresses of the user's contacts in the list box Use the composedocument API to compose an to selected contact with data

50 Final word on APIs Accounts Secure storage for credentials, Automatic authentication for HTTP requests Lotus Sametime Awareness / realtime collaboration Search Search other applications from the search center Domino Designer Extend Domino Designer with custom actions Composite Applications Create components for using Eclipse technology and listen for properties and expose actions XPages Extensibility Library Add custom widgets for XPages LiveText / Toolbox (LiveText / Widgets API's is targeted to be publicly supported from 8.5.3) Inject recognizers based on business rules

51 Final word on APIs I promise!! Like with Lotus Notes there a multitude of API's available to you for Selection, Jobs, Actions / menus, Drag'n'drop, Custom drawing, Charting Explore Eclipse.org and remember to search for Eclipse and not Lotus Notes as it will yield far more results

52 Demo: Debugging basics Launching Notes from Eclipse in debug mode Set breakpoints Inspecting variables The console, logging levels

53 Deploying your fantastic work Deployment is done by Feature... Plug-in Plug-in Feature Plug-in Update Site... Plug-in... 1 Packaging your plugin(s) in a feature 2 Creating an update site to hold the feature 3 Installing the feature into the clients either manually or using a widget descriptor

54 Demo: Wrapping it all up Create a feature project Create an update site Create an update site NSF Add our feature to the update site NSF Create a widget for our feature Add it to a widget catalog Watch a video at:

55 DOTS (used to be JAVADDIN)

56 XPages Extensibility Library A new project has been created which contains a simple sample for how to to develop a 'native' XPages control via the Java extensibility API. This control can be deployed globally as an OSGi bundle/plugin to Lotus Domino and Lotus Notes/Domino Designer and then used in all NSFs without having to put the code in all NSFs redundantely. The new control shows up in the palette in Designer as other out of the box controls.

57 Summary and resources RedWiki about plugin development >> pluginredwiki HIGHLY recommended article on the Job API >> Eclipse articles >> Eclipse WindowBuilder >> windowbuilder

58 Q&A But! How do I? Doesn't that mean? Give it to me! :-)