Now, I would certainly not advise you to not do unit testing, but to me it seems that there is a trade-off. Let’s look at an example. What about domain objects? When they are dumb (no business logic), it seems that there is little need to test all the getters and setters right? (Actually, these getters and setters are mostly waste as well and luckily there are programming languages in which this is a bit more transparent. Maybe I will write another post on encapsulation at some point…)

Well, then surely we unit test the view layer? Technically you can, but mostly it is a lot of work, because you have to mock around your view framework. A lot of things cannot easily be tested at all, like jsps for example. It seems that using Selenium or other automated test tools can do this far more efficiently. I have seen that the view layer generally has the lowest unit test coverage of all.

Now the only thing that is really left over is business logic. And there unit tests show their real value. It is easy to mock around all business logic you are not testing at that moment, because that dependent logic will likely just deliver a domain object for you.

Furthermore, business logic can have a lot of assumptions, and you must test what happens when these are not met. These unit tests are simple, relatively easy to maintain. The mock plumbing is likely manageable.

So what are unit tests? They are used to test small units of your code, to test for bugs. Well let’s just test the relevant parts of an application and not waste time. View layers and integration with other systems are likely better tested with integration tests or automated functional tests (like Selenium).

Now I want to ask you, what would my unit test code coverage be when applying the above? 30 percent? 50 percent maybe? I think for business logic it is good to have 100%. Regarding the rest, the effortt might be wasted! But then again, if everybody says these tests are needed, but I cannot see a lot of value in most of them, am I then missing something?

The increase of mobile devices and services makes a lot of companies and organizations wonder if they should just not be in the mobile space as well. Of course, I cannot decide if this is necessary for a company or not, but I do happen to have some ideas on how one can achieve a mobile presence for his company.

Nowadays you might jump up and say: “I know that: write an app!”. Now wait a minute here. There are still a lot of people around who do not have a smartphone. But you can still serve those people as well.

Plain old SMS might serve your goals very well. Let people submit data to you by sending an SMS to a certain number. Let them be notified with an SMS about important events. Let them request information by sending an SMS to you. Everybody with a mobile phone, how old it might be, can use these kind of services.

If you have rich content to share with your customers, you might want to consider a mobile website, to complement your desktop website. With a well-designed mobile website, you avoid being bound to a certain mobile platform (like Apple, Android, Blackberry). With a well-designed mobile website, you might just be able to serve your customers with everything they need.

The best user experience is actually achieved with native applications. These can take full advantages of the hardware capabilities and are designed specifically to the platform they run on, therefore providing premium look and feel.

A sort of in-between is a multi platform app solution, like PhoneGap. You will be able to use a lot of the hardware functions and generally achieve a better user interface (compared to a mobile website). Although real native applications look better, this can be a cheaper alternative.

Now that I have presented you a few ways to mobilize your business, which of them are you going to choose? One aspect is always money. If there is no money, there is no way you are going to get what you want. But there is also the aspect of maintenance of the chosen solution.

Native applications are very expensive to develop and to maintain. And when you have paid all the costs you only have an app on one platform (say iPhone). If you want to cover Android as well, you need to develop the app again with a different technology.
There is a way to avoid some of the costs; you can use multi platform solutions like PhoneGap. There you develop the app only once and you will be able to deploy to multiple devices.

A mobile website is a lot cheaper. It runs on every browser (provided that you account for the major browser versions, but that is quite doable).

A multi platform app or a website is cheaper, however a native app looks better and you will have support for all the hardware functions. You will have to balance the costs versus the features.

Keep in mind that when you have an app, you also need to maintain it. There will always be new versions of the operating systems of the iPhone, Android, Blackberry etc. and you must make sure that your app does not break in these newer versions. You must also make sure that there is a support channel for the users (support email address and special web page) where people can come to with questions about the app. Especially for a small company this can be a burden. A mobile website is then easier to maintain and support.

I hope you found this discussion useful and I wish you good luck implementing your own mobile strategy.

#import <Foundation/Foundation.h>

@interface YourTabBar : UITabBar {
}
@end



#import "YourTabBar.h"

@implementation YourTabBar

- (void)drawRect:(CGRect)rect
{
	[super drawRect:rect];
	UIImage *image = [UIImage imageNamed:@"tabbar-background.png"];
	[image drawInRect:rect];
}
@end

package ....

import android.os.Handler;
import ...

public class MyActivity extends Activity {

// The android.os.Handler can be used to execute tasks 
// in the thread where it has been initialized. 
private Handler handler;

[...]

public boolean onOptionsItemSelected(MenuItem item) {
	switch(item.getItemId()) {
	case 1:
		doHeavyTask();
		return true;
	} 
	return false;
}

/** {@inheritDoc} */
@Override
public void onCreate(Bundle savedInstanceState) {
...
// Create a new Handler that is being associated to the 
// main thread.
handler = new Handler();
...
}

private void doHeavyTask() {
	// Show a progress bar
	findViewById(R.id.Waiter).setVisibility(View.VISIBLE);
	new Thread(new Runnable() {
		public void run() {
			// Do heavy calculation
			[...]
			
			// Use the handler to execute a Runnable on the 
			// main thread in order to have access to the 
			// UI elements. 
			handler.postDelayed(new Runnable() {
				public void run() {
					// Update UI
					((TextView)findViewById(R.id.text))
						.setText("calculation finished");
					// Hide the progress bar
					findViewById(R.id.Waiter)
						.setVisibility(View.INVISIBLE);
				}
			}, 0);
		}
	}).start();
}

}

This Activity contains a progress bar (rotating spinner) and some text field. The text needs to be updated when a heavy calculation has been finished. The UI will still be responsive. A rotating spinner is also shown and hidden again after the calculation finished.
The postDelayed() method on the Handler ensures that you can do another task on the thread where the Handler has been initialized. This can be used to post results of your calculation back to the main thread.

So, is there any fundamental difference between iPhone and Android? Maybe at first glance not really. Both platforms offer communication services (phone, sms, email), internet and a market or app store, where users can find applications they need.

However, when looking more closely, one may conclude that the iPhone is really a Swiss army knife. A device loaded with utilities that help you online or offline with multiple tasks. For example, I manage my agenda, email and twitter with it. But I also grab it to use the calculator, I have a metronome on it, a unit converter, games, ebooks, all my relevant music, etc. Occasionally I even watch a movie with it. I must admit that the iPod touch I own really has become an almost indispensable thing in my life.

But what about the Android? I have also used an Android for a while. To me, Android does not provide me with such an extensive toolbox. The Android market has only a fraction of the number of apps available in Apple’s App Store. But, something the Android aims at (in my opinion) is Information. The disclosure of information (preferably from online sources) is to me the main focus of the Android platform. It shows off from the home screen right away with the search box. This search box will not only do a Google search, it will also connect with all apps on the device that support this to fetch information about the keywords.

So, Android is about information. The iPhone does not have such an integrated search option. The iPhone however provides a lot of utilities to the user to help him with his daily life. Here I spot a basic difference in the two platforms, which I think is worthwhile to consider when you plan to buy a smartphone.

How does this compare to the other platforms available? Unfortunately I do not have hands on experience with them. However, I still think I can say something about them.

Blackberry is a platform that seems to be targeted to business people. It is all about managing agendas, mail, etc. It is not so much meant to access a lot of information or to provide a lot of tools to the user.

The new Windows Phone is primarily targeted to social media, at least I think I can infer that from the media event in January. Sure there is Bing, there is the XBox live connection, but the home screen shows primarily your friends, how you can contact them, what their statuses are on the different social media platforms. The XBox live feature seems to be more about your avatar and connections with other players online.

To summarize (while probably doing a lot of injustice to the platforms):
iPhone: Swiss army knife
Android: Find me information about everything
Blackberry: Manage my business
Windows Phone: Keep in touch with my contacts

I think it is very wise that, if someone wants to expose some services or utilities or games or whatever via the mobile platforms, he should be aware of the differences between the platforms. Because the differences I have highlighted here, will be reflected in how users use their phones.

I must admit that I am quite a fan of the products that are made by Apple. So I was quite excited when the event finally arrived. Steve’s presentation completely blew me away at that moment.

Next morning I started to think everything over and I actually realized what the iPad did not have. It has been mentioned quite a bit on the web: no flash, no multitasking, closed system, etc. At that point I grew disappointed with the device as well. Is this everything? Could Apple not do more than this?

But let us see if everything really iz that bad. All these so-called missing ‘open doors’, are they really important? After all, the hype had risen to enormous heights. People were making the wildest guesses. Let me review a few of the complaints.

A very serious problem in the minds of people is the lack of multitasking. People think they are severely hampered in their productivity when they are.not able to grab something from the web or to listen to some music while they Are working on some document, presentation or something else. However, I would like to question the necessity for this. Most of the time while you are working with some application, I would argue that you need only a few secondary apps. Probably the browser, a music player, and maybe a dictionary, but most of your needs would be covered.

Well, even the iPhone allows you already to listen to your music library while doing something else. And how many windows are you planning to put next to each other on a 10 inch screen? In.my opinion it is all about how quickly can you change between apps. Now, just like the iPhone, thw iPad has a dock where you can put your most used secondary apps in. You can switch apps by pressing the home button and the app icon when you go back to your main app, you do the same thing. One button and one touch, that does not sound more invasive than the use of option-tab on your mac.
However, this will only work when apps launch fast and when they will bring you back right where you left of. If these two conditions are not met, this will not work. This leaves a responsibility on developers to preserve those two conditions.

I wonder if the closed retail system of Apple is a real problem either. After all, there are so many apps out there, that are immediately useable on the iPad that there is not much need for an open system. People can just download what they need, and what’s more, apps downloaded on their iPhones don’t need to be bought again. ‘Techies’ might complain that they cannot do with the device what they like, but all other people will probably not care. And one might add that the iPad will probably undergo jailbreaks as well.

A few other issues are not so convenient for the end user, as the lack of flash (how buggy or detestable it may be to some people, it is still much used) or the difficulty in sharing files with other devices. Still, for browsing, light office work, quick email, reading, watching movies on the go, digital photo frame, etc. it is a useful device. I think Apple might indeed fill a gap in a lot of households. The inconveniences might be fixed in later releases as well.

And what will the future bring? The first iPhone version was not very well received either and ‘could never work’. The same counts for the App Store. Still, nowadays both are highly successful and will keep being successful for the coming time. Who knows where the iPad may evolve to…

The Android platform gets its location data from two sources. I think the best known source is the GPS that is built in the device. It will give you an accuracy up to a few meters under good conditions. However, it can take quite some time for a device to get a GPS fix from the satelites. Therefore it is worthwhile to look at a second source of location input. Android devices can also get their location from the cell towers of the mobile network. This is a very coarse estimate with an accuracy that can be a few hundred meters. However, the result is available almost instantly.

To accomodate for the differences of the two methods, I used a solution as the one shown below. First it will fetch the last known position of the GPS service, to make sure that there will be some location to use. Then it will register two LocationListeners to fetch an updated position fix.

The network (coarse accuracy) will deliver quick results and I will unregister this listener again when the accuracy is smaller than 1000 meters. (By the way, I was displaying distances rounded to 100 meters). Then a second listener will ask for updates from the GPS unit, and will unregister with an accuracy below 50 meters.

In this way I make sure that I get a position fix as quickly as possible, although with low accuracy, whereas in the meanwhile I try to get a better fix by the GPS unit. Even when the device cannot get a GPS fix, I will always be able to at least give a crude estimate on the position of the user.

The (stripped) code follows here.

public class Main extends Activity {

	private LocationManager locationManager;
	private LocationListener listenerCoarse;
	private LocationListener listenerFine;
	
	// Holds the most up to date location. 
	private Location currentLocation;
	
	// Set to false when location services are 
	// unavailable. 
	private boolean locationAvailable = true;

		
	/** {@inheritDoc} */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		setContentView(R.layout.main);
		super.onCreate(savedInstanceState);
		registerLocationListeners();
		...
		...
	}

	private void registerLocationListeners() {
		locationManager = (LocationManager) 
			getSystemService(LOCATION_SERVICE);
		
		// Initialize criteria for location providers
		Criteria fine = new Criteria();
		fine.setAccuracy(Criteria.ACCURACY_FINE);
		Criteria coarse = new Criteria();
		coarse.setAccuracy(Criteria.ACCURACY_COARSE);
		
		// Get at least something from the device,
		// could be very inaccurate though
		currentLocation = locationManager.getLastKnownLocation(
			locationManager.getBestProvider(fine, true));
		
		if (listenerFine == null || listenerCoarse == null)
			createLocationListeners();
			
		// Will keep updating about every 500 ms until 
		// accuracy is about 1000 meters to get quick fix.
		locationManager.requestLocationUpdates(
			locationManager.getBestProvider(coarse, true), 
			500, 1000, listenerCoarse);
		// Will keep updating about every 500 ms until 
		// accuracy is about 50 meters to get accurate fix.
		locationManager.requestLocationUpdates(
			locationManager.getBestProvider(fine, true), 
			500, 50, listenerFine);
	}

	/**
	* 	Creates LocationListeners
	*/
	private void createLocationListeners() {
		listenerCoarse = new LocationListener() {
			public void onStatusChanged(String provider, 
				int status, Bundle extras) {
				switch(status) {
				case LocationProvider.OUT_OF_SERVICE:
				case LocationProvider.TEMPORARILY_UNAVAILABLE:
					locationAvailable = false;
					break;
				case LocationProvider.AVAILABLE:
					locationAvailable = true;
				}
			}
			public void onProviderEnabled(String provider) {
			}
			public void onProviderDisabled(String provider) {
			}
			public void onLocationChanged(Location location) {
				currentLocation = location;
				if (location.getAccuracy() > 1000 && 
					location.hasAccuracy())
					locationManager.removeUpdates(this);
			}
		};
		listenerFine = new LocationListener() {
			public void onStatusChanged(String provider, 
				int status, Bundle extras) {
				switch(status) {
				case LocationProvider.OUT_OF_SERVICE:
				case LocationProvider.TEMPORARILY_UNAVAILABLE:
					locationAvailable = false;
					break;
				case LocationProvider.AVAILABLE:
					locationAvailable = true;
				}
			}
			public void onProviderEnabled(String provider) {
			}
			public void onProviderDisabled(String provider) {
			}
			public void onLocationChanged(Location location) {
				currentLocation = location;
				if (location.getAccuracy() > 1000 
					&& location.hasAccuracy())
					locationManager.removeUpdates(this);
			}
		};
	}
	
	...
	...
    
	/** {@inheritDoc} */
	@Override
	protected void onResume() {
		// Make sure that when the activity has been 
		// suspended to background, 
		// the device starts getting locations again
		registerLocationListeners();
		super.onResume();
	}
	
	...
	...
	    
	@Override
	protected void onPause() {
		// Make sure that when the activity goes to 
		// background, the device stops getting locations
		// to save battery life.
		locationManager.removeUpdates(listenerCoarse);
		locationManager.removeUpdates(listenerFine);
		super.onPause();
	}	
}

The activity will create and register the necessary listeners. The onPause() method will actually unregister the location listeners again to avoid that the application keeps updating its location, even when moved to the background. This will help saving battery life. On Android, you cannot really close an application (unless you kill it with an app killer application). Therefore you need to stop fetching locations yourself when it is no longer needed.

The onResume() method will start listening again when the activity becomes active again. This will ensure that the user gets an updated location when he has moved in the meantime. Because returning to the home screen on Android means that the application might still be running, the location could be very outdated. Therefore I added this onResume() method.

Working in this area means that one has to brush of his trigonometry skills. But luckily there are some good resources on the web, that explain the theory perfectly. The formula you need is the haversine formula, which gets its name from the use of the haversine function:
.

The haversine formula is:

earth’s radius (mean radius = 6367.45 km)

Here the distance in kilometers will be calculated based on the latitudes and longitudes of the two points on the earth, expressed in radians. To convert from degrees to radians, simply multiply the value in degrees by . The function is a function implemented in many computer languages and is a variation on the arctangent function.

The error of this formula in calculating distances is about 0.1% and mostly due to the fact that the Earth is not a perfect sphere (see the resources below for a more in-depth discussion). Also numerical rounding errors can occur, but this is mainly an issue when the two locations are very nearly antipodal (on opposite sites of the Earth), which is generally not something you will use very often.

But enough now of the theoretics, I will show how to put this to a practical use. The code to calculate the distance between two points can be expressed in Java code as:

double EARTH_RADIUS = 6367.45;

double latitude;
double longitude;

double lat2;
double lon2;

double deltalat = lat2 - latitude;
double deltalon = lon2 - longitude;

double a = Math.sin(deltalat / 2) * Math.sin(deltalat / 2) + Math.cos(latitude) * Math.cos(lat2) * Math.sin(deltalon / 2) * Math.sin(deltalon / 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
double distance = EARTH_RADIUS*c;

One thing you need to make sure, is that the latitude and longitude are expressed in radians (see above).
Put this code into a method and you are done.

This post is based on a few web resources, that will give a bit more information on distance calculations. There is a nice wikipedia article on the Haversine formula. Here and here you can find a bit more information on calculating distances on a sphere.

Native apps are applications that are developed for a specific platform. They will only run on that platform, but will have the possibility to use all the platforms specific functionalities. Let’s look as an example to the iPhone platform. Apps can be designed and developed specifically for the iPhone. The user experience of these apps is very good. Transitions between pages are smooth and the layout is generally compliant with the Apple standards. However, nothing of the development effort can be reused for other platforms. Apps like these are nowadays generally available via so-called ‘App Stores’, where users can download or buy applications.

Cross platform solutions are solutions that try to mend the reusability problem. Solutions are a mobile website of a solution as widgets (I have written about those earlier). These solutions will be usable across multiple platforms, without extra or with minimum development effort. Other cross platform solutions try to bridge the two possibilities, by giving the developer a way to design an application and then bundle this for multiple platforms in different applications that can be sold in the respective app stores. The primary example of this is PhoneGap.

So, what are the benefits of the native apps over the cross platform solutions and vice versa? Generally speaking, one can say that native apps best utilize the specific functions of the device and integrate natively with the OS. However, to maintain native apps for multiple platforms is quite expensive and laborious. It requires sufficient technical skills on every platform as well. I do development for iPhone and Android, and can therefore say from experience that maintenance of multiple apps can be quite a pain. Especially since one also need to support multiple versions of each platform (like iPhone OS 2.x and 3.x and Android 1.5, 1.6 and 2). It is clear that cross platform solutions are much cheaper and better maintainable (although it is probably still necessary to test on a lot of different devices).

Let us now revisit the question what businesses should do when starting out in the mobile market. I think that for very small companies a cross platform solution is best, since native development is too expensive. However, for larger companies I think that it is best too target one or two major native platforms as well. The users of those devices are used to high quality applications and will not easily accept medium quality apps. Development for one or two widespread platforms (that are, based on current insights, future proof as well) will not be too expensive, since a lot can be done with one or two good developers and will result in best user experience. It is best to chose platforms where users are used to high standards.

On a side note, I have heard some people doubting the future proofness of the App Store, and more specifically of the iPhone. I think that for the coming years Apple will still gain more and more market share with the iPhone and thereby with the App Store. I think that iPhone users will not care very much about mobile websites (since mobile Safari is quite good) and also not about widgets (since there are more then 100.000 apps in the store). On the contrary, they are expecting an app for everything in the store. I think it is wise to target the biggest app stores, until the future will tell us more about how the mobile landscape is about to evolve.

First you will need a background drawable. Create the file screen_background.xml in your drawables directory and put in the following content.

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle" android:padding="10dp">
	<solid android:color="#FFFFFF"/>
    <corners android:bottomRightRadius="30dp" android:bottomLeftRadius="30dp"
android:topLeftRadius="30dp" android:topRightRadius="30dp"/>
</shape>

Now use this background in your layout file. First create a LinearLayout and set the background color to be the color of the border. Then use your newly created background in a subview. Apply paddings to adjust the thickness of the border. Here is a basic example.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout android:id="@+id/LinearLayout01"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent"
	android:background="#0000FF"
	android:padding="10dp"
	xmlns:android="http://schemas.android.com/apk/res/android">
	<RelativeLayout android:id="@+id/RelativeLayout01"
			android:layout_width="fill_parent"
			android:layout_height="fill_parent"
			android:padding="10dp"
			android:background="@drawable/screen_background">
	</RelativeLayout>
</LinearLayout>

This example will result in a white screen with a blue border and rounded edges of the white area. Good luck.