J2ME Group

Google Analytics ME v2.0: Unique visitors

2012-01-03T09:36:00.000-03:00

Hi, all

Today, I would like to announce that Google Analytics ME v2.0 has been released. This new version comes with some good news and important changes. See them below:

- Identification of unique visitors.
- Better visitor's features identification.
- Small code refactoring.
- Android support deprecated.

Identification of unique visitors

Now GAN ME identifies properly who is a new visitor or not. This way, your visitors report is 100% accurate about the number of new and old visitors.

Better visitor's features identification

More visitor's features are being collected by GAN ME. For instance, now the app's name, version, screen size and number of colors are being collected.

Small code refactoring

To implement some of the new features and fix some of the bugs, some code changes were required, which may cause some compilation errors for your app. But it is not a big deal from developer's view. Actually, most developers will just have to fix the call to Tracker.getInstance(), which now requires to pass the MIDlet instance as well as the GAN app Id.

Android support deprecated

From this version on, we decided to deprecate the Android support. It turns out that there is already an official GAN API for Android, built by Google. So, we strongly recommend you to use that one in your Android app. It is very good!

I hope everybody enjoy this new version. Let me know your feedback.

To download the API, click here! By the way, inside the package there is a sample app for reference.

See you in the next post...

Multiple HTTP Headers: No cookie for you

2011-12-06T09:31:00.000-03:00

Hi, all

As you may know, HTTP Cookies are mostly used to track sessions between a client and a server. The flow is pretty simple: you access a server and it returns a piece of information (a cookie), which the client stores, in order to send back in every subsequent request. Based on this cookie, the server identifies the client.

Unfortunately, this session management must be handled by the developer, since HttpConnection does not do that automatically. This is achieved in a very simple way and a few lines of code. If do not know how to do it, please learn now here.

According to the example at Nokia's page, session management using a single cookie is very easy. How about two? It should be easy as well. Instead of only one, now you have to store two and send them back.

In a project that I am currently working on, there are two cookies to manage the session. As I said above, it is very easy, right? It should be. I am porting a code from Nokia S60 5th Edition series to S40 6th Edition. This session management works like a charm, but it fails on S40. Any guess? No? Read the post's title again. The answer is:

Series 40 platform devices up to Series 40 6th Edition and Series 40 5th Edition, Feature Pack 1 Lite, and S60 devices prior to S60 3rd Edition, Feature Pack 1 does not support multiple HTTP header. It means that two cookie cannot be handled, because only one is available. Nice, hah?

Long story short, we had to implement a workaround in our server for S40 version, where only one cookie is used for session management. As a consequence of it, this version accesses a no scalable server, since the second cookie was used for load balancer.

W.O.R.A does not work so well on mobile devices.

See you in the next post...

Twitter API ME 1.8: Now with OAuth support

2011-10-06T23:02:00.000-03:00

Hi, all

It's been a long time since my last post, but besides being a little bit busy, I also took a vacation, enjoying a trip to US, to visit some old friends. Great trip, by the way. But now, let's get back to work!

One thing that kept me busy during this time was the implementation of Twitter API ME 1.8. This new version is very special, because it comes with full support to OAuth. Since Twitter changed its Application Permission Model, requiring apps to use OAuth to have access to user's direct messages, Twitter API ME developers were not longer able to access DMs from their apps. Before v1.8, only xAuth was supported.

Other great thing about OAuth is that developers will no longer need to request xAuth permission to Twitter for their apps keys, in order to start working with the API. Since OAuth flow is more secure, Twitter trusts promptly any registered app, because there is no way for apps to get access to user's password. So, no more you have to wait days or until your app is done, so Twitter decides to grant you permission.

It is also important to point out, OAuth is available for all platforms supported: Java ME, Android and RIM.

Besides OAuth, Twitter API ME 1.8 comes with other news:

- Possibility to configure additional connection parameters for RIM platform.
- Improved RIM connection string solving the issue of when the devices is subscribed to BIS.
- Geo-located Trend search based on Yahoo! Where On Earth ID.
- Bug fixes and replacement of some deprecated Twitter API's resources.

I am really glad to have one more version of this successful project released. In addition, I would also like to thank everybody that contributed with the project, reporting bugs and requesting new features through our Express Support.

I strongly recommend you to migrate to v1.8 right away. So, download it now from here. I also prepared some sample apps to help developers to understand how to integrate OAuth into their apps. Just click here and have fun.

See you in the next post...

Facebook API ME for Android

2011-06-20T08:55:00.000-03:00

Hi, all

Continuing the announcements on Facebook API ME, yesterday, I released Facebook API ME v1.0 for Android. This version uses WebView component from Android API to display the authentication page. As I explained in this tutorial, to use the API for other platforms, you just need to work with the respective wrapper class for the target platform. Regarding Android, you will have to use WebViewAuthDialogWrapper.

...
WebView webView = ...;

AuthDialogWrapper pageWrapper =
new WebViewAuthDialogWrapper(webView);
pageWrapper.setAppId("App Id goes here");
pageWrapper.setAppSecret("App Secret goes here");
pageWrapper.setRedirectUri("Redirect Uri goes here");
pageWrapper.setPermissions(new String[] {Permission.OFFLINE_ACCESS, Permission.PUBLISH_STREAM});
pageWrapper.addAuthenticationListener(this);
pageWrapper.login();
...

Besides the release package, there is also a sample app demonstrating how to implement the authentication process for this platform. Here it goes the download link.

I hope you guys enjoy it.

See you in the next post...

Facebook API ME for Blackberry

2011-06-18T18:54:00.002-03:00

Hi, all

This afternoon, I released Facebook API ME v1.0 for Blackberry. This version uses BrowserField component from RIM API to display the authentication page. As I explained in this tutorial, to use the API for other platforms, you just need to work with the respective wrapper class for the target platform. Regarding Blackberry, you will have to use BrowserFieldAuthDialogWrapper.

...
BrowserField browserField = ...;

AuthDialogWrapper pageWrapper =
new BrowserFieldAuthDialogWrapper(browserField);
pageWrapper.setAppId("App Id goes here");
pageWrapper.setAppSecret("App Secret goes here");
pageWrapper.setRedirectUri("Redirect Uri goes here");
pageWrapper.setPermissions(new String[] {Permission.OFFLINE_ACCESS, Permission.PUBLISH_STREAM});
pageWrapper.addAuthenticationListener(this);
pageWrapper.login();
...

Besides the release package, there is also a sample app demonstrating how to implement the authentication process for this platform. Here it goes the download link.

I hope you guys enjoy it.

See you in the next post...

Twitter API ME v1.7 and TwAPIme for Android App v1.0 (open source)

2011-06-10T14:40:00.000-03:00

Hi, all

Today, I am proud to announce that Twitter API ME v1.7 was finally released. This new version comes with a bunch of new functionalities, improvements and bug fixes. A special fact in this release is that all new functionalities implemented were requested by developers. All of them through our Express Support. So, thank you very much to those developers and their respective companies that contributed to this project.

As I said, this version comes with a great number of news. Check them out:

- Reply tweet
- Timeline of favorite tweets
- Favorite/unfavorite tweet
- User search
- User lookup
- Get friends and followers (full objects, not just id)
- Get friendship details between two users
- New attributes in MetadataSet class
- Bug fixes related to authentication using e-mail address instead of username

As you can see, you will have a lot of work to integrate those new functions into your app.

This version also comes with some remarks:

- From this version on the release's jar file is no longer preverified for Java ME and RIM platforms. It is not necessary, because you will do that when you build your application.

- You can now obfuscate your app with Twitter API ME's jar file without adding any rule to your obfuscator. No class is instantiated using reflection any more.

- HTTP Basic Authentication support was completely removed from source code.

Besides all those great news, there is one more thing (Apple like ): TwAPIme for Android app. This an open source Twitter Android client app totally developed using Twitter API ME v1.7.

I expected to publish this app on Android Market at the same time v1.7 was released, but unfortunately, for time reason, it was not possible yet. Any way, you guys may already check out this good app. I believe it will be worthy for all developers. Find below some features available in this app:

- View Home, Mentions, DM and List timeline
- Post Tweet
- Send DM
- Reply and comment tweet
- Favorite/unfavorite tweet
- Retweet
- View user profile
- View user's lists
- View List's members
- Follow/unfollow user
- Block/unblock user
- Users search
- Report spammer

However, it comes with an important remark that must observed by everybody: Terms of Use

This source code is FREE ONLY for NON-commercial purposes. Actually, you can change it, add new features, fix bugs, etc. However, if you intend to release it as an app of yours, be aware it MUST be 100% FREE, besides making clear it is powered by Twitter API ME project and providing a link to website's project.

I recommend everybody to read the READ-ME.txt file contained in the release package of Twitter API ME and TwAPIme for Android.

So, here it goes the links to download the releases:

Twitter API ME v1.7
http://kenai.com/projects/twitterapime/downloads/directory/1.7

TwAPIme for Android v1.0
http://kenai.com/projects/twitterapime/downloads/directory/TwAPIme

So, I hope everybody enjoys all the news.

See you in the next post...

Facebook API ME 1.0: Tutorial

2011-06-05T14:11:00.001-03:00

Hi, all

As I announced yesterday on Twitter, the first release of Facebook API ME is now available for download. Besides the release package, there is also a sample app, demonstrating how to implement the authentication process.

For while, only the version for eSWT is released. So, if your target device supports eSWT, you will be able to use this package in your Java ME app right away. I am also working on other versions targeted to Blackberry, LWUIT and Android. All of them are now under test phase. I hope to release them very soon. On the other hand, if you cant't wait, check out the source code from the project's repository. You need to add yourself to the project as an Observer member to be able to check out.

Let's start the tutorial!

Registering an App

You need to register an app on Facebook's Developer page. The process is pretty simple and straightforward. The goal of this registration is to obtain some keys that are required by authentication process: App Id, App Secret and Redirect Uri. This process is very similar to Twitter's app registration process.

Once you have the keys, let get to the API itself.

Browser Component

In your app, you need to display Facebook's Login page, so your user can enter his credentials and then grant access to your app. This process is implemented by the API. You just need to provide a browser component instance and then the API takes care of the rest. Considering the eSWT version, you need to provide an instance of Browser class.

Wrapper Class

Once the browser instance is created, you have to wrap it with an instance of AuthDialogWrapper class. This class is responsible for managing the authentication and delegates the events to your app. Considering the eSWT version, you have to instantiate the BrowserAuthDialogWrapper subclass.

Setting Up the Keys

The wrapper object must be set up, so it can handle the authentication process properly for you app. There are some "set" methods that can be used to inform your App Id, App Secret and Redirect Uri. If you prefer, you can enter the keys in the constructor.

...
Browser browser = new Browser(browserComp, SWT.TOP);

AuthDialogWrapper pageWrapper = new BrowserAuthDialogWrapper(browser);
pageWrapper.setAppId("App Id goes here");
pageWrapper.setAppSecret("App Secret goes here");
pageWrapper.setRedirectUri("Redirect Uri goes here");
...

Permissions

Most services provided by Facebook API requires explicit authorization by user. So, during the authentication process you must inform which permissions the services that you intend to work with, must be granted by user.

...
pageWrapper.setPermissions(new String[] {Permission.OFFLINE_ACCESS, Permission.PUBLISH_STREAM});
...

This code snippet says the app will request permission to perform authorized requests on behalf of the user at any time (OFFLINE_ACCESS) and publish content to a user's feed at any time PUBLISH_STREAM. For the full list of permissions provided by Facebook API, click here.

Authentication Events

In order to know if the user granted or denied permission to the app, you need to register a listener of the type AuthenticationListener. This interface has three methods:

- onAuthorize(String token)
- onAccessDenied(String message)
- onFail(String error, String message)

onAuthorize() means the user has granted permission to the app along with the Access Token. Keep this token, since you will use it to sign all your requests to Facebook API. This token works to identify your app. So, from this point on, you can dismiss the login page and start publishing links, comments, etc.

onAccessDenied() means the user has denied access to his Facebook account. It does not mean the user can change his mind later and then authorize your app.

onFail() means that something went wrong during the authentication process. Just try again!

...
pageWrapper.addAuthenticationListener(this);
...

public void onAuthorize(String token) {
   System.out.println("onAuthorize: " + token);
}

public void onAccessDenied(String message) {
   System.out.println("access_denied: " + message);
}

public void onFail(String error, String message) {
   System.out.println("error: " + error + " message: " + message);
}
...

Displaying Login Page

The Facebook's Login page will just be requested and displayed, as soon as the method login() be called.

...
pageWrapper.login();
...

Dispatching Requests

The API also provides a helper class, called Dispatcher, responsible for dispatching the requests, synchronously or asynchronously, to Facebook API. Each Dispatcher instance must be associated to an access token, so all requests dispatched be signed automatically.

...
Dispatcher dispatcher = Dispatcher.getInstance("Access Token goes here");
...

Dispatcher Events

When you work with asynchronous requests, it is recommended to register a listener in order to know whether they were successfully processed. This listener is defined by DispatcherListener interface. This interface has two methods:

- onComplete(Request request, Response response)
- onFail(Request request, Throwable error)

onComplete() means the request was processed successfully and returns the result (response).

onFail() means the request failed, returning the cause.

...
dispatcher.addDispatcherListener(this);
...

public void onComplete(Request request, Response response) {
   ...
}

public void onFail(Request request, Throwable error) {
   ...
}
...

Posting on User's Wall

To publish a text on user's wall is pretty simple. Just instantiate an object of Status class, informing the text in the constructor. The other constructor allows you to post a text on a friend's wall.

...
Status status = new Status("Text goes here");
dispatcher.dispatch(status); //synchronously

//or dispatcher.addToQueue(status); //asynchronously
...

Status status = new Status("Text goes here", "Friend's Id goes here");
dispatcher.dispatch(status);
...

Sharing Link

To share a link is as easy as posting on wall. Just instantiate an object of Link class, informing the URL in the constructor. The other constructor allows you to define how the link will be displayed.

...
Link link = new Link("Link's URL goes here");
dispatcher.dispatch(link);
...
Link link = new Link("Link'URL goes here", "Link's Picture Uri goes here", "Link's Name goes here", "Link's Caption goes here", "Link's Description goes here", "Link's Message goes here", "Friend's Id goes here");
dispatcher.dispatch(link);
...

Retrieving Friends List

To retrieve the user's friends list just instantiate an object of Friends class. This request returns an instance of Friends.Response, which is Enumeration.

...
Friends friends = new Friends();
Friends.Response friendsEnum = (Friends.Response) dispatcher.dispatch(friends);

while (friendsEnum.hasMoreElements()) {
   Friends.Response friend = (Friends.Response)friendsEnum.nextElement();
   String friendId = friend.getId();
   String friendName = friend.getName();
   ...
}
...

Profile Picture

To retrieve a friend's profile picture, create an instance of Picture class, informing the friend's Id in the constructor. This request returns an instance of Picture.Response.

...
Picture picture = new Picture("Friend's Id goes here");
Picture.Response pictureResp = (Picture.Response)dispatcher.dispatch(picture);
byte[] imageBytes = pictureResp.getData();
...

Revoking Authorization

Just in case an user decides to remove your app's authorization to access his Facebook account. For that, use the request defined by RevokeAuthorization class, informing the access token in the constructor. Once this request is processed, the access token is expired and you app will no longer be able to access the user's account. To access it again, the entire authentication process must be redone.

...
RevokeAuthorization revoke = new RevokeAuthorization("Access Token goes here");
dispatcher.dispatch(revoke);
...

Log out

The wrapper class AuthDialogWrapper has a method called logout(). Call this method in order to remove any cookie or logged user's data left by Facebook's Login page in our browser component. It is recommend to call this method when the user removes the app's authorization.

It is important to point out that all items presented here are valid for all versions of Facebook API ME. It does matter if you are working on Blackberry, LWUIT or Android. The steps are all the same, except at item 3, regarding the type of subclass. Each platform has its own subclass of AuthDialogWrapper.

So, I hope this tutorial has been useful for you guys, as well as the API itself.

As soon as the release of the other platforms are released, I will let everybody knwos.

See you in the next post...

Facebook API ME & HTMLComponent: Not going well.

2011-05-23T09:42:00.000-03:00

Hi, all

Yesterday, I took the day to work on my new project: Facebook API ME. The development is going well, btw. As I explained in the previous posts, the great challenge of this project is the authentication process, since it requires certain browser integration, which is not a trivial thing considering Java ME.

Anyway, the API is now working properly using Browser component from eSWT library. eSWT is available in most Nokia and Sony Ericsson devices. I intend to release it for developers this week. I will let you guys know.

Regarding LWUIT integration, using HTMLComponent, the work is not going so well. HTMLComponent is not working well with Facebook's authentication pages. Actually, it works well on login page, where the username/password are informed. On the other hand, the page where the user authorizes the app to access his account is not displayed properly. HTMLComponent is not able to display the "Accept" and "Deny" submit buttons. Because of that, the authentication process is not complete.

I tried to check out LWUIT's latest source code from SVN repository, but it seems they are refactoring the code for some reason. There is an error in one of the classes. Because of that, I was not able to generate a jar file. Is there anybody here that could help with that?

I also intend to work on Blackberry integration, using BrowserField component. But as I am not a Blackberry expert, I have to study a little bit to understand how it works so I can work with it.

I let you guys posted.

See you in the next post...

Facebook API for Java ME: In the works

2011-04-14T13:41:00.000-03:00

Hi, all

Let's make it different this time. I use to announce my new projects just when they are ready to go, but let's change the paradigm.

Early this week, I checked in to Kenai, the alpha source code of my Facebook API ME project. The name stands for itself, it is API that allows Java ME apps to access Facebook. In fact, I had already commented on this project in the last post.

The code is in alpha version, but most features are already done and tested. I am stating it is still as alpha, since I need to retest the authentication feature using eSWT, besides implementing support to LWUIT, by using HTMLComponent.

Currently, besides authentication, Facebook API ME also supports the following features:

Post status
Share link
Get list of friends
Get friend's profile picture

It is not many features, but the way this API is designed, it is a snap to get new ones available.

As soon as I have time, I will complete the tests, so I can officially release the API's version 1.0. The source code is already available for check out, just in case you are very curious.

I hope you guys also enjoy this new project.

See you in the next post...

Facebook and Java ME: How to authenticate?

2011-03-16T09:59:00.000-03:00

Hi all,

Last month, I have developed a tiny API that integrates a Java ME app into Facebook. The implementation was not a big deal, except the authentication process. Since Facebook uses OAuth 2.0, it requires that any app that wants to integrate into Facebook's services must authenticate via its web login page. We all know that displaying HTML page in Java ME is not a easy task, since we have no LCDUI component that renders HTML. Fortunately, LWUIT already provides that via HTMLComponent.

But how to accomplish that if my app is not based on LWUIT? Hard question, huh? In my case, fortunately, the app that I had to integrate into Facebook is based on eSWT, which provides a Browser component. Because that, I was able to access the Facebook's login page and track the whole process in order to retrieve the token access required to access the methods from Facebook API.

My point in this post is: how to integrate Java ME app into Facebook API without a browser component? What is the trick? Parser the web login page's content and simulate the form submission programmatically? How have you guys have done that?

In intend to release my Facebook API in a near future. So I would like to know a better approach to implement the authentication process, so this API do not get tied to any specific framework.

See you in the next post...

Google Analytics ME 1.2: Android Support

2011-03-11T14:42:00.000-03:00

Hi all,

Today I have released a new version of Google Analytics ME project. This is also a small release that just consists of bug fixes and a new support for Android 1.5 or newer.

You can download it by clicking here.

See you in the next post...

Twitter API ME 1.6: Finally

2011-02-14T15:37:00.000-03:00

Hi all,

I would like to announce that Twitter API ME 1.6 has just been released. The main features present in this version are:

Retweets to me timeline
Retweets by me timeline
Tweets from list timeline
List management (e.g. create, update, memberships, subscriptions, etc)
Special character (*) in password bug fix

To download the new version, click here.

See you in the next post...

Soundtrckr: Internet Radio with Java ME

2011-02-11T10:27:00.000-03:00

Hi all,

I would like to introduce an interesting app developed with Java ME and eSWT, which is part of the series where Nokia is inviting the coolest app developers to showcase and pilot their apps at Nokia Beta Labs. This app is called Soundtrckr.

Soundtrckr is the first Geosocial Internet radio. It has the largest fully licensed music catalog for Internet radio in the world, plus tons of social and location-based features to help you discover and share music that you can’t find anywhere else. See below some features available on Soundtrckr:

Listen to more than 10 million fully licensed songs
Create and share personal radio stations
Play music with friends in real time
Search your city for popular music and people with similar taste
Share your favorite stations on social networks

Since it is still in lab, Soundtrckr team is inviting developers to test its beta version in order to receive some feedbacks and then improve the app as much as they can. So, if you are interested in being part of this testing process, click here and find out. On the other hand, if you are just interested in enjoying all features by Soundtrckr, you can download it directly from Ovi Store.

Soundtrckr is available for Nokia N8 and other Symbian S^3 devices as well as S60 5th edition devices. Regarding S60, the version on beta labs requires JRT 2.1 and the Ovi's one, 1.4.

For further information Soundtrckr, access the app's page at Nokia Beta Labs.

Before I forget, Soundtrckr works with Twitter API ME in order to implement the functionalities related to Twitter. Cool, huh?

See you in the next post...

Google Analytics ME 1.1: Just a patch

2011-01-13T18:35:00.000-03:00

Hi all,

I have just released Google Analytics ME 1.1, which consists of small bug fix related to visitor identification. In the first version, the visitors were not being tracked properly. In fact, every tracking was recording as from the same visitor. Now it is fixed! However, the API is not able to track unique visitors yet. Actually, a new visitor identification is created at each new app session started. In other words, if you restart your app and track anything to Google Analytics, a new visitor will be counted.

I hope to provide unique visitors feature in the next versions. Stay tuned!

To download the new version, click here.

See you in the next post...

Tracking Java ME Apps with Google Analytics

2010-12-27T20:04:00.000-03:00

Hi all,

Today I would like to announce another project of mine, which I believe it will be very helpful for most Java ME developers. This new project is called Google Analytics ME.

This micro Java API allows developers to track their Java ME apps using Google Analytics. Developers will be able to analyze how the users are using their apps, using this Google's powerful tool, just like they are used to do with their websites.

To work with Google Analytics ME is as easy as it is to install that piece of JavaScript code provided by Google, in order to start tracking your websites. The only requirement of Google Analytics ME is a tracking code (e.g. UA-1736743-0), which you get as soon as you register an account for your website (app) on Google Analytics.

Once you have your tracking code, all you need is to specify which points of your app will be tracked by the API.

Google Analytics ME is capable of working with two types of events provided by Google Analytics: Page View and Event Tracking.

A Page View is an event that represents a page (or screen) that was viewed by a user. For instance, you may use this event to check how many times your app was started up, by tracking the MIDlet's constructor. See below how to implement it:

public AppMIDlet() {

...

    Tracker tracker = Tracker.getInstance("UA-1736743-0");

    tracker.addToQueue(new PageView("/app_started"));

...

}

In a similar way, you can also track how many times each app's screen is viewed by users, just using another unique id for each one. For instance:

public MainMenu() {

    super("Media Player")

...

    Tracker tracker = Tracker.getInstance("UA-1736743-0");

    tracker.addToQueue(new PageView("/media_player"));

...

}

An Event Tracking may be used to track events that occur in a screen, e.g., a button click or the usage of a given feature. For instance, considering your app is a media player, you can track how many times or how long a given song is played.

An event is composed of four information: Category, Action, Label and Value. A Category only works to group actions. For instance, a Category could be a screen's title, which you intend to track its events. The Action, considering a media player, would be the events of playing or stopping a song. In addition, for each Action, a Label may also be specified. In this case, you could use a Label to indicate the song's name being played.

Specifying up to these three parameters, Google Analytics will count how many times they were tracked. On the other hand, when you specify the Value, which is a integer, Google Analytics will also sum all values that were tracked for a given Category, Action and Label.

This way, we can track, for instance, for how long a given song was played, because Google Analytics will display a sum of all values.

See below how to work with events:

public void play(String media) {

    Tracker tracker = Tracker.getInstance("UA-1736743-0");

    tracker.addToQueue(new Event("/media_player", "Play", media, null));

...

}

public void stop(String media) {

    Tracker tracker = Tracker.getInstance("UA-1736743-0");

    tracker.addToQueue(new Event("/media_player", "Stop", media, timePlayed));

...

}

It is important to point out that only Category and Action are required. For further information on event tracking, click here.

You may be wondering why the events are being added to a queue. It is because the Tracker class can work synchronously and asynchronously. All queued events are flushed automatically by an internal background process that runs within a fixed-delay strategy. In addition, to work synchronously, you can use the method Tracker.track(Request), which immediately sends the event to Google Analytics.

...

Tracker tracker = Tracker.getInstance("UA-1736743-0");

tracker.track(new Event("/media_player", "Rewind", null, null));

...

You can also adjust the interval between each flush operation, by using the method Tracker.getIntance(String, long). In addition, the queue can be explicitly flushed through the method Tracker.flush(boolean).

...

Tracker tracker = Tracker.getInstance("UA-1736743-0", 120);

...

The code above specifies that background process runs at each 120 seconds. It is also important to point out that there is only one Tracker object per tracking code, since it uses the Singleton pattern.

As usual regarding my projects, this one is also available on Kenai.com and can be downloaded here.

I hope you guys enjoy it.

Happy new year!

See you in the next post...

AdME: Ad Library for Java ME

2010-12-13T21:21:00.000-03:00

Hi all,

I hereby to announce another open source project of mine, called AdME. The idea behind this project is to provide a standardized way to access Ad Networks from Java ME apps. Designed to be extensible, AdME is prepared to support any Ad Network. For each network supported, a connector component must be build in order to handle the Ad retrieval. This work is done following a standard interface defined by the library.

In this version 1.0, AdME provides support for Inner-active Ad Network. It is a very good service that provides a rich set of Ads for Java-ME based devices, besides other popular platforms. Currently, I am working with them for two appa of mine. So far, so good! All you need to do to work with them is to fill out a form and register and your app. In a couple of hours, a person on behalf of Inner-active will get in touch with you, in order to provide your username, password and Application ID. You will use this ID in order to connect your app with Inner-active.

The AdME library is already available on Kenai.com/adme. There, besides the library, you will also find a sample app that demonstrates how to work with AdME. Due to lack of time, I was not able to publish a project's wiki with more details yet. However, the library is very straightforward and I believe you will not have any problem to get it working, by reading the Javadoc and/or analyzing the app's source code.

I hope to get more Ad Networks connectors implemented as soon as possible. If you know a good network with Ads for Java ME devices, please let me know.

I hope you like it!

See you in the next post...

Twitter API ME 1.5

2010-10-31T10:19:00.000-03:00

Hi all,

Quick post just to announce that Twitter API ME 1.5 has just been released.

In this new version, the following new features are available:

List of pending friends/followers request
Report spam
Retweets of me timeline
Trend Topics search
Tweet's entities
Retrieval of access token from UserAccountManager class

For further information on this new release, access www.twitterapime.com

See you in the next post...

JPhone and JOS: It could work

2010-10-22T13:50:00.000-03:00

Hi all,

Since iOS and Android came out as two big waves flooding the entire mobile world, leveraged by Apple and Google (and its partners) and their incredible devices, developers have wondered what is going to be the future of other mobile platforms. In our case, Java ME.

There are a lot of discussions in the internet about this topic. Actually, I have already exposed my point of view on this matter. However, I am not here today to extend this discussion. In fact, I would like to demonstrate how Java ME could be at a better place.

In my opinion, one of the greatest advantage of iOS and Android platforms have compared to Java ME is a rich and uniform base. Who develops for either one knows that there is a bunch of APIs that allow us to build very compelling apps. In addition, those APIs will always be there. So developers do not have to worry about fragmentation.

In any event, we know that Java ME has a different concept, which is to provide a base platform aimed to run on low, mid and high-end devices. Because this difference of hardware, not all JSRs specified by JCP are available on any Java ME-enabled device.

Since the existent set of specified JSRs, I believe that Java ME could be at a better place. Java ME has a very rich set of JSRs at JCP that could also provide a very rich and uniform base for Java ME devices. If we had a manufacturer interested on implementing all of them in a single device, I believe Java ME developers would not be so afraid. Sony Ericsson and Nokia have done a good work on providing devices with a very good set of APIs. However, it is not enough to compete with the other players.

So, let's imagine such device. Let's call it JPhone, running JOS. Now, let's outline some JSRs that could be present on it.

A lot of stuff, huh? And here I am just considering JSRs that at least are compatible with CLDC and at final release stage. There are a bunch of other ones in JCP, but they are either CDC compliant, rejected or stuck. I am assuming that once a JSR reaches final release stage, it is feasible to be implemented. So it would be ready to go on JPhone.

I would also add LWUIT to this list. I believe that all efforts put on LWUIT, since ORACLE (that time Sun) embraced it, have come this project to a higher level of maturity and capabilities. Today, we have seen great things being developed with it. At Java One, there were many presentations regarding LWUIT being capable to build very compelling smartphone apps.

This my list is close to what is proposed by MSA. However, I would like to see no optionality, i.e., MSA subset or even hardware dependency.

We can't forget about the Java language itself. Today we are stuck in Java 1.3 language. On the other hand, there are some great new features, e.g., generics, enumerations, auto boxing, etc, in Java 5, which most developers can no longer live without.

Java has many more things to offer and that could be present on JPhone, e.g., collections, network, I/O, etc. Considering the hardware that runs iOS and Android, full Java SE 6 could run properly on it too.

Another leak of Java ME is related to an application model. iOS and Android have theirs, which are based on Model-View-Controller pattern. On the other hand, Java ME let this task on developers' hands. Java ME needs to provide more references for them.

Java ME also leaks providing a better solution for data storage. Record Store is not enough at all. On the other hand, iOS and Android provide their SQLite implementations. It is time for ORACLE to start thinking of using its huge background on it to help Java ME.

I know that my proposal is kind of surreal, but it seams to be a receipt for success of iOS and Android. Windows Phone 7 tends to follow it letter by letter.

See you in the next post...

Improving your App Quality

2010-10-22T08:44:00.000-03:00

Hi all,

Check this interesting post that I just read on Android's blog. It describes important points about how to improve app quality. In some points, the writer speaks about specific things of Android platform. However, the general idea is worth for any app, regardless platform.

See you in the next post...

Beyond Smartphones: Rich Applications and Services for the Mobile Masses

2010-10-17T10:30:00.001-03:00

Hi all,

I would like to share you this presentation by Terrence Barr (@terrencebarr), at JavaOne 2010. Terrence introduces some tools that allow us to build rich and compelling smartphone-like applications. To demonstrate how to put all this technologies together, he develops a very interesting social networking mash-up app.

Terrence points out three technologies in his presentation:

To access the presentation, click here. It is a short one, but its content is valuable and really worths a view.

See you in the next post...

xAuth lib: OAuth made easy

2010-10-08T16:41:00.002-03:00

Hi all,

Nowadays, important sites on web are growing their presence in mobile space. As usual, a quick way to go in this direction is releasing mobile versions of their sites. On the other hand, they also use to provide means so third-party sites and apps can access their content and services. For instance, many sites (or platforms), e.g., Google, Yahoo, Facebook, Twitter, etc, provide APIs, so that developer can build their products that rely on content from them.

To start accessing any content or service from one of those sites, you first need to authenticate with it. The site needs to recognize you so it can open their doors for you. The type of authentication may vary depending on each site. It is commom to encounter with Http Basic Auth, which is very easy to work with. However, most services are shifting to OAuth. A more secure auth mechanism that also avoids third-party sites have access to user's credentials. Recently, Twitter turned off its Http Basic Auth, to support only OAuth. Some sites still work with both, but it is matter of time so they keep only OAuth.

Due to some aspects of OAuth, its pure implementation is not feasible for desktop and mobile apps. This is related to a spec flow that demands your app to be redirected forth/back to/from a login page. It is kind of complicated to accomplish that in a mobile app, for instance. To avoid this step, they created xAuth, which is same as OAuth, but the login page flow.

An OAuth request is quite more complicated to perform, since it requires a signature for the request, which uses some hash algoritms and encoders. To now more about it, click here.

In my Twitter API ME project, I had to implement it, since as I previously said, Twitter turned off Http Basic Auth. However, my xAuth implementation was designed to be reused by other apps and frameworks. So, if you are looking for xAuth lib for your app, you are at the right place. So, to start it up, download the latest version of Twitter API ME at www.twitterapime.com.

Below I will put some code snippets that demonstrate how to get authenticated to Twitter and then post a tweet. After downloading the API, you will need to obtain your app's OAuth keys: consumer key and secret. They will be used to produce that signature I mentioned ealier. Those keys are provided by the site you want to connect with, after a quick subscription. Let's show some code:

01. HttpRequest req = new HttpRequest("https://api.twitter.com/oauth/access_token");
02. req.setMethod(HttpConnection.POST);

03. XAuthSigner signer = new XAuthSigner("", "");
04. signer.signForAccessToken(req, "", "");

05. try {
06.    HttpResponse resp = req.send();
07.    if (resp.getCode() == HttpConnection.HTTP_OK) {
08.        Token accessToken = Token.parse(resp.getBodyContent());

09.        req.close();

10.       req = new HttpRequest("http://api.twitter.com/1/statuses/update.xml");
11.       req.setMethod(HttpConnection.POST);
12.       req.setBodyParameter("status", "");
13.       req.setSigner(signer, accessToken);

14.       resp = req.send();
15.     }
16. } catch (IOException e) {
17.    e.printStackTrace();
18. } finally {
19.    try {
20.        req.close();
21.    } catch (IOException e) {}
22. }

Basically what we do is to sign each request, using XAuthSigner class, as we see in the lines 4 and 13. As soon as you get authenticated, you will obtain your access token (line 8). From this point on, every request will be signed using your keys and token. This token, in turn, can be stored for further use. It avoids requesting user's credentials next time and skip auth step.

I recommend before trying to access any site using xAuth, that read its documentation first, so you can see whether they require an additional procedure to work with xAuth. I am mentioned that, because Twitter, for instance, demands us to send an e-mail to them requesting privileges to use xAuth in our apps. Otherwise, it will not work. So be aware of that.

So, that's all guys! I hope it be useful for all of you.

See you in the next post...

Millennial Media: Mobile Advertising with Java ME

2010-10-08T11:23:00.000-03:00

Hi all,

It is notorious the growth of mobile adverstising in the last years, since mobile devices are more connected to internet. More and more publishers are investing on it, in order to sell their products/services, based on a huge number of potential consumers, which use their devices everyday to read e-mails, news, chat, etc. It is a market of millions of dollars a year.

Who makes possible all this mobile advertising are specialized companies known as Ad Networks. They are responsible for connecting publishers to advertisers. In our scenery, Mobile Ad Networks. Regarding us, developers, those companies provide a variety of means for us to integrate our apps with their ads platform. They provide SDKs for the main mobile platform in the market, e.g., iOS, Android, Flash, WebOS, etc. All you need to do is to sign up in one of those companies, e.g. AdMob, iAd, Quatto, Jumptap, etc, and download the SDK. Most of them are very documented and pretty easy to install.

But I believe you may be wondering: Do they not support Java ME platform? The answer is no. However, just a few of them do. On the other hand, they do not provide a specific SDK for Java ME, just like they do for iOS, Android, Flash, etc. They usualy provide a RESTful API, which your app can access in order to retrieve an ad. Web apps also use this sort of API to work with ads.

Recently, I have been searching for an ad platform in order to provide ads from our app, M-Stocks App. For our iOS and Android versions it was easy to find, but for Java ME, it took awhile. For instance, we tested AdMob, Adfonic, Jumptap but no success. Even their RESTful API did not work for us. We were about to create our own ad platform, when we finally encountered Millennial Media. On their website, they state Java ME support. So I decided to give it a shot.

We sign it up and then started to read the documentation. Actually, they do not provide a Java SDK, in fact they provide a RESTful API, called Server-Side API. This API is very easy to work with. They just require a few paremeters (i.e. UID, IP, User-agent and App ID). By default, they return a HTML code, which contains a ad's image url and link. For instance, if you utilize LWUIT as UI framework, you just need to set this content in a HTML viewer component. Otherwise, you need to implement a workaround.

The workaround is simple. As in the HTML content there are an ad's image url and link, you just need to parse it and get those information. Once you have the ad's image url just download the image using HttpConnection and display it using ImageItem or Canvas. To open the ad's link, do it using MIDlet.platformRequest(String), which will open up the device's browser.

On the other hand, Server-Side API also enables you to receive an ad in XML format, which contain more data about the ad, e.g., image type and size. To enable this, you need to send an e-mail to Millenial Media's support and requesting it for your app. However, I actually tried that, but I got no reponse from them so far. Because of that, I am parsing the HTML.

Other interesting feature by Millenial Media is the ability of integrating with other ad networks. You can set up your AdMob account, for instance, and then receive ads from Millenial and AdMob in your app. Particularly, I am using this approach.

By now, we are going good with Millenial Media. I hope it brings good revenues for us. Mobile advertising is a very good approach for free apps developers. It is a good alternative, since we do have many options to charge for Java ME apps.

See you in the next post...

Floggy: Powered by Eclipse Plugin

2010-10-08T09:29:00.000-03:00

Hi all,

Do you remind Floggy? No? So click here and refresh your mind. In a few words it is a persistence framework, which makes easier the work with data persistence in Java ME. No more handling byte arrays and record stores. My students liked it! They were not confortable with the idea of working with bytes, so I decided to introduce Floggy to them. This behavior is pretty commom from developers coming from JEE world, used to deal with Hibernate, JPA, etc.

For my surprise, one of the students that decided to work with Floggy, in order to develop his final evaluation project, introduced me a pretty nice tool: Floggy Eclipse Plugin. I really did not know it. That time I wrote about Floggy, I did not pay attention in all details of the project.

Anyway, always is time to introduce good things. Floggy Eclipse Plugin makes much easier the process of working with Floggy: from setup until deployment phase. In addition, you do not even need to import Floggy lib into your project. The plugin does it for you.

The install process of Floggy Eclipse Plugin is just like any other Eclipse plugin. Once istalled, all you need to to is to enable it for your project. Just right-click in your project folder and then press "Add Floggy Nature". Easy, huh? Now you are good to go! However, if you need more details on it, here it goes the link.

Floggy is a very good alternative for Java ME persistence. It is worth a shot.

See you in the next post...

LWUIT: In the spotlight at Java One

2010-10-04T13:40:00.005-03:00

Hi all,

LWUIT was one of the most mentioned topics related to mobility at Java One. This year, there were many sessions related to it, for instance:

Beyond Smartphones: Rich Applications and Services for the Mobile Masses
Developing Java TV Applications with LWUIT for DTVi-J (Ginga-J) Brazil
LWUIT Cheat Sheet: How to Optimize Your LWUIT-Based Java ME Applications
Introducing Java TV Widget Development

Since LWUIT has joined ORACLE (since times of Sun), it has achieved a huge visibility and importance in mobile scenery. Now, developers are more aware of what they can do for their apps, regarding UI. Instead of struggling to implement their own UI frameworks, now they know that there is a good option to invest on. In addition, LWUIT has also worked hard to provide more features and be more stable as new versions are released.

Today, I would like to share with you this short presention about LWUIT 1.4 and some other related topics, e.g., Virtual Keyboard, HTMLComponent, etc, that was also presented at Java One. Who hold this presention were Ariel Levin and Chen Fishbein. Two key LWUIT developers.

I hope you like, since it gives a good overview of what now you can do with LWUIT 1.4.

See you in the next post...

Java ME: Next steps

2010-10-01T09:06:00.000-03:00

Hi all,

As most of Java community must know, last month we had JavaOne event, in San Francisco, CA. It was a huge event, as usual. Many Java topics were discussed and introduced. But one of them has great importance for us, which is related to Java ME.

We all had our doubts about Java ME's future after acquisition of Sun Microsystems by ORACLE. It has been created a big expectation on what would be the next steps of this platform. Fortunately, they had something prepared to announce at Java One.

There are some good news for all of us, which I want to share with you. Who outlines all these good stuff is Terrence Barr. A very known name in Mobile & Embedded Java community. I will drop here a link to his latest post, where he describes what is coming on Java ME's future.

However, I really do not know how soon we will get all those new features. Since, we all know that it does not depend on ORACLE only. Unfortunately, Java ME-enabled devices are not produced by ORACLE itself. I wish we could have something for Java ME as we have for iOS and Android platforms.

I really hope it does not end up like MIDP 3.0. Let's cheer for the opposite!

See you in the next post...