My Java Experiences

OSGi - Road Ahead

2013-10-20T19:07:00.000+05:30

OSGi has been introduced many times in the past few years and will still require some in the future ¹. With so many introductions, one might be inclined to think that this is a new technology. To the contrary, OSGi is a good 14 year old technology started in 1999!

So why does such an old technology still require an introduction? Is it because it is not yet popular and not reached mainstream yet? Even after 14 years! There are more than 3 implementations of the OSGi specification. Glassfish and Websphere uses it. JBoss supports it. Apache Geronimo provides it. Eclipse is built on it. Netbeans supports it. Spring dmServer and Oracle JDeveloper is built on it. As you can see, most of the middleware servers and the top IDEs are either built on OSGi or has support for it. So, popular it is! But mainstream? That is debatable.

The applications mentioned above are middleware or tooling products. You can use any of these products without knowing anything about OSGi. This is good as well as bad. Good because it helps adoption, as unlike other frameworks, OSGi does not come in the developers' way. Bad because developers tend not to follow the OSGi principles while developing applications. Besides, middleware and tooling product developers are far less compared to general java developers. There have been few attempts to make OSGi available for general purpose development like Spring dmServer (now Eclipse Virgo). But it did not gain much traction. So, why is OSGi not mainstream yet in spite of all the benefits that it provides? Here, I summarize some of my personal observations behind the reasons of OSGi's non-adopt-ability:

Observation One: Elitist

The OSGi group looks like an elitist club with minimal public engagement up until recently. Only big companies seem to be part of it. There is no open-source-community-like engagement with the general public or at least it appears so.

Solution

The name (OSGi Alliance) itself sounds very technical and non-mainstream. I agree that OSGi started in a niche area and now have expanded to general purpose usage. But since the context has changed, so should the engagement. I think, a name like `OSGi Foundation` will make it less intimidating (`OSGi` itself cannot be dropped because of brand value and historical reasons).

The group should allow individual technical contributors without corporate affiliations to be part of the top membership. A similar model like the current Java Community Process (JCP) or Spring community will make it look more open. I know many will disagree that the JCP is an open community. But it does allow individual membership and is becoming more open.

Observation Two: Too many jargon

The OSGi specification is full of jargon. Names like blueprint and compendium, for example, sounds complex although they have simpler names. The use of `Specification` instead of `API` to describe a standard makes it sound too technical like the CORBA specification. Yes, I know that OSGi IS a `Specification`.

Solution

Can't we have a specification without calling it a specification? I think `API` is a much simpler term to use just like how the JCP uses it. All JCP APIs are standard specifications. But for marketing purpose, API sounds more appealing to the general masses. Similarly, call it dependency injection container or CDI container instead of blueprint container to make it sound familiar with JavaEE CDI concepts.

Observation Three: FUD

Lots of FUD (Fear, Uncertainty, Doubt) has been generated regarding OSGi. Read this and this and this and this and that. Some of those opinions have been presented with the sole intention to garner page hits. The title do not match the contents. Some of these has been addressed while some may not. Some are genuine concerns. When a new developer reads such articles, they become very skeptical about adopting it. When people like Rod Johnson says it is complex, people(developer, architect, project manager, IT department) tend to believe it.

Solution

To counter these FUDs, more and more real life examples of successful projects should be published. Additionally, architecture, design patterns, anti-patterns, best practices, etc. should be published frequently. Some of these are available but they have become dated. Fresh information on latest technologies will create the buzz around OSGi. The following links addresses the strength of OSGi:

http://jaxenter.com/jax-magazine/JTJ-2011-04
LinkedIn's use of OSGi
http://javadepend.wordpress.com/2012/10/11/the-osgi-puzzle/
http://soupinadeli.com/pdfs/a-year-with-osgi.pdf
http://branchandbound.net/blog/java/2013/07/java-modularity-story/

Observation Four: No centralized implementation

The OSGi site does not provide an official reference implementation of all the specifications. Individual specifications/API are implemented by different project groups mostly from the Apache stable. Core implementation is provided by Eclipse Equinox project. Some of the enterprise APIs are provided by Apache Aries, Apache CXF and other projects. This means a developer has to pull together different parts from various sources to meet his needs. This can be overwhelming sometimes.

Solution

Similar to how JavaEE provides an official reference implementation and complete product (Glassfish), OSGi should provide a reference implementation together with every specification release. OSGi R5 has been released in 2012 but still there is no complete R5 implementation after one year. This implementation need not be a new project. One of the main two projects, Equinox or Felix, should be made the centralized implementation of all core and compendium specifications.

A concurrent implementation release with every new specification release will allow users to start 'playing' with the new features. This will create more buzz as people will start blogging, tweeting and pinning their experiences.

In fact, a core product similar to OpenJDK project, would be more appealing. The core can be maintained by all parties interested (Equinox, Felix, Knoplerfish, JBoss) while individually they can differentiate by additional components or integration with their products.

Observation Five: Community, community

The OSGi blog seems to be the personal blog of Peter Kriens. There are no other contributors to the blog. Don't misunderstand me. His posts are always very informative and insightful and a Body of Knowledge by itself. I always look forward to his posts. But, only one person speaking about OSGi in a community that boasts of hundreds of members does not correctly reflect the diversity of the community. On the other hand, the OSGi wiki is non existent. It is hardly being maintained.

Solution

Blogs from different community members should be published in the official blog area and not just as RSS feed. This will complement the efforts to counter the FUD mentioned earlier.

The wiki should also be maintained more regularly with up-to-date information. More tutorials, code snippets, design rationale, etc. should be provided.

General Observations

The OSGi site design is dated. A modern theme should be applied to make it more appealing.
Community engagement must be made a priority. Programs similar to Adopt a JSR should be adopted to encourage community participation.

1 This will become a past event after the scheduled date.^↩

OpenStack on Windows Azure?

2013-09-09T23:47:00.000+05:30

Although this is off-topic from my blog interest, just thought about sharing this.

I was searching for information on the OpenStack project and did a Google search. This is what came up:

See the ad on the right that has been highlighted. The title is 'Openstack'. But the link points to www.windowsazure.com. Is this some false and misleading marketing strategy from Redmond to gain clicks and hits? Or does Redmond offer Openstack on its platform? Hardly so.

I rest my case.

Java sees Daylight in the Open

2013-04-10T15:12:00.000+05:30

With Software Defined Networking (or SDN in short) gaining huge traction over the past few years, numerous start-ups, protocols, frameworks and other applications have started coming up every few weeks. With this also came numerous efforts to standardize around this concept, chief among them being the Open Networking Foundation. Last week saw the emergence of another standards group (rather self-proclaimed) consisting of industry leading networking companies to launch the OpenDaylight project. The OpenDaylight project is an open source effort similar to the OpenStack project to collaborate on SDN related technologies. An extract from the OpenDaylight describing its motivation:

" At this early stage of SDN adoption, the industry acknowledges the benefits of establishing an open, reference framework for programmability and control through an open source SDN solution. Such a framework maintains the flexibility and choice to allow organizations to deploy SDN as they please, yet still mitigates many of the risks of adopting early stage technologies and integrating with existing infrastructure investments.

With OpenDaylight, a community has come together to fill this need through the combination of open community developers and open source code and project governance that guarantees an open, community decision making process on business and technical issues. Establishing an open source project in this way is designed to help accelerate the development of technology available to users and enable widespread adoption of Software-Defined Networking. "

This is indeed a good development but as long as all groups collaborate with each other rather than compete against each other, which will lead to fragmentation and higher cost of implementation and deployment.

However, what is interesting about this project is the use of Java for one of their central component! Yes, for all the cries of Java being dead, we see a new far-reaching project adopt Java as one of their underlying technology. This is indeed good news for the Java platform as well as the greater Java community. This underlines the strength, robustness and applicability of the Java technology for myriad platforms. The architecture of the OpenDaylight project is reproduced below:

Java is used for the Controller platform described above. See this link for an architectural overview. Interestingly, as well, OSGi is also used by the Controller framework. OSGi is a dynamic modular framework for Java which has also been steadily gaining limelight in recent Java developments. OSGi enables the Service Abstraction Layer because of its modular and extensible nature.

There are indeed good times ahead for both the Java and OSGi community.

Happy daylighting!

Liferay Expando Services

2013-01-09T15:35:00.000+05:30

Liferay provides a mechanism to create tables, columns, rows and values dynamically. It provides these features through the Expando services. The mechanism is supported by using four database tables: ExpandoTable, ExpandoColumn, ExpandoRow and ExpandoValue.

Creating tables dynamically

The class com.liferay.portlet.expando.service.ExpandoTableLocalServiceUtil allows creation of dynamic tables.

To create a new table, call:

ExpandoTable table = ExpandoTableLocalServiceUtil.addTable(<companyId>, <className>, <tableName>);

Parameters:

<companyId> (Type: long) – The company id for the table. To get the company id, call

long companyId = CompanyLocalServiceUtil.getCompanies().get(0).getCompanyId();

<className> (Type: String) – The class name should be the fully qualified class name of the java class that you are trying to save to database.

<tableName> (Type: String) – The name of the dynamic table to create.

A new row is added to the ExpandoTable table.

Creating columns dynamically

The class com.liferay.portlet.expando.service.ExpandoColumnLocalServiceUtil allows creation of dynamic columns.

To create a new column, call:

ExpandoColumn column = ExpandoColumnLocalServiceUtil.addColumn(<tableId>, <columnName>, <type>);

Parameters:

<tableId> (Type: long) – The table id for which to create column.

<columnName> (Type: String) – The name of the column.

<type> (Type: int) – The data type of the column. Use the ExpandoColumnConstants to specify the data type. For example, ExpandoColumnConstants.STRING;

A new row is added to the ExpandoColumn table.

Creating rows dynamically

The class com.liferay.portlet.expando.service.ExpandoRowLocalServiceUtil allows creation of dynamic rows.

To create a new row, call:

ExpandoRow row = ExpandoRowLocalServiceUtil.addRow(<tableId>, <classPK>);

Parameters:

<tableId> (Type: long) – The table id for which to create row.

<classPK> (Type: long) – The classPK .

A new row is added to the ExpandoRow table.

Storing values in a dynamic table

The class com.liferay.portlet.expando.service.ExpandoValueLocalServiceUtil allows storing values for dynamic tables.

To store a value, call:

ExpandoValue
value = ExpandoValueLocalServiceUtil.addValue(<classNameId>,
<tableId>, <columnId>, <classPK>, <value>);

Parameters:

<classNameId> (Type: long) – The class name id.

<tableId> (Type: long) – The table id for which to store value.

<columnId> (Type: long) – The column id of the table for which to store value.

<classPK> (Type: long) – The classPK .

<value> (Type: String) – The value to be stored .

A new row is added to the ExpandoValue table. There are several variations of the addValue API to store different data types.

Removing dynamic entities

Delete Table:

ExpandoTableLocalServiceUtil.deleteTable(long <tableId>)

Delete Column:

ExpandoColumnLocalServiceUtil.deleteColumn(long <columnId>)

Delete Row:

ExpandoRowLocalServiceUtil.deleteRow(long <rowId>)

Delete Value:

ExpandoValueLocalServiceUtil.deleteValue(long<valueId>)

The above APIs for each entity is the simplest one. There are other variations depending on the parameters. The above APIs only removes the corresponding entity. It does not remove the related entities. For example, deleting table does not automatically delete the columns, rows and values.

Updating dynamic entities

Update Table:

ExpandoTableLocalServiceUtil.updateTable(long <tableId>, String <name>)

ExpandoTableLocalServiceUtil.updateExpandoTable(ExpandoTable <table>)

Update Column:

ExpandoColumnLocalServiceUtil.updateColumn(<...>)

ExpandoColumnLocalServiceUtil.updateExpandoColumn(<...>)

Update Row:

ExpandoRowLocalServiceUtil.updateExpandoRow(<...>)

Update Value:

ExpandoValueLocalServiceUtil.updateExpandoValue(<...>)

Searching for entities

Search Table:

ExpandoTableLocalServiceUtil.getTable(<...>)

ExpandoTableLocalServiceUtil.getExpandoTable(long <tableId>)

Search Column:

ExpandoColumnLocalServiceUtil.getColumn(<...>)

ExpandoColumnLocalServiceUtil.getExpandoColumn(long <columnId>)

Search Row:

ExpandoRowLocalServiceUtil.getRow(<...>)

ExpandoRowLocalServiceUtil.getExpandoRow(long <rowId>)

Search Value:

ExpandoValueLocalServiceUtil.getValue(<...>)

ExpandoValueLocalServiceUtil.getExpandoValue(long <valueId>)

ExpandoValueLocalServiceUtil.getData(<...>)

Dynamic queries

For dynamic queries, all the Local service util provide 2 APIs:

Expando[Table|Column|Row|Value]LocalServiceUtil.dynamicQuery(<...>)

Expando[Table|Column|Row|Value]LocalServiceUtil.dynamicQueryCount(DynamicQuery <dynamicQuery>)

Integrating Coin Slider with Liferay 6.1.1 with zero development

2012-08-26T00:07:00.000+05:30

In my previous blog, I demonstrated how to integrate the Coin Slider library in a Liferay portlet without having to develop any portlet. Coin Slider is a jQuery based image slider with many effects for image transition. That demonstration was based on Liferay 6.0.5. With Liferay 6.1.1 now available, I decided to try my own example and see whether the steps still hold true for the latest version of Liferay. And guess what, it does! That's the power of Liferay! Congratulations to the Liferay Team!

So here I demonstrate the same example with updated screenshots for the benefit of the community.

Note: This solution is based on Liferay 6.1.1

Download and extract the latest version of the Coin Slider library from http://workshop.rs/projects/coin-slider/

Liferay now has a single Library for storing both documents, images, video and any other media files. Create a folder slideshow in the Document and Media library of the community where you want to use the slider. Add the files coin-slider-min.js, coin-slider-styles.css, jquery-1.8.0.min.js to the slideshow folder. Create a new file javascript.js file in filesystem. Add the following code to this file:

$(document).ready(function() {
$("#coin-slider").coinslider({ hoverPause: false });
});

Upload the javascript.js file to the slideshow library. The slideshow folder should now look like this:

Next, upload few images that you want to display in the slider in the Document and Media Library.

There are 8 images in the library above.

Now create a new web content structure. Name it coin-slideshow. Add xml schema definition to the structure as shown below:

Click Save when done.

Create a new web content template and name it coin-slideshow-template. Select coin-slideshow as the structure for the new template. Click the Launch Editor button. In the dialog that appears, paste the following code:



<link href="$css.getData()" rel="stylesheet" type="text/css" />

<script type="text/javascript" src="$jquery.getData()"></script>

<script type="text/javascript" src="$coinjs.getData()"></script>

<script type="text/javascript" src="$slidestart.getData()"></script>



<div id="coin-slider">

#foreach ($item in $slide.getSiblings())

   #foreach ( $itemData in $item.getChildren() )

        #if ( "$itemData.getName()" == "href" )

          #set ( $href = $itemData.getData() )

        #elseif ( "$itemData.getName()" == "img_src" )

          #set ( $img_src = $itemData.getData() )

        #elseif ( "$itemData.getName()" == "description" )

          #set ( $description = $itemData.getData() )

        #end

    #end

    <a href="$href"><br />

        <img src="$img_src" />

        <span>$description</span>

    </a>

#end

</div>

Click Update button when done. Click Save again in the main dialog.

Now is the time to add the slider in our page. Add Web Content Display portlet to the page where you want the slider. Click the Add Web Content link in the portlet to create content for the portlet. In the new dialog box, give a name to the content, say Slideshow. Change the structure of the web content by clicking the Choose button under the Structure section on the right. Select the structure coin-slideshow that we created earlier. This will automatically choose the template that we associated with the structure. Instead of the HTML editor, a web form with fields are shown.

In the css field, choose the coin-slider-styles.css from the document library. Similarly, choose jquery-1.4.2.min.js for jquery field, coin-slider-min.js for coinjs field and javascript.js for coinstart field. For the first slide, name it slide1. Select a image from the Document and Media Library for the img_src field. Select target location when an image is clicked from the dropdown list for the href field. Type some text to be displayed for the image in the description field. Similarly, add more slides for each image that you want to be displayed.

Click Publish button to save the content and make it viewable.

OrientDB - Pure Java NoSQL Datastore

2011-06-14T11:04:00.000+05:30

I have been following the so-called 'NoSQL movement' (as if such a movement exists!). In my opinion, it is just another way of storing and retrieving data. And this new (rather different, I am sure the method is not new) way is only suitable for certain type of applications. Not all applications require NoSQL-type storage and retrieval regardless of those who claim it to be. SQL and NoSQL complement each other. They are not rivals.

Having said that, I was pretty much interested in the concepts. I love trying out new things. While I was planning the design and architecture of a new open source project that I intend to develop (It is not exactly new. I have already started it but now plan to move it to a new architecture - Greenscape), one of the choices I had to make was on the data storage. My application will be highly dynamic with ability of end users to add and remove columns to a database table frequently. Doing it in relational database will incur heavy performance and complexity. After much consideration, I decided that a non-relational database will be the best choice for my application. But this choice is not without its share of challenges:

I loose JPA/Hibernate support which means I may have to come up with an equivalent framework.
I loose portability. NoSQL is non-standard. There is no standard query language. There are no standard protocol. So, tomorrow, I cannot replace the database with a better performing one without rewriting my application.
Few documentation. What are the best practices, design patterns, etc?

In spite of the challenges, I went ahead with my choice. The compelling reason was the ability to create knowledge because of the void.

Now that the decision was made, I had to choose a NoSQL database. I analysed all the popular ones but none fitted my requirements. I had one criteria for selecting a database: I must be able to code in Java. Most available systems were non-Java based which would be a significant issue for a one man project. Even if they had Java interface, the installation, setup, etc. were a tedious process. Having a database developed purely in Java has many advantages:

Easy packaging with other applications
Easy to install and run
Can be embedded
Can run in same or different VM
Easy to debug
Easy to test

After much searching, I came across OrientDB. Voila! That was what I needed! Going through its features only reinforced by belief in it. It is a pure Java solution and very small in size (~~500KB!~~ 2MB since last release) . It can be embedded as well as deployed in networked mode. It is both schema-less and schema-based! This topped the feature list. It also supports SQL as a query language (Hmm, need to call NoSQL by some other name).

Some of the features taken from its homepage:

SQL
Super fast
Transactional
GraphDB
Web ready (HTTP, REST, JSON)
Everywhere (Pure Java)
Extremely light
Apache License (Here's the money)

End of architecture choice 1 for Greenscape.

Next decision on application framework pending.

Grow Up Java! Proposing Java Desktop Edition

2011-02-19T13:25:00.004+05:30

No, this is not another 'Java is Dead' rant. Java is very much alive and kicking. It is one of the best development and runtime platform available. By far the most stable platform of those. And that might just be its biggest bane. Ridiculous! How is stability a bane? You might ask. Well, you can see the slow progress in path breaking innovation, due to it. See the debate on closures and the progress on module system/OSGI.

The Java platform is growing only by a few APIs and small language changes/additions every year. There is no major big innovation happening. All the major changes that has been happening are outside it. Be it the Dependency Injection, Persistence API, Scripting API, Desktop API, Application Framework API, they were only added to the platform subsequently. But they are just APIs. What we need is something big. Something that is 10 years advanced than today.

What I feel is Java is advancing in a bottom-up fashion. Small and slow changes at a time. What we need is a top-down approach. Think futuristic, design it and then only implement it in a bottom-up approach.

Take the example of new Swing Application Framework (now dropped from the standard). I think this new framework is a poorly envisioned idea. Look at the poor state of JMF. No substantial progress can be made on the desktop without support for multimedia. Yes, JavaFX is coming soon (for 3+ years ?). It is a big step forward but is not a standard (yet. Will it be ever?).

We have the JavaSE and JavaEE is built on top of it. Why can't we do the same with the desktop? Why can't we have something like the Java Desktop Edition or JavaDE ? Put all the big stuffs here. In this way, we can keep the JavaSE simple. Language and VM changes goes into JavaSE. Common APIs applicable to both EE and 'DE' goes into SE. But desktop additions like application framework, multimedia, browsing capabilities, gadget bar?, JavaFX, etc. goes into 'DE'. Of course, JavaME also needs to be considered but since industry's mood is to bring SE to ME, they can be considered the same for the sake of this blog.

Some might argue that the desktop is becoming irrelevant with the popularity of web applications and powerful browsers (with HTML 5). But as any unbiased report will say, the irrelevance of desktop will not happen anytime soon. After all, the browser needs to run on a desktop!

Basically, Java Desktop Edition becomes the new Operating System. It should have transparent integration with the underlying OS. Have functionalities in the form of services and modules on the lines of OSGI. So everything is a service: print service, document service, file service, graphic service, database service, < add your favorite services here >. So advanced capabilities can be exposed as a service to any module or applications (collection of modules) in the system. Imagine having Eclipse plugins as services exposed to all applications.

Think of the innovative possibilities of a Java Desktop (heard it before?):
- Java Browser with built-in support for applets, JavaFX - we can have applet plugins
- Browser can be embedded in any application
- GIMP like editor - JIMP?
- Standard installer for all applications - No OS specific versions of Eclipse or Netbeans (Java WAS supposed to be Write Once, Run Everywhere)

- Finally, a Java media player

- Desktop gadget bar

- Java Office
- < your favorite application here >

It is time for Java to grow up and act its age.

Liferay (s)mashup - Google Maps

2011-01-27T16:24:00.001+05:30

Part One - Liferay (s)mashup - The Beginning

In the previous blog, we saw how to fire events asynchronously on the client side. In this blog, we will see the integration of Google Maps in a portlet.

Showing Google Maps in a portlet is a breeze. For this, create a portlet called 'Visual View'. This portlet displays the Google Map for visual interaction. It receives the source and destination from the Plan Your Travel portlet and shows the road route in the map.

Using Google Maps API

Google Maps API is a collection of web services providing geographic data for creating maps applications. These web services use HTTP requests to specific URLs, passing URL parameters as arguments to the services. Generally, these services return data in the HTTP request as either JSON or XML for parsing and/or processing by an application. Let's get straight to the code.

Code Listing

<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet"%>
<portlet:defineObjects />
<style type="text/css">
#map_canvas {
    height: 500px;
    width: 400px
}
</style>

<script type="text/javascript">
    var <portlet:namespace />map;
    var <portlet:namespace />geocoder;
    var <portlet:namespace />directionDisplay;
    var <portlet:namespace />directionsService;
    var <portlet:namespace />rendererOptions = {
        draggable : true //make the map points draggable
    };
    var <portlet:namespace />initialLocation;
    var <portlet:namespace />infowindow;

    function <portlet:namespace />initialize() {
        var myLatlng = new google.maps.LatLng(-34.397, 150.644);
        var myOptions = {
            zoom : 8,
            center : myLatlng,
            mapTypeId : google.maps.MapTypeId.ROADMAP
        };

        <portlet:namespace />map = new google.maps.Map(document.getElementById("map_canvas"), myOptions);
        <portlet:namespace />geocoder = new google.maps.Geocoder();
        <portlet:namespace />directionsService = new google.maps.DirectionsService();
        <portlet:namespace />directionsDisplay = new google.maps.DirectionsRenderer(
                                                    <portlet:namespace />rendererOptions);
        <portlet:namespace />directionsDisplay.setMap(<portlet:namespace />map);
        <portlet:namespace />infowindow = new google.maps.InfoWindow();

        //geo location
        // Try W3C Geolocation method (Preferred)
        if (navigator.geolocation) {
            browserSupportFlag = true;
            navigator.geolocation.getCurrentPosition(function(position) {
                <portlet:namespace />initialLocation = new google.maps.LatLng(
                        position.coords.latitude, position.coords.longitude);
                contentString = "Location found using W3C standard";
                <portlet:namespace />map
                        .setCenter(<portlet:namespace />initialLocation);
                var marker = new google.maps.Marker({
                    map : <portlet:namespace />map,
                    position : <portlet:namespace />initialLocation
                });
            }, function() {
                <portlet:namespace />handleNoGeolocation(browserSupportFlag);
            });
        } else if (google.gears) {
            // Try Google Gears Geolocation
            browserSupportFlag = true;

            var geo = google.gears.factory.create('beta.geolocation');
            geo.getCurrentPosition(function(position) {
                <portlet:namespace />initialLocation = new google.maps.LatLng(
                        position.latitude, position.longitude);
                contentString = "Location found using Google Gears";
                <portlet:namespace />map.setCenter(<portlet:namespace />initialLocation);
                <portlet:namespace />infowindow.setContent(contentString);
                <portlet:namespace />infowindow.setPosition(<portlet:namespace />initialLocation);
                <portlet:namespace />infowindow.open(<portlet:namespace />map);
            }, function() {
                <portlet:namespace />handleNoGeolocation(browserSupportFlag);
            });
        } else {
            // Browser doesn't support Geolocation
            browserSupportFlag = false;
            <portlet:namespace />handleNoGeolocation(browserSupportFlag);
        }

        //add listener for directions change
        google.maps.event.addListener(
            <portlet:namespace />directionsDisplay,
            'directions_changed',
            function() {
                var leg = <portlet:namespace />directionsDisplay.directions.routes[0].legs[0];
                Liferay.fire('directionsChanged', {
                        origin : leg.start_address,
                        destination : leg.end_address
                });
            });
    }

    function <portlet:namespace />handleNoGeolocation(errorFlag) {
        if (errorFlag == true) {
            <portlet:namespace />initialLocation = newyork;
            contentString = "Error: The Geolocation service failed.";
        } else {
            <portlet:namespace />initialLocation = siberia;
            contentString = "Error: Your browser doesn't support geolocation. Are you in Siberia?";
        }
        <portlet:namespace />map.setCenter(<portlet:namespace />initialLocation);
        <portlet:namespace />infowindow.setContent(contentString);
        <portlet:namespace />infowindow.setPosition(<portlet:namespace />initialLocation);
        <portlet:namespace />infowindow.open(<portlet:namespace />map);
    }
 
    function <portlet:namespace />loadScript() {
        var script = document.createElement("script");
        script.type = "text/javascript";
        script.src = "http://maps.google.com/maps/api/js?sensor=false&callback=<portlet:namespace />initialize";
        document.body.appendChild(script);
    }

    window.onload = <portlet:namespace />loadScript;

    function <portlet:namespace />showDirection(source, destination) {
        var request = {
            origin : source,
            destination : destination,
            travelMode : google.maps.DirectionsTravelMode.DRIVING
        };
        <portlet:namespace />directionsService.route(request, function(
                response, status) {
            if (status == google.maps.DirectionsStatus.OK) {
                <portlet:namespace />directionsDisplay.setDirections(response);
            }
        });
    }

    Liferay.on('planTravel', function(event) {
        <portlet:namespace />showDirection(event.origin, event.destination);
    });
</script>

<div id="map_canvas"></div>

The Google Maps API requires a single div element with an id in the html page to be rendered. Here, we have given the id as 'map_canvas'. The loadScript() method dynamically loads the maps script file. This speeds up the page display. The initialize() method loads the map view with pre-configured values. Also, latest versions of most browsers support geolocation. Geolocation allows tracking user's current location. This information is used to load the map with user's current location.

Note the listener for the directions changed event from the map in the initialize function. When the directions changed event occurs, we republish the event using Liferay's event manager to notify other portlets. Other portlets receives this event to update their display. We saw this in the search form in the first part of this blog series.

To use the two portlets that we have developed so far, type in the names of cities in the origin and destination and hit the Search button. The road rout between the two cities will be shown in the Google map. Now, try changing the cities by dragging the marker in the map. The cities' names are updated in the Plan Your Travel portlet. We will see interesting applications of this event model in the next few portlets.

For more details working on the Google Maps API, see this and this.

Liferay (s)mashup - The Beginning

2010-12-29T11:33:00.007+05:30

Part Two - Liferay (s)mashup - Google Maps

There are many popular web services available online. From the rich set of APIs from Google and Yahoo to social sites likeTwitter and Facebook, almost all service providers make available their services in the form of an open API. These rich APIs has given rise to new kind of applications called mashups. They are basically an integration of various web APIs from different providers put together to form new kind of applications.

In this and the next series of blogs, I will show how to integrate with some of these APIs.

To make meaningful use of these APIs, let me propose a sample application where these services can be used. Let us develop a travel planning site that helps user to plan their travel dates and location. Travelling is just not about location and date. There are other factors like weather conditions, transport availabiity, political turmoil, other events clashing with date. Questions such as 'Are any of my friends travelling on that date or to that location?', 'Do I know anyone from that location I am going to?' frequently comes up. Our site will try to resolve these questions so that a probable date and location can be zeroed on.

Features of the Application
- Display input form for receiving the source, destination, journey date and duration.
- Show the road route of the origin and destination in Google map
- Show weather information of origin and destination
- Show the event happening in origin and destination on and around the journey date
- Show news related to origin and destination
- Moving the marker on the Google map must also update all other information in real time like weather, events, news and the input form.

- More services as we go along

For the first requirement, create a new portlet. In the view.jsp file, design a basic form for the user to fill in: Origin, Destination, Journey Date and Duration.

Code Listing

<form action="<liferay-portlet:actionURL portletConfiguration="true" />" method="post" name="<portlet:namespace />fm">
    <aui:input name="origin" label="Origin" />
    <aui:input name="destination" label="Destination" />
    <aui:input name="journeyDate" label="Journey Date" />
    <aui:input name="duration" label="Duration" suffix="(in days)" />
    <input type="button" value="Search" onclick="<portlet:namespace />postPlanDetails()" />
</form>

The journeyDate is shown as a calendar when user clicks on the input field. Define it in javascript as:

AUI().ready('aui-calendar', function(A) {
    var calendar1 = new A.Calendar({
        trigger : '#<portlet:namespace />journeyDate',
        dateFormat : '%d/%m/%Y',
        setValue : true,
        selectMultipleDates : true,
        on : {
            select : function(event) {
                var normal = event.date.normal;
                var detailed = event.date.detailed;
                var formatted = event.date.formatted;
            }
        }
}).render();

A.on('mousedown', function() {
    A.CalendarManager.hideAll();
}, document);

});

The postPlanDetails() javascript function is defined as follows:

function <portlet:namespace />postPlanDetails() {
    var origin = document.<portlet:namespace />fm.<portlet:namespace />origin.value;
    var dest = document.<portlet:namespace />fm.<portlet:namespace />destination.value;
    var journeyDate = document.<portlet:namespace />fm.<portlet:namespace />journeyDate.value;
    var duration = document.<portlet:namespace />fm.<portlet:namespace />duration.value;

    Liferay.fire('planTravel', {
        origin : origin,
        destination : dest,
        journeyDate : journeyDate,
        duration : duration
    });

}

The code in bold above functions publishes the 4 parameters as an event using Liferay client side Inter Portlet Communication. For more details on IPC, see Portlet to Portlet Communication.

This portlet also receives the 'directionsChanged' event from the Google Maps portlet. We will discuss this in the next blog.

Liferay.on('directionsChanged',
    function(event) {
        document.<portlet:namespace />fm.<portlet:namespace />origin.value = event.origin;
        document.<portlet:namespace />fm.<portlet:namespace />destination.value = event.destination;
});

Speeding up page loading

2010-12-24T17:28:00.008+05:30

Developing fast loading pages is a complex task. Some have even defined it as an art. Large companies have dedicated professionals or hire external consultants to audit their applications for speed and responsiveness.

Here I provide some simple tips to speed up page loading in Liferay. Liferay also provides some in built features for fast page loading. Whenever available, Liferay support will be shown for each tip.

Tip 1: Sharing script and css files across portlets

For each script and css file included in a page, the browser makes separate requests to fetch them. This takes time. If the same file is included many times, the browser only makes requests the first time and for subsequent access, it picks from the cache. Therefore, common javascript code should be placed in a single file and this file should be included in all portlets that need it.

To share scripts across portlets, use the <header-portlet-javascript> tag or <footer-portlet-javascript> tag in the liferay-portlet.xml file. Similarly, use <header-portlet-css> tag or the <footer-portlet-css> tag in the liferay-portlet.xml file.

Tip 2: Lazy loading of scripts

Sometimes, scripts are not immediately needed after page load but only after user takes some action. To prevent such scripts being loaded on page load, we can load in the background after the page has loaded. There are two ways for lazy loading. One, the script is added to the <head> tag and the other is to add it to the <body> tag.

Adding to head tag:

function loadScript() {

    var script = document.createElement("script");

    script.type = "text/javascript";

    script.src = "";

    var head = document.getElementsByTagName("head")[0];

    head.appendChild(script);

}



window.onload = loadScript;

The function loadScript() above creates a dynamic script tag and adds it to the first head tag available. It registers this function to be called on load of the page.

Adding to body tag:

 function loadScript() {

    var script = document.createElement("script");

    script.type = "text/javascript";

    script.src = "";

    document.body.appendChild(script);

}



window.onload = loadScript;

The function loadScript() above creates a dynamic script tag and adds it to the body. It registers this function to be called on load of the page.

Tip 3: Minimize script, stylesheet and html output

Whitespace and comments in script file or html pages takes up bandwith and so slows down page load. While comments and whitespaces are necessary for development, in production they should be removed. It would be nice to not to change the source code for production while still be able to remove the comments and whitespaces. A simple technique for this would be to use server side comments in jsp files and not to use html or javascript comments. Whitespaces cannot be handled this way.
Liferay provides a minifier process that strips down both whitespaces and comments from script and css files. The minifier also shortens function and variable names to make the script even smaller. To enable the minifier, set the option in the portlet-ext.properties file.

com.liferay.portal.servlet.filters.minifier.MinifierFilter=true

Another option Liferay provides is to load packed (compressed) versions of Liferay scripts and css. Enable it using

javascript.fast.load=true

By default, both the options are true. Make sure, they are not false on production systems.

Tip 4: Specify image and table width and height

If the browser can immediately determine the height and/or width of images and tables, it will be able to display a web page without having to reflow the content. This not only speeds the display of the page but prevents annoying changes in a page's layout when the page completes loading. For this reason, height and width should be specified for images and tables, whenever possible.

Integrating Coin Slider with Liferay with zero development

2010-11-15T15:44:00.000+05:30

In this blog, I will show you how to integrate the Coin Slider library in a Liferay portlet without having to develop any portlet. Coin Slider is a jQuery based image slider with many effects for image transition.

Note: This solution is based on Liferay 6.0.5

Download and extract the latest version of the Coin Slider library from http://workshop.rs/projects/coin-slider/

Create a folder slideshow in the document library of the community where you want to use the slider. Add the files coin-slider-min.js, coin-slider-styles.css, jquery-1.4.2.min.js to the slideshow folder. Create a new file javascript.js file in filesystem. Add the following code to this file:

$(document).ready(function() {
$("#coin-slider").coinslider({ hoverPause: false });
});

Upload the javascript.js file to the slideshow document library. The slideshow folder should now look like this:

Next upload few images that you want to display in the slider in the Image Gallery.

There are 3 images in the image gallery above.

Now create a new web content structure. Name it coin-slideshow. Add xml schema definition to the structure as shown below:



<link href="$css.getData()" rel="stylesheet" type="text/css" />

<script type="text/javascript" src="$jquery.getData()"></script>

<script type="text/javascript" src="$coinjs.getData()"></script>

<script type="text/javascript" src="$slidestart.getData()"></script>



<div id="coin-slider">

#foreach ($item in $slide.getSiblings())

   #foreach ( $itemData in $item.getChildren() )

        #if ( "$itemData.getName()" == "href" )

          #set ( $href = $itemData.getData() )

        #elseif ( "$itemData.getName()" == "img_src" )

          #set ( $img_src = $itemData.getData() )

        #elseif ( "$itemData.getName()" == "description" )

          #set ( $description = $itemData.getData() )

        #end

    #end

    <a href="$href"><br />

        <img src="$img_src" />

        <span>$description</span>

    </a>

#end

</div>

Click Update button when done. Click Save again in the main dialog.

Now is the time to add the slider in our page. Add Web Content Display portlet to the page where you want the slider. Click the Add Web Content link in the portlet to create content for the portlet. In the new dialog box, give a name to the content, say Slideshow. Change the structure of the web content by clicking the Choose button under the Structure section on the right. Select the structure coin-slideshow that we created earlier. This will automatically choose the template that we associated with the structure. Instead of the HTML editor, a web form with fields are shown.

In the css field, choose the coin-slider-styles.css from the document library. Similarly, choose jquery-1.4.2.min.js for jquery field, coin-slider-min.js for coinjs field and javascript.js for coinstart field. For the first slide, name it slide1. Select a image from the Image Gallery for the img_src field. Select target location when an image is clicked from the dropdown list for the href field. Type some text to be displayed for the image in the description field. Similarly, add more slides for each image that you want to be displayed.

Click Publish button to save the content and make it viewable.

Swinglets 0.1 Beta Released

2008-06-12T11:24:00.000+05:30

I have just released the first beta version of the Swinglets project on java.net.

This project is a collection of Java Swing components developed by me. In this release, only two components JClock and JRuler is provided. I have few other components in development which will be released soon. This is not a stable release, so expect lots of bug and an unstable API. By sharing this project with the community, I intend to build and grow this library.

Users are requested to use this library and send your feedback. Even better, join this project and submit your improvements.

Please note that this library depends on the jscience library from jscience.org. This library is not included with this project. You need to separately place it in the classpath.

Integrating JavaDB with Netbeans modules - Series 3

2008-04-17T00:45:00.000+05:30

In this last part of the series, I will show how to save and retrieve data from our embedded database.

Create a new class called DBConect under the package org.embedded.db. Replace with the following code:

package org.embedded.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import org.openide.util.Exceptions;

public class DBConect {

    Connection con = null;

    public DBConect() {
        Properties prop = System.getProperties();
        prop.put("derby.system.home",
             System.getProperty("user.home") + "/" + ".mesh");
        try {
            //start the database and get a connection
            con = DriverManager.
                    getConnection("jdbc:derby:mesh_db", prop);
        } catch (SQLException e) {
            Exceptions.printStackTrace(e);
        }
    }

    public ResultSet executeQuery(String sql) throws SQLException {
        Statement statement = con.createStatement();
        return statement.executeQuery(sql);
    }

    public int executeUpdate(String sql) throws SQLException {
        Statement statement = con.createStatement();
        return statement.executeUpdate(sql);
    }
}

Now you can use this class to query the database or save data to the database using the two functions provided. This is a simple class. You can extend/modify it to do more complicated tasks.

Integrating JavaDB with Netbeans modules - Series 2

2008-04-11T23:25:00.000+05:30

In my last post, we created MyDbModule project. In this part, I will tell you how to start the embedded database when our module gets loaded.

Expand the Source Packages folder of the embedded-db project. Right-click on org.embedded.db package and select New > Java Class.Name the class as Startup. Then click on Finish.
This will be our startup class when the module is loaded. To make that happen we need to do two things. First, extend it with the NetBeans API class ModuleInstall. ModuleInstall exposes two methods for child classes: restored() and closed(). restored() is called when the module is loaded for the first time. and closed() is called when the module is unloaded. To use this API, add two module dependencies to the module. Right click on embedded-db project and select Properties. Select Libraries. On the right hand side, click Add Dependency... Select Module System API and Utilities API and then clcik Ok. The two APIs will be added to the project. Then click OK again on the Project Properties Dialog box. Second, open the Module manifest file (manifest.mf) from the Important Files folder of the module. Add the following line to it:

OpenIDE-Module-Install: org/embedded/db/Startup.class

This will register our class as the startup class when the module is loaded.

Now replace the Startup code with the following code:


package org.embedded.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
import org.openide.modules.ModuleInstall;
import org.openide.util.Exceptions;

public class Startup extends ModuleInstall {

    @Override
    public void restored() {
        super.restored();
        Properties prop = System.getProperties();
        prop.put("derby.system.home",
               System.getProperty("user.home") + "/" + ".mydb");
        Connection con = null;
        try {
            //start the database and get a connection
            con = DriverManager.
                        getConnection("jdbc:derby:my_db", prop);
        } catch (SQLException ex) {
            if (ex.getErrorCode() == 40000) {
                //database does not exist. create it now
                try {
                    con = DriverManager.
                          getConnection("jdbc:derby:my_db;create=true", prop);
                    //create the schema
                } catch (SQLException ex1) {
                }
            }
        } finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (SQLException ex) {
            }
        }
    }

    @Override
    public void close() {
        try {
            super.close();
            DriverManager.getConnection("jdbc:derby:;shutdown=true");
        } catch (SQLException ex) {
            if (!ex.getSQLState().equals("XJ015")) {
                Exceptions.printStackTrace(ex);
            }
        }
    }
}

In line 13, we call the base class restored() function to perform the default operation. Then we customize according to our requirements. In line 15, we set the JavaDB home directory where the database will be stored, which is the user's home directory under '.mydb' directory. In line 19, we try to connect to our embedded database with the name 'my_db'. First time, as the database is non-existent, it will throw an exception which will be caught by our handler. In line 24, we create the database by using the special connection string:

"jdbc:derby:my_db;create=true"

In line 25, we can create our database tables as required.

To shutdown the database when our application is closed, we override the closed() method. Shutting down the JavaDB engine is the same as getting connection except we pass the 'shutdown=true' parameter with the connection string as shown in line 43. Note the ':;' characters after 'jdbc:derby'. While shutting down, JavaDB throws an SQLException with SQL state code 'XJ015'. We need to ignore this exception which is done in line 45.

That's it. We have created a module which loads and/or creates our database on startup and shuts it down when the application is closed.

In the next and final blog, I will show how to connect to the database and save/retrieve data.

Integrating JavaDB with Netbeans modules - Series 1

2008-04-09T14:39:00.000+05:30

Here, I outline the series of steps to integrate JavaDB a.k.a Apache Derby with your Netbeans module. JavaDB acts as the embedded database for our Netbeans module. The network server features of JavaDB will not be utilized. I will also show how to configure the database so that it is stored in a custom location rather than the default.

Note: In trying out this guide, it is assumed that you are familiar with the Netbeans Platform and related concepts such as module, suite, etc. This guide is based on the latest Netbeans 6.1 Beta platform.

Create a module suite with the name 'MyDbModule'. You can give any name you want. If you want to add JavaDB to an existing module suite project, skip this step.
Right click on the project and select Properties. Select Libraries. In the Platform Modules section, uncheck all modules except platform8. We don't want other modules for now and if necessary, they can be added later.Click Ok when done.
Add a new module to this suite. (If you already have a module, skip this step)

Expand the suite tree node.
Right click on Modules node and select Add New... You will see the following dialog:
Type the name of the module as 'embedded-db'. Choose a location if required. Click Next. You will now see the following dialog:
Type Code Name Base as 'org.embedded.db'. Keep the rest as default. You may change the module display name.
Click Finish.
Your new module is added to the suite 'MyDbModule'.

Now add a dependency for JavaDB to this new/existing module. JavaDB is installed with Java SE 6. If you do not already have JavaDB, please install it first.

Expand 'embedded-db' node.
Right-click on Libraries and select 'Add New Library...'
Browse for the JavaDB jar files. For a default installation in Linux, you will find it in /opt/sun/javadb/lib. For a default Windows installation, it will be in C:/Program Files/Sun/JavaDB/lib. Select derby.jar and then click Next.
Give the project name as 'JavaDBLib'. Then click next.
Set code name base as 'org.embedded.javadb'. Leave the rest as it is. Then click Finish. The library is added to the suite as well as a dependent library to 'embedded-db' project.

So far, we have created a new module suite, added a module and a JavaDB library wrapper to it. In the next part, we will dive into coding and see how to start up our database in our own location . Also, we will connect to the database using Java Persistence API and do some simple queries.

First Look

2007-10-07T14:34:00.000+05:30

I have been working on various Java technologies for quite some time. I have always wanted to share my experiences but never got the time to do it. This is my first step in that direction.
This post is just to intimidate users about what will be coming next. I have experiences in Core Java, JavaEE, JavaME, web applications.

I hope that others may benefit from my experiences or share their experiences with me.

Thanks & Good Luck!!