Image by The GameWay

So I believe by my last posts here you may have guessed I’ve been doing lots of mobile development in the last few months.

It’s got nothing too do with work, as I do all of my mobile development on my spare time at home.

So what brought me to it?

I always felt like I was missing a big “piece of the cake” (which isn’t a lie btw) when seeing some of the people I relate to on a daily basis, talking about how cool mobile application development was.

Some things you can avoid, others you can only delay, and I know the latter was true in this case, but I was fighting really hard to let the laziness win.

Then came the Playbook, and RIM was offering to give one for each developer who successfully built and published an application for it before the launch of the device.

There was no way out this time. I love free stuff more than anything else, I’m one of those people who change their route when they know that if they pass through a certain place at a certain hour, there will be freebies being given. I queue for free bits of cheese at the supermarket *blush*.

So there I was, sitting in front of my computer with a trial copy of flash builder, and trying to make something I thought people would enjoy.

Then came the idea of building a Magic 8 Ball type thing (which later would have to be renamed and rebranded due to patent implications I wasn’t even aware of. But I’ll talk about this one on my next post).

In about 5 days and having no previous flex knowledge at all, but just some ActionScript, I had an application running on my simulator.

It was the coolest thing ever, it felt like the olden days of hacking through other people’s source code to steal get JavaScript ideas.

I then went to the pretty complicated challenging process of getting my app signed and approved.

Rim, the company behind the Playbook (and blackberry) was completely overflowed with approval requests, and it took them good 20+ days to actually get my application approved. I made the cut first time though, which made me quite proud, since it was my first appearance on the “mobile scene”.

Because it got me so excited about the whole thing, I had my second app (Time Traveller) approved even before the deadline before the launch was over. I built this very app several years ago in C, and used it a lot when I was travelling to help me get through the differences in timezones on the several countries in Europe I was going to. Except that this time, I built this one entirely using Rim’s Playbook Tablet SDK, which is optimized for the Playbook.

I then received my Playbook about 15 days after the US release, which meant I had it before it had been mentioned here in the UK. What a chick magnet that was

Getting the Playbook only gave me more stamina to build my third app, so I started with Bonjour, which is a French learning application that teaches you by pronouncing the words, and encouraging you to repeat then. Pretty cool stuff IMO.

It might be just me, but you can’t build an app that teaches people French, without also building one that teaches people Italian. It’s just wrong! So I couldn’t help but building Ciao, which had exactly the same premise as Bonjour, but for the Italian language.

I put several hours in making sure the applications were useful and functional, and would attend the needs of all. For that reason, I made them available in 6 languages, so even if you can’t speak English, it’s very likely you will be able to speak either Spanish, Dutch, German, Portuguese, French or Italian.

You guessed right, I was very enthusiastic about the whole thing, and surely my mobile saga wouldn’t simply end here.

BUT I feel like I’ve already dragged this blog post for too long, so will continue my story on the next post, where I’ll be telling you what happened next, what patent problems I had with my Magic 8 Ball app, and what new apps I have released.

I will also talk about other markets, and what new applications I’m working on right now.

So stay tuned.

Here’s is something that got me scratching my head for a little while today while working on my new mobile application.

In my new application, I’ll be reading XML off various different providers, so I have an interface that gets implemented in various classes to make sure they all obey a certain contract, and I don’t need worry about what type they are (more on that later…)

With that in mind, I ended up implementing different logic on different classes since the XML returned will vary from provider to provider. I am using E4X to get the various information I need from the XML returned, and one of them would not work at all when selected.

I will put two XML examples here, and let you spot the difference:

var basket:XML =
	<foods>
	  <fruit>
		<name>Apples</name>
		<name>Bananas</name>
	  </fruit>
	</foods>;
trace(basket..fruit.name[0])

And that should return “Apples”.

Nothing new here, now for the second example:

var basket:XML =
	<foods xmlns="http://www.w3.org/TR/html4/">
	  <fruit>
		<name>Apples</name>
		<name>Bananas</name>
	  </fruit>
	</foods>;
trace(basket..fruit.name[0])

At a first glance, I have to admit I was expecting apples as well, but to my surprise, I got… nothing…

It took me a while to to go look on the XML again, and then it hit me. This provider would give me XML with a namespace, and in order to read that with E4X, I would need to declare that namespace. There is absolutely nothing wrong with the code above, but it simply won’t find anything since you’re not declaring what the namespace is, and the compiler gets completely lost.

What you need to do is declare the namespace on the top of my code like so:

namespace items = "http://ns.imageshack.us/imginfo/7/";
use namespace items;
trace(basket..fruit)

How you name it doesn’t matter, but it’s important that it’s unique, so in case you’re reading from multiple XML files on the same class, you should be using different names, otherwise you will get compiling errors.

This is just a quick example of how to add a background colour to a label control in AS3.

Most people don’t know, but the label component has a TextField inside of it. What that means is that you can basically use all of the available methods within the TextField in a label. Here’s an example of how to add a background colour to a label.

import fl.controls.Label;
// If you were doing Playbook development
// import qnx.ui.text.Label;
 
var lblName:Label = new Label();
lblName.textField.background = true;
lblName.textField.backgroundColor = 0xFFFFFF;
addChild(lblName);

And that’s it. You now have a label with a white background. Seems pretty simple, but what is cool here, is the fact that your label can have pretty much the same behaviour as a text field, and you can modify it as you would in a text field.

As some of you might have noticed, I have been building some mobile applications lately on my spare time specifically for the Blackberry Playbook. They are mainly built in Adobe Air using Actionscript 3 and Blackberry’s Tablet SDK.

On my latest application, I have found the need for a database, as it needs to store lots of user input data. The first option that comes to mind is SQLite, as it’s very simple to integrate, and has native support.

I will show here an integration example, and focus on a caveat I found while trying to use it on a real device.

For starters, here are the classes you need to import on your main class:

import flash.data.SQLConnection;
import flash.data.SQLStatement;
import flash.filesystem.File;

I then create a method to initialize my database connection:

private var dbConnection:SQLConnection = new SQLConnection;
private function initDB():void{
	var embededSessionDB:File = File.applicationDirectory.resolvePath("assets/db.sqlite");
	var writeSessionDB:File = File.applicationStorageDirectory.resolvePath("assets/db.sqlite");
	// If a writable DB doesn't exist, we then copy it into the app folder so it's writteable
	if (!writeSessionDB.exists) {
		embededSessionDB.copyTo(writeSessionDB);
	}
	var dbFile:File = writeSessionDB;
	dbConnection.open(dbFile);
}

What is important to mention here, is that most people (myself being one of them) will be completely tempted to skip the bit where it copies the local file (coming from the application itself) into the local storage. Funnily enough, if you skip this step, when you test it locally, it will all work wonderfully, but when you deploy it into a real device (or even a simulator) nothing happens at all.

After some research, I found out that you need to be using the database from the local storage, and just like this is that you will have read and write permissions.

After getting that small “detour” out of the way, I can go on and write my first query against that database.

private function getWords(intTabID:int):Array{
	var stmt:SQLStatement = new SQLStatement();
	stmt.sqlConnection = dbConnection;
	stmt.text = "SELECT key, word FROM WORDS WHERE category_id = (:wordID)";
	stmt.parameters[':wordID'] = intTabID;
	stmt.execute();
	var result:Array = stmt.getResult().data;
	return result;
}

And this will return a nice array with all my data from the SQLite database.

I’m building a new Blackberry Playbook app, and when starting to work with internationalization, I got stuck with a bug that wouldn’t go away. I’m pretty sure this won’t just affect just this kind of application, but anything that is built using Flash Builder and requires resource bundle files.

It’s a pretty common standard to name resource bundle files as *.properties, but it turns out Flash Builder ignores *.properties files when packaging, and you end up with an error like:

Error: Error #3003: File or directory does not exist.

It actually took me quite a long time to figure that one out, since I was pretty sure the files were in the correct location. Changing the file extension to .prop did the trick, and now Flash Builder will package them successfully.

I believe there must be another way in Flash builder settings to make it not ignore *.properties files, but for the time being, simply renaming its extension will do.

Hope that helps someone in the future searching for this error.

Ok, I know I’m late on this, but I just thought I’d register here that Adobe Flash Player 10.2 has just been released on the Adobe Labs this week.

A few of it’s key features are:

• Stage Video hardware acceleration
• Internet Explorer 9 hardware accelerated rendering support
• Native custom mouse cursors
• Support for full screen mode with multiple monitors

Here’s a video preview from Adobe Max 2010:

Download the Flash Player 10.2 beta

I know it must be pretty old news by now that Matt Gifford has written a book called Object-Oriented Programming in ColdFusion.

I’ve been approached by the folks at Packt last week and asked to read it and write a review about the book.

I’m still waiting for it to be delivered, but will be writing the review as soon as I’m done with the book. In the meantime, you can have a sneak peek of the sample chapter or buy the book directly.

As previously mentioned on my other post, I’m working on improving usability and user experience within one of our applications.

This application has a somehow complex authentication system managed by Fusebox.

In one of our screens, we’ve replaced most of the page refreshes with ajax calls, so on the table of contents, the user can modify anything, and it gets saved automatically upon confirmation without the need for clicking buttons or reloading the page.

Our QA soon noticed that if during the process of browsing the page and updating something you got yourself logged out, the authentication system would kick off (as it runs per request), and the whole page would get a bit screwed.

An example of this would be:

When clicking on each of the tabs, they would trigger an Ajax call to a dynamic page that would return some HTML. this HTML would fill up the internal div and display the contents without refreshing.

Now, if while clients were viewing this page they decided to go for a cup of tea and clicked on a tab when they came back after 15 minutes, the following would occur:

That isn’t the right behaviour, as the browser is supposed to redirect the user to a login page, and not display this page inside the tabs. in this situation, no matter what the client do, clicking the tabs will always take them to the same screen, which could confuse them.

To get around this, I need to have some kind of hook that will check if the user is logged in before any Ajax requests are made.

Come jQuery to the rescue!

When using any of the Ajax capabilities available through jQuery, you can register a handler to be called when the  request begins.

This can be accomplished with ajaxStart(). it will kick off whenever you make an Ajax request, and in this case, it works a treat, as it will go through my authentication system, and redirect the page to the login screen should the user have been logged in.

A simple code sample for this would be:

$(this).ajaxStart(function() {
     $.ajax({
           url: 'index.cfm?fuseaction=c_common.islogged',
           success: function(data, event) {
             //check the results of the authentication page here
           }
     });
});

You can also use ajaxStop() for the exact same effect, but only getting triggered when the Ajax call is finished.

Book reviewer Marcos Placona | Publisher: Packt | Author: John Farrar

The book starts with a very brief introduction to ColdFusion, and what the basic language capabilities are.

On chapter 1 – Web Pages – Static to Dynamic

The author begins by explaining what variables are for, and then moves into strings and scopes. He then moves into structures, loops, arrays , conditional processing through if’s and case statements, and explains some of the wonders on exception handling. This chapter is merely a run through around the CFML language, and will help programmers familiar with the technology to understand the conventions used by the book through the code samples.

Chapter 2 – Basic CFCs and Database Interaction

Things start to get a bit more exciting on chapter two, where the topic moves into CFC creation, some objects (beans), and a little bit of database interaction. I like how basic terminologies are described here, and pretty much every example is showed through tags and scripting.

The book uses a very simple product management system as example, and the examples show what a bean object is, and what it can be used for. I could see the author did not focus too much on explaining what object oriented programming is, but the concept is shown through the whole book.

In this chapter, some simple database interaction is demonstrated, and at around page 60, you are already writing full blown objects, which are database reliant, and give you the ability to encapsulate most of the logic.

Chapter 3 – Power CFCs and Web Forms

Things start to get a lot more interesting now, and the book starts to explain why restricting access to methods is so important. All of the four access types (public, private, package and remote) are described, and the author briefly exemplifies when which of them should be used.

Some more database examples are given here, and what was only a set of screen dumps with database objects on chapter two, starts to take some form, and the examples already show how to properly create, update and delete data from the database through in-line SQL. At this point, I reckon anyone who’s never seen ColdFusion, would be able to get a pretty good idea of its capabilities.

Chapter 4 – ORM Database Interaction

This is the chapter everyone has been waiting for. The CFML language has used in-line SQL (or stored procedure calls) all along its 15 years, and a new way of interacting with databases was long overdue. Chapter 4 starts by taking you through the necessary steps to “ORM enable” your application and CFCs. In all honesty I was expecting to be put off by this chapter, as ORM in itself is a pretty big a complex subject. The author exposes the topic in a very nice way, and I felt really comfortable reading and coding through the examples.

ORM really seems magical, and will do wonders for small to medium projects, where high performance is not  the major concern.

The code samples are really fun to do, but I felt there was a lack of explanation on when and why people should be using ORM as opposed to the good old inline SQL or stored procedure calls.

Chapter 5 – Application, Session, and Request Scope

After a very exciting chapter 4, the author touches back again on scopes, and starts to talk about the application.cfc, and what the life span for each of the scopes is. It’s not nearly as exciting or elegant as ORM, but as the request and session scopes are widely used across ColdFusion applications, it’s important to know what can, and what can’t be done with them, as well as settings you can apply to the through simple directives on the application.cfc

Again the author gives some examples on how these directives can be used in real life, and also shows some of the new cool things added to ColdFusion 9, such as the ability to create universal data sources, or setting custom tag paths per application.

Chapter 6 – Authentication and Permissions

This chapter describes the built-in authentication framework and methods that can be found inside ColdFusion. The example given here is a simple user login, where each group consists of a set of roles. This is particularly useful on CMSs, where only users within a specific group can interact with xyz system modules.

I specifically like how the author employs the cflayout tag to create the screens here.

Chapter 7 – CFScript

Every CFML developer has been waiting for this day to come, and it finally did on ColdFusion 9. ColdFusion is now fully “script-able”, and developers no longer need to write code through tags. Until ColdFusion 9, you were only able to use a limited set of functionalities with cfscript.

In this chapter, the author describes what each operator is, and exemplifies the most common functionalities through script. there aren’t too many things to be said here, and the examples pretty much show what needs to be shown.

Chapter 8 – CF AJAX User Interface

Everybody loves ajax, and ColdFusion has helper tags that will help you get up and running with it, even if you are not a JavaScript wizard. most of the examples given on this chapter are related to presentation and user interaction. a simple pod system is demonstrated, and after only a handful of lines, the example turns into a very interactive interface.

Things get a bit more colour once the author starts to describe the cfmap tag usage. this in my opinion is one of the most impressive new tags in ColdFusion 9. It allows you to interact with Google maps, and display live data on your website.

As every every back-end technology that generates JavaScript, the code becomes really obtrusive, and most very specific setting will need to be set through JavaScript.

Chapter 9 – CF AJAX Forms

This is pretty much an extension of chapter 8, but the author focuses a lot more on forms. ColdFusion has a nice set of built-in UI capabilities, and the examples here really demonstrate them in full colours. The first example  shows a product data-grid with pagination functionality. It also allows you to delete and update products “in-screen”, without the need for refresh.

Some other examples demonstrated here are:

Auto-complete field, date-picker, related drop-downs, wysiwyg editors, directory trees, message boxes and progress bars. All of them can mostly be accomplished in less than 10 lines of code, and look really slick.

Chapter 10 – CF AJAX Programming

I have to admit a got a bit bored of Ajax t this stage, and another chapter on Ajax seems a bit overkill. In fact, Ajax is a pretty extensive topic, and there’s entire books covering the topic from front to back.

In this chapter, the author demonstrates how to bind HTML objects, JavaScript, URLs and events to CFC’s. It also briefly touches debugging both on client and server side, as well as describes the functionality of each variable available through the ColdFusion JavaScript API.

Chapter 11 – Introduction to Custom Tags

Custom tags are mainly created for code reuse, and have been widely used for a long time. In this chapter, the author explains the differences between them and CFCs or includes.

The book exemplifies the usage of custom tags by building a dynamic page layout where common things such as the header and footer and invoked via custom tags.

At the end f the chapter, the author describes how the same results can be accomplished through  tag libraries or cfmodule.

Chapter 12 – ColdFusion Powered Views

This chapter shows how to manipulate the presentation layer with ColdFusion, and gives some very nice examples on how to manipulate the DOM with ColdFusion code. Basically, from ColdFusion you could for example modify the entire page style with the click of a button.

Chapter 13 – Control Logic Processing

It’s now time to put everything we learned in practice, and the book briefly explains MVC (model, view, controller). this is a very complete chapter, where the author has put a lot of effort to try and use most of what’s been explained in the previous chapters, but in a more organized way (through MVC)

Chapter 14 – Guide to Unit Testing

Unit testing is one of my favourite topics, hence, this is my favourite chapter. Most software developers don’t really know when, where or why a system needs to be tested. the most popular ColdFusion testing framework is called MXUnit, and is freely available for download.

In this chapter, the author exemplifies how and when to use unit tests as well as some simple assertions. He also shows what the different views for unit tests results can be used, and briefly touches built-in assertions.

My personal notes

It’s been a pleasure reading this book, and although I cold not really learn a lot from it, as it’s mostly targeted to new developers, I was able to update myself on many of the new functionalities included on ColdFusion 9. I don’t necessarily agree with all the code samples used on the book, and would not use some of the same approaches described by the author. That said, I think this is an amazing book for any ColdFusion developer at any level. It’s not the kind of book you will want to keep on your desk as reference, but surely is an excellent complement for any level of knowledge.

I’d like to leave here my special thanks to the fine guys at Packt who sent me this book for evaluation and technical review.

I found this two function yesterday while working on one of our applications.

We are turning a very boring page into a full blown jQuery powered page. It’s got loads of functionalities being turned into Ajax calls to give the user a better experience. We are really taking usability into account, and minimizing things like page refresh or reloads is essential.

One thing that got to us, was the fact that IE8 insists in caching some Ajax contents when loading things too quickly (i.e. if a link is clicked, and a tab is clicked subsequently).

This is easily fixable by adding a timestamp to the request, so whenever a link is clicked, the request would be doing something like:

var tS=new Date().getTime();
$.ajax({
    url: searcher,
    data: {timestamp:tS},
    type: 'GET',
    dataType: 'json',
    success: function(data) {
        //something here
}});

The code above will do the job, but you have to remember to always use the timestamp, and pass it on.
Another better way of doing it, is by using the ajaxSetup function.

According to the documentation, ajaxSetup sets default values for future Ajax requests. So in other words, every Ajax request made after ajaxSetup will obey the directives defined by it.

One of this directives happens to be called “cache”, and if set to “false”, will make sure every Ajax request has the current timestamp appended to the URL. You can simply add it to your code as such:

$(document).ready(function() {
   $.ajaxSetup({ cache: false });
   // put all your jQuery goodness in here.
 });

Now all of your requests will look like this:

http://my_server.com?123456789

There are also other settings that can be added inside ajaxSetup. They can be found on the jQuery.ajax() documentation, and all the settings listed in there will also work with ajaxSetup.
Hope this tip is useful to someone.