*Let me assured you that even though the directions bellow seems complicated and clumsy at first, after doing them once or twice it is really easy to repeat them.

Motivation
The default action of Clover is to gather code coverage information during build time or compile time. Therefore, This information includes just the coverage data created by unit tests.

If you are developing web applications, you probably use more technologies to test your applications beside unit tests. These technologies may include HTTPUnit/HTMLUnit or automation technologies (like Selenium). These technologies do not work at build time, they can only work during run time, where a web server is up and running and HTTP calls are made.
As a result, the code coverage made during build time is not reflecting the actual code coverage. We should be able to test the coverage while a server is running.

The idea
The idea is that we will first run clover regularly during build time. We will than take the clover artifacts, put them in our server and then run the integration tests.
While running the integration tests, the clover database will be updated and we would be able to generate reports from it which will reflect both unit and integration tests.

Step 1 – Preparation

• Make sure that you have a web/application server (Tomcat/JBoss/weblogic…) with your web application already deployed.
• Execute clover on your application as you would normally do (either by compiling the code on eclipse or by building with Maven or Ant, it doesn’t matter).
  
  The result of this action would be:
  1. Clover DB files.
     One of the outcome of executing the clover on your code are the DB files.
     The DB files hold all the information about your code and the coverage itself.

     The location of those files may change depending on the way you use clover and according to the way you configured clover in your environment.

     This is how the files looks like
     

     

     the .db file holds the information regarding your code (classes, methods and so on). All the other files hold all the coverage data.

     It is important that you will locate those files because we are going to use them in the next step.

  2. An instrumented code.
     Another outcome of clover is that it instruments your code. A clover call is injected into each method so it would be reported in the coverage calculation.
     We will need this code. we will use this instrumented code in runtime to update the coverage data.

     If you use Eclipse than the generated classes would be instrumented. If you use Maven or Ant than most chances are that a jar with all the instrumented code would be generated separately.
     Search the instrument code jar. Again, I can’t tell you exactly where it is located, but usually it generates a jar with a ‘clover’ postfix. Example: if your jar name is my_app.jar, than the generated instrumented code jar will probably be something like my_app-clover.jar.
     So you will need to do some detective work here to find the instrumented classes/jar. If you are not sure whether the classes are instrumented or not, just decompile one of them with Jad and search for the word clover inside of it.

  3. A code coverage report.
     This is a report with the unit test coverage. We don’t really need this, but it would be good so that we would be able to compare it with the report we will generate at the end.

Step 2 – Updating the server
The next steps are very important, please make sure you do them properly.

• Replacing the existing application jar/classes with the instrumented jar/classes.
  Take the instrumented jar/classes that were created by the clover and add it to your server’s classpath instead of the original jar/classes.
  The instrumented code will cause the clover DB to be updated with the runtime data.




• Adding clover jars and license.
  Since we will use clover on runtime we will need also the clover jars in our server’s classpath.
  So add the clover own jars to your server’s classpath. If you are using clover with Eclipse than these jars are located in the plugin folder of Eclipse. If you are using Maven than they will be loacted in your repository.

  * Make sure you are using the same version of clover in your server as you used to generate the DB files and instrumented code, otherwise it will not work and you will get error messages.
  Also add the clover license file to the same location as the jars.




• Adding the clover java argument.
  Add the following java arg -Dclover.initstring.basedir={location of the db files that were created by the clover}.
  *Notice – the path you have entered above is the path of the folder which contains the DB files.
  Example:
  -Dclover.initstring.basedir=C:/workspace/MyWebApp/target/clover.
  This java argument is used by the clover to locate the DB files and update them.

Step 3 – Restarting the server and running the tests
Now that hopefully all is set properly all that you need to do now is to restart your server and than running your integration tests.
The tests should trigger the instrumented code which will call the clover API’s and will update the clover DB.

While running the tests:
1. Look at your log/console and search for error messages from clover.
2. Look at the folder which holds the clover DB files. If everything is going as it should, new files will be created in this folder while running the tests.

If not everything is going well the first time, don’t discourage, just go over each of the steps again.

Step 4 – Generating an updated report
If everything went well and new files were created in the DB folder than that means you just need to generate a new report.
If you are using clover with eclipse than you can simply push the reload button to reload the coverage data.
If you are using Maven or Ant you can execute just the task which generates the report.
Another way is to use the clover HtmlReporter to generate a report easily.

Now compare the new report to the old report. You should see that the new report coverage is much bigger than the old one since it contains also the integration tests coverage.

*Notice that not all the data is updated, even though the percentages are being updated, for some reason the calls counter does not.

To summarize. As mentioned; yes, these instructions seems a bit complicated but after you succeed the first time, it is very easy to repeat it. In the company I work for we even made this whole process automatic and we are able to generate a full coverage report with unit and integrated tests combined.

To create a customized animation you need to follow these 3 steps.
For the explanation, we will create a simple animation that changes the background of a button gradually from black to red.

Step 1 – Extend the Animation class and set the properties
Create a class which extends Android Animation class.
This class will hold the logic of your animation.
See my example:

public class BGColorAnimation extends Animation {

	private View view;
	private int currentRedColor;

	//The steps to skip between colors
	private static int STEP_SIZE=30;
	private static int ANIMATION_DURATION=50;

	public BGColorAnimation(View view) {
		this.view=view;
		setDuration(ANIMATION_DURATION);
		setRepeatCount(255/STEP_SIZE);
		setFillAfter(true);
		setInterpolator(new AccelerateInterpolator());

		setAnimationListener(new MyAnimationListener());
	}
}

• As you see, there is not much in this class since my animation is not that complicated.
• Notice that I have made all the necessary animation parameters initialization from inside the constructor, but you can defiantly initialize them from outside the class.
• There are 2 important parameters which determines the behavior of the animation:
  1. RepeatCount – the number of steps this animation has.
  2. Duration – the sleep time between 2 steps.
• On each step, the animation listener will be triggered.

Step 2 – Implement AnimationListener interface
Create a class which implements Animation.AnimationListener.
As mentioned, it is triggered on each animation step.

class MyNumbersAnimationListener implements AnimationListener{
	    	private int index;

	    	class MyAnimationListener implements AnimationListener{

		@Override
		public void onAnimationEnd(Animation animation) {

		}

		@Override
		public void onAnimationRepeat(Animation animation) {
			// Change color of the view
			view.setBackgroundColor(
				Color.rgb(currentRedColor+=STEP_SIZE, 0, 0));
		}

		@Override
		public void onAnimationStart(Animation animation) {
			view.setBackgroundColor(Color.BLACK);
			currentRedColor=0;
		}

	}

In fact, I see no reason why not doing both steps in the same class:

public class BGColorAnimation extends Animation implements
		Animation.AnimationListener {

	private View view;
	private int currentRedColor;

	// The steps to skip between colors
	private static int STEP_SIZE= 30;
	private static int ANIMATION_DURATION = 50;

	public BGColorAnimation(View view) {
		this.view = view;
		setDuration(ANIMATION_DURATION);
		setRepeatCount(255 / STEP_SIZE);
		setFillAfter(true);
		setInterpolator(new AccelerateInterpolator());

		setAnimationListener(this);
	}

	@Override
	public void onAnimationEnd(Animation animation) {

	}

	@Override
	public void onAnimationRepeat(Animation animation) {
		view.setBackgroundColor(
			Color.rgb(currentRedColor += STEP_SIZE, 0, 0));
	}

	@Override
	public void onAnimationStart(Animation animation) {
		view.setBackgroundColor(Color.BLACK);
		currentRedColor = 0;
	}

}

Step 3 – Start the animation from a view
Animations are triggered from a view.
Example:

Button button = (Button)findViewById(R.id.b_colors);
button.setOnClickListener(new OnClickListener() {

				@Override
				public void onClick(View v) {
					button.startAnimation(new BGColorAnimation(button));
				}
			});

Download demo project

To answer these questions I have made a simple test and ran it as a java program on my PC and than as an Android activity.

Here is the test for the PC:

 private static final int SIZE_OF_ARRAY = 10000000;
	private static long time;

	public static void main(String[] args) {

		        Integer [] sourceArray = new Integer[SIZE_OF_ARRAY];
		        Integer [] destinationArray = new Integer[SIZE_OF_ARRAY];
		        fillArray(sourceArray);

		        startBenchmark();
		        naiveCopy(sourceArray,destinationArray);
		        stopBenchmark();

		        startBenchmark();
		        System.arraycopy(sourceArray, 0, destinationArray, 0,
						  sourceArray.length);
		        stopBenchmark();
		    }

			private static void naiveCopy(Integer [] src, Integer [] dst) {
				for (int i = 0; i < src.length; i++) {
					dst[i]=src[i];
				}

			}

			private static void fillArray(Integer [] src) {
				for (int i = 0; i < src.length; i++) {
					src[i]=i;
				}

			}

			private static void startBenchmark() {
				time = System.currentTimeMillis();
			}

			private static void stopBenchmark() {
				time = System.currentTimeMillis() - time;
				System.out.println( "time="+time);

			}

Here are the results while running it from my PC (java 7, 8GB memory, CPU intel i5):
Naive algorithm – 14 ms
System.arraycopy(); – 6 ms.

Arraycopy does the task in less than half of the time.

Now to use it on Android – here is the code:

public class ArrayCopyTestActivity extends Activity {
    private static final int SIZE_OF_ARRAY = 1000000;
	private long time;

	/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Integer [] sourceArray = new Integer[SIZE_OF_ARRAY];
        Integer [] dst = new Integer[SIZE_OF_ARRAY];
        fillArray(sourceArray);

        startBenchmark();
        naiveCopy(sourceArray,dst);
        stopBenchmark();

        startBenchmark();
        System.arraycopy(sourceArray, 0, dst, 0, sourceArray.length);
        stopBenchmark();
    }

	private void naiveCopy(Integer [] src, Integer [] dst) {
		for (int i = 0; i < src.length; i++) {
			dst[i]=src[i];
		}

	}

	private void fillArray(Integer [] src) {
		for (int i = 0; i < src.length; i++) {
			src[i]=i;
		}

	}

	private void startBenchmark() {
		time = System.currentTimeMillis();
	}

	private void stopBenchmark() {
		time = System.currentTimeMillis() - time;
		Log.d("array copy test", "time="+time);

	}
}

* Notice I have reduced the size of the Array from 10 million to 1 million, this is due to restrictions on memory for applications in Android.

The results from running it on my device (nexus 1):
Naive algorithm – 182 ms
System.arraycopy(); – 12 ms.

This means that the fact that System.arraycopy() is better than the regular copy is even more true for Android.
In short than, always use System.arraycopy() especially on Android.

Test for PC
Test for Android

Simple Example

@Test
public void testGoogle(){
	WebClient webClient = new WebClient();
	HtmlPage currentPage = webClient.getPage("http://www.google.com/");
	assertEquals("Google", currentPage.getTitleText());
}

WebClient

• As you can see in the example, the WebClient is the starting point. It is the browser simulator.
• WebClient.getPage() is just like typing an address in the browser. It returns an HtmlPage object.

HtmlPage

• HtmlPage represents a single web page along with all of it’s client’s data (HTML, JavaScript, CSS …).
• The HtmlPage lets you access to many of a web page content:

Page source

• You can receive the page source as text or as XML.

HtmlPage currentPage =
		webClient.getPage("http://www.google.com/");
String textSource = currentPage.asText();
String xmlSource = currentPage.asXml();

HTML Elements

• HtmlPage lets you ability to access any of the page HTML elements and all of their attributes and sub elements. This includes tables, images, input fields, divs or any other Html element you may imagine.
• Use the function getHtmlElementById() to get any of the page elements.

WebClient webClient = new WebClient();
HtmlPage currentPage = webClient.getPage("http://www.google.com/");
HtmlImage imgElement = (HtmlImage)currentPage.getHtmlElementById("logo");
System.out.println(imgElement.getAttribute("src"));

Anchors

• Anchor is the representation of the Html tag <a href=”…” >link</a>.
• Use the functions getAnchorByName(), getAnchorByHref() and getAnchorByText() to easily access any of the anchors in the page.

WebClient webClient = new WebClient();
HtmlPage currentPage = webClient.getPage("http://www.google.com/");
HtmlAnchor advancedSearchAn =
		currentPage.getAnchorByText("Advanced Search");
currentPage = advancedSearchAn.click();
assertEquals("Google Advanced Search",currentPage.getTitleText());

Dom elements by XPath

• You can access any of the page elements by using XPath.

WebClient webClient = new WebClient();
HtmlPage currentPage =
	webClient.getPage("http://www.google.com/search?q=avi");

//Using XPath to get the first result in Google query
HtmlElement element = (HtmlElement)currentPage.getByXPath("//h3").get(0);
DomNode result = element.getChildNodes().get(0);

Form control

• A large part of controlling your HTML page is to control the form elements:
  • HtmlForm
  • HtmlTextInput
  • HtmlSubmitInput
  • HtmlCheckBoxInput
  • HtmlHiddenInput
  • HtmlPasswordInput
  • HtmlRadioButtonInput
  • HtmlFileInput

WebClient webClient = new WebClient();
HtmlPage currentPage = webClient.getPage("http://www.google.com/");

//Get the query input text
HtmlInput queryInput = currentPage.getElementByName("q");
queryInput.setValueAttribute("aviyehuda");

//Submit the form by pressing the submit button
HtmlSubmitInput submitBtn = currentPage.getElementByName("btnG");
currentPage = submitBtn.click();

Tables

currentPage = webClient.getPage("http://www.google.com/search?q=htmlunit");
final HtmlTable table = currentPage.getHtmlElementById("nav");
for (final HtmlTableRow row : table.getRows()) {
System.out.println("Found row");
    for (final HtmlTableCell cell : row.getCells()) {
       System.out.println("   Found cell: " + cell.asText());
    }
}

JavaScript support

• HtmlUnit uses the Mozilla Rhino JavaScript engine.
• This lets you the ability to run pages with JavaScript or even run JavaScript code by command.

ScriptResult result = currentPage.executeJavaScript(JavaScriptCode);

• By default JavaScript exceptions will crash your tests. If you wish to ignore JavaScript exceptions use this:

webClient().setThrowExceptionOnScriptError(false);

• If you would like to turn off the JavaScript all together, use this:

currentPage.getWebClient().setJavaScriptEnabled(false);

HTTP elements

URL

WebClient webClient = new WebClient();
HtmlPage currentPage =
	webClient.getPage("http://www.google.co.uk/search?q=htmlunit");
URL url = currentPage.getWebResponse().getRequestSettings().getUrl()

Response status

WebClient webClient = new WebClient();
HtmlPage currentPage = webClient.getPage("http://www.google.com/");
assertEquals(200,currentPage.getWebResponse().getStatusCode());
assertEquals("OK",currentPage.getWebResponse().getStatusMessage());

Cookies

Set<Cookie> cookies = webClient.getCookieManager().getCookies();
for (Cookie cookie : cookies) {
	System.out.println(cookie.getName() + " = " + cookie.getValue());
}

Response headers

WebClient webClient = new WebClient();
HtmlPage currentPage =
	webClient.getPage("http://www.google.com/search?q=htmlunit");

List<NameValuePair> headers =
	currentPage.getWebResponse().getResponseHeaders();
for (NameValuePair header : headers) {
	System.out.println(header.getName() + " = " + header.getValue());
}

Request parameters

List<NameValuePair> parameters =
	currentPage.getWebResponse().getRequestSettings().getRequestParameters();
for (NameValuePair parameter : parameters) {
	System.out.println(parameter.getName() + " = " + parameter.getValue());
}

Making assertions

• HtmlUnit comes with a set of assetions:

   assertTitleEquals(HtmlPage, String)
   assertTitleContains(HtmlPage, String)
   assertTitleMatches(HtmlPage, String)
   assertElementPresent(HtmlPage, String)
   assertElementPresentByXPath(HtmlPage, String)
   assertElementNotPresent(HtmlPage, String)
   assertElementNotPresentByXPath(HtmlPage, String)
   assertTextPresent(HtmlPage, String)
   assertTextPresentInElement(HtmlPage, String, String)
   assertTextNotPresent(HtmlPage, String)
   assertTextNotPresentInElement(HtmlPage, String, String)
   assertLinkPresent(HtmlPage, String)
   assertLinkNotPresent(HtmlPage, String)
   assertLinkPresentWithText(HtmlPage, String)
   assertLinkNotPresentWithText(HtmlPage, String)
   assertFormPresent(HtmlPage, String)
   assertFormNotPresent(HtmlPage, String)
   assertInputPresent(HtmlPage, String)
   assertInputNotPresent(HtmlPage, String)
   assertInputContainsValue(HtmlPage, String, String)
   assertInputDoesNotContainValue(HtmlPage, String, String)

• You can still of course use the framework’s assertions. For example, if you are using JUnit, you can still use assertTrue() and so on.
• Here are a few examples:

WebClient webClient = new WebClient();
HtmlPage currentPage =
      webClient.getPage("http://www.google.com/search?q=htmlunit");

assertEquals(200,currentPage.getWebResponse().getStatusCode());
assertEquals("OK",currentPage.getWebResponse().getStatusMessage());
WebAssert.assertTextPresent(currentPage, "htmlunit");
WebAssert.assertTitleContains(currentPage, "htmlunit");
WebAssert.assertLinkPresentWithText(currentPage, "Advanced search");
assertTrue(currentPage.getByXPath("//h3").size()>0); //result number
assertNotNull(webClient.getCookieManager().getCookie("NID"));

See also

• Product main page
• Download page
• Jar dependencies

 Download example

Android designers have developed a framework to make the developers life a lot easier.
Preference Framework is a framework composed of a hierarchy of preference objects which are translated to UI objects.
This mechanism is built on top of the shared preferences mechanism which stores the values.

Shared Preferences Mechanism
Before we can explain how to build a settings page with the preferences framework we need to get to know the shared preferences mechanism.
Shared Preferences is a simple key-value storage mechanism of primitive types and Strings.
These values are stored even if the program is terminated.
Use it to store simple variables you wish to save between sessions of the program.

public class MyActivity extends Activity {
     @Override
    protected void onCreate(Bundle state){
       super.onCreate(state);

// Restore preferences
       SharedPreferences settings = getSharedPreferences(“MyParams”, 0);  // zero is the default
       boolean booleanParam = settings.getBoolean("booleanParam", false); //false is the defaulr
    }

    @Override
    protected void onStop(){
       super.onStop();

	// Change preferences
      SharedPreferences settings = getSharedPreferences(“MyParams”, 0);
      SharedPreferences.Editor editor = settings.edit();
      editor.putBoolean("booleanParam", true);

	// Save changes
	 editor.commit();        

         }
}

Preferences Framework
As mentioned, the preference framework is a framework which is built on top of the shared preferences mechanism.
But opposed to what you have seen above, in this case you don’t even have to save and load the data every time, the OS does that for you.
Furthermore, this framework offers UI objects that hold persistent preferences.

Types of preferences objects

• CheckBoxPreference – displays a checkbox and stores boolean values
• EditTextPreference – displays a edit text box and stores string values
• ListPreference – displays a drop down list.
• RingtonePreference – displays a list of existing ringtones in the system.

Step 1 – Creating XML preferences menu
First we will create the XML file which represents our settings page.

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:title="Settings">
	<PreferenceCategory android:title="First Category">
		<CheckBoxPreference android:key="MyBoolean"
			android:title="Boolean Value"></CheckBoxPreference>
		<EditTextPreference android:key="MyText"
			android:title="String Value"
			android:dialogTitle="Edit this text"
			android:dependency="MyBoolean"></EditTextPreference>
	</PreferenceCategory>

	<PreferenceCategory android:title="Seconed Category">
		<RingtonePreference android:showDefault="true"
			android:key="Audio" android:title="Select sound"
			android:ringtoneType="notification">
		</RingtonePreference>
		<ListPreference android:title="Group Choice Test "
			android:entries="@array/PreferencesGroupItems"
			android:entryValues="@array/PreferencesGroupValues"
			android:dialogTitle="Choose an option please">
		</ListPreference>
	</PreferenceCategory>
</PreferenceScreen>

*Notice:

• You can create categories to divide the preferences to groups according to the context. Here we have created 2 categories.
• ListPreference requires 2 arrays, one for the values and one for the labels. Both are taken from values/strings.xml.
• You can create dependency between prefrences by using the dependency field. For example, I have made the text field depended on the checkbox, which means, it will be disabled if the checkbox is not checked.
• Put this xml file under /res/xml/my_prefrences.xml

Step 2 – Extending the PrefrencesActivity

public class PreferencesActivity extends PreferenceActivity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		addPreferencesFromResource(R.xml.my_prefrences);
	}

}

• As you see, all this activity does is to load the preferences xml file.

Step 3 – Calling the PrefrencesActivity
Now we will create a button in our main activity that will trigger the preferences activity.

 @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        ((Button)findViewById(R.id.Button01))
		.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Intent settingsActivity = new Intent(getBaseContext(),
                        PreferencesActivityTest.class);
				startActivity(settingsActivity);

			}
		});
    }

Step 4 – Using the preferences
We can now use the preferences values anywhere in our main Activity.

SharedPreferences preferences =
			 PreferenceManager.getDefaultSharedPreferences(this);

String myText =	preferences.getString("MyText", "default value");
boolean MyBoolean = preferences.getBoolean("MyBoolean", false);

Download demo project

*Note: the examples bellow may not always work in the emulator.

Web address:

TextView myWebSite = new TextView(this);
myWebSite .setText("http://http://www.dzone.com/");
Linkify.addLinks(myWebSite , Linkify.WEB_URLS);

Phone number:

TextView myPhone = (TextView) findViewById(R.id.my_web_site);
myPhone .setText(“5552323233”);
Linkify.addLinks(myPhone  , Linkify.PHONE_NUMBERS);

TextView myLocation = new TextView(this);
myLocation.setText("436 Mayfield Ave, Stanford, CA");
Linkify.addLinks(myLocation , Linkify.MAP_ADDRESSES);
mainLayout.addView(myLocation);

Email address:

TextView myEmail= (TextView) findViewById(R.id.my_web_site);
myEmail.setText(“aviyehuda@gmail.com”);
Linkify.addLinks(myEmail  , Linkify.EMAIL_ADDRESSES);

Linkify.addLinks(myTextView , Linkify.ALL);

More than one option:
You can choose more than a single option for the link type.

Linkify.addLinks(myTextView, Linkify.PHONE_NUMBERS | Linkify.WEB_URLS);

Using pattern:
You can use a regular expression for detecting text parts and transform only them to links instead of the whole text.

 TextView myCustomLink = new TextView(this);
Pattern pattern = Pattern.compile("[a-zA-Z]+&");
myCustomLink.setText("press Linkify& or on Android& to search it on google");
Linkify.addLinks(myCustomLink,pattern, "http://www.google.ie/search?q=");
mainLayout.addView(myCustomLink);

MatchFilter:
MatchFilter is used for more complicated filters.

MatchFilter myMatchFilter = new MatchFilter() {
	@Override
	public boolean acceptMatch(CharSequence cs, int start, int end) {
		return start > 48;
	}
};

TextView myCustomLink2 = new TextView(this);
Pattern pattern2 = Pattern.compile("[a-zA-Z]+");
myCustomLink2.setText("press one of these words to search it on google: Android Linkify dzone");
Linkify.addLinks(myCustomLink2,pattern2, "http://www.google.ie/search?q=", myMatchFilter, null);
mainLayout.addView(myCustomLink2);

TransformFilter:
So fat the text we have filtered stayed the same. But sometimes you need the text to be different than the text which is appended to the link.

  TransformFilter myTransformFilter = new TransformFilter() {
	@Override
	public String transformUrl(Matcher match, String url) {
		return url.substring(1); //remove the $ sign
	}
};

TextView myCustomLink3 = new TextView(this);
Pattern pattern3 = Pattern.compile("\\$[a-zA-Z]+");
myCustomLink3.setText("press $Linkify or on $Android to search it on google");
Linkify.addLinks(myCustomLink3,pattern3, "http://www.google.ie/search?q=", null, myTransformFilter);
mainLayout.addView(myCustomLink3);

Download code example

((Button)findViewById(R.id.Button01)).setOnClickListener(
             new OnClickListener() {

			@Override
			public void onClick(View v) {
            int result = doLongOperation();
            updateUI(result);
			}
		});

What will happen?
The UI freezes. This is a really bad UI experience. The program may even crash.

The problem in using threads in a UI environment
So what will happen if we use a Thread for a long running operation.
Let’s try a simple example:

((Button)findViewById(R.id.Button01)).setOnClickListener(
new OnClickListener() {

			@Override
			public void onClick(View v) {

				(new Thread(new Runnable() {

					@Override
					public void run() {
                    int result = doLongOperation();
                    updateUI(result);
					}
				})).start();

			}

The result in this case is that the application crashes.
12-07 16:24:29.089: ERROR/AndroidRuntime(315): FATAL EXCEPTION: Thread-8
12-07 16:24:29.089: ERROR/AndroidRuntime(315): android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
12-07 16:24:29.089: ERROR/AndroidRuntime(315): at ...

Clearly the Android OS wont let threads other than the main thread change UI elements.

But why?
Android UI toolkit, like many other UI environments, is not thread-safe.

The solution

• A queue of messages. Each message is a job to be handled.
• Threads can add messages.
• Only a single thread pulls messages one by one from the queue.

The same solution was implemented in swing (Event dispatching thread
and SwingUtilities.invokeLater() )

Handler
The Handler is the middleman between a new thread and the message queue.

Option 1 – Run the new thread and use the handler to send messages for ui changes

final Handler myHandler = new Handler(){
	@Override
public void handleMessage(Message msg) {
		updateUI((String)msg.obj);
}

};

(new Thread(new Runnable() {

	@Override
	public void run() {
		Message msg = myHandler.obtainMessage();

		msg.obj = doLongOperation();

		myHandler.sendMessage(msg);
	}
})).start();

* keep in mind that updating the UI should still be a short operation, since the UI freezes during the updating process.

Other possibilities:
handler.obtainMessage with parameters
handler.sendMessageAtFrontOfQueue()
handler.sendMessageAtTime()
handler.sendMessageDelayed()
handler.sendEmptyMessage()

Option 2 – run the new thread and use the handler to post a runnable which updates the GUI.

final Handler myHandler = new Handler();

				(new Thread(new Runnable() {

					@Override
					public void run() {
						final String res = doLongOperation();
						myHandler.post(new Runnable() {

							@Override
							public void run() {
								updateUI(res);
							}
						});
					}
				})).start();

			}

Looper
If we want to dive a bit deeper into the android mechanism we have to understand what is a Looper.
We have talked about the message queue that the main thread pulls messages and runnables from it and executes them.
We also said that each handler you create has a reference to this queue.
What we haven’t said yet is that the main thread has a reference to an object named Looper.
The Looper gives the Thread the access to the message queue.
Only the main thread has executes to the Looper by default.

Lets say you would like to create a new thread and you also want to take advantage of the message queue functionality in that thread.

(new Thread(new Runnable() {

						@Override
						public void run() {

							innerHandler = new Handler();

							Message message = innerHandler.obtainMessage();
							innerHandler.dispatchMessage(message);
						}
					})).start();

Here we created a new thread which uses the handler to put a message in the messages queue.

This will be the result:
12-10 20:41:51.807: ERROR/AndroidRuntime(254): Uncaught handler: thread Thread-8 exiting due to uncaught exception
12-10 20:41:51.817: ERROR/AndroidRuntime(254): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
12-10 20:41:51.817: ERROR/AndroidRuntime(254): at android.os.Handler.(Handler.java:121)
12-10 20:41:51.817: ERROR/AndroidRuntime(254): at ...

The new created thread does not have a Looper with a queue attached to it. Only the UI thread has a Looper.
We can however create a Looper for the new thread.
In order to do that we need to use 2 functions: Looper.prepare() and Looper.loop().

(new Thread(new Runnable() {

					@Override
					public void run() {

						Looper.prepare();
						innerHandler = new Handler();

						Message message = innerHandler.obtainMessage();
						innerHandler.dispatchMessage(message);
						Looper.loop();
					}
				})).start();

If you use this option, don’t forget to use also the quit() function so the Looper will not loop for ever.

@Override
	protected void onDestroy() {
		innerHandler.getLooper().quit();
		super.onDestroy();
	}

AsyncTask
I have explained to you that a Handler is the new thread’s way to communicate with the UI thread.
If while reading this you were thinking to yourself, isn’t there an easier way to do all of that… well, you know what?! There is.

Android team has created a class called AsyncTask which is in short a thread that can handle UI.

Just like in java you extend the class Thread and a SwingWorker in Swing, in Android you extend the class AsyncTask.
There is no interface here like Runnable to implement I’m afraid.

class MyAsyncTask extends AsyncTask<Integer, String, Long> {

    	@Override
    	protected Long doInBackground(Integer... params) {

    		long start = System.currentTimeMillis();
    		for (Integer integer : params) {
    			publishProgress("start processing "+integer);
    			doLongOperation();
    			publishProgress("done processing "+integer);
    		}

    		return start - System.currentTimeMillis();
    	}

    	@Override
    	protected void onProgressUpdate(String... values) {
    		updateUI(values[0]);
    	}

    	@Override
    	protected void onPostExecute(Long time) {
    		updateUI("Done with all the operations, it took:" +
                                     time + " millisecondes");
    	}

    	@Override
    	protected void onPreExecute() {
    		updateUI("Starting process");
    	}

    	public void doLongOperation() {

    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}

    	}

    }

This is how you start this thread:

MyAsyncTask aTask = new MyAsyncTask();
aTask.execute(1, 2, 3, 4, 5);

AsyncTask defines 3 generic types:
AsyncTask<{type of the input}, {type of the update unit}, {type of the result}>
You don’t have to use all of them – simply use ‘Void’ for any of them.

Notice that AsyncTask has 4 operations, which are executed by order.
1. onPreExecute() – is invoked before the execution.
2. onPostExecute() - is invoked after the execution.
3. doInBackground() - the main operation. Write your heavy operation here.
4. onProgressUpdate() – Indication to the user on progress. It is invoked every time publishProgress() is called.

* Notice: doInBackground() is invoked on a background thread where onPreExecute(), onPostExecute() and onProgressUpdate() are invoked on the UI thread since their purpose is to update the UI.

Android developer website also mentions these 4 rules regarding the AsyncTask:

• The task instance must be created on the UI thread.
• execute(Params…) must be invoked on the UI thread.
• Do not call onPreExecute(), onPostExecute(Result), doInBackground(Params…), onProgressUpdate(Progress…) manually.
• The task can be executed only once (an exception will be thrown if a second execution is attempted.)

Timer + TimerTask
Another option is to use a Timer.
Timer is a comfortable way to dispatch a thread in the future, be it once or more.

Instead of doing this:

Runnable threadTask = new Runnable() {

	@Override
	public void run() {

		while(true){
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			doSomething();
		}
	}
};

(new Thread(threadTask)).start();

do this:

TimerTask timerTask = new TimerTask() {
	@Override
	public void run() {
		doSomething();
	}
}; 

Timer timer = new Timer();
timer.schedule(timerTask, 2000,2000);

which is a bit more elegant.

Bare in mind, you still have to use Handler if you need to do UI operations.

Download sources:

Download demo project 1
Download demo project 2

Add all activities to manifest

• Each screen is usually an Activity.
• Each activity should be mentioned in the manifest file.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.aviyehuda.puzzle" android:versionCode="1"
	android:versionName="1.0">
	<application android:icon="@drawable/icon"
			android:label="@string/app_name">
		<activity android:name="MyActivity">

			<intent-filter>
				<action android:name="android.intent.action.MAIN" />
				<category android:name="android.intent.category.LAUNCHER" />
			</intent-filter>

		</activity>

		<activity android:name=".MyActivity2" >

		</activity>

</application>
<uses-sdk android:minSdkVersion="6" />
</manifest> 

The simple use

Intent in = new Intent(MyActivity.this, MyActivity2.class);
startActivity(in);

• Bear in mind that every time you will call the function startActivity(intent) a new instance of MyActivity2 will be created.

Passing a parameter

• In most times you need to pass a parameter to the new screen. You do that by using the function putExtra().
• This function

Intent in = new Intent(myactivity.this, MyActivity2.class);
in.putExtra("myKey", "new1");
startActivity(in);

Receiving a parameter

• And of course you will need to receive that parameter on the other side.

String s= getIntent().getExtras().get("myKey").toString()

Going back

• If you need to go back to the previous screen and terminate the current screen, than all you have to do is to use the function finish() from anywhere in the new Activity.

finish();

Open for result

• When you need to open a new screen and get result back from it, than use the function startActivityForResult() instead of startActivity()

Intent in = new Intent(myactivity.this, MyActivity2.class);
startActivityForResult(in, 0);

Returning a result

Intent in = getIntent();
in.putExtra("result", "some parameter");
setResult(RESULT_OK,in);
finish();

Getting the result from the new activity

@Override
    protected void onActivityResult(int requestCode,
                                     int resultCode, Intent data) {
    	super.onActivityResult(requestCode, resultCode, data);

    	Log.d("Result",""+data.getExtras().get("result"));
    } 

The obvious solution for many of these fat clients were the java web frameworks like Struts, JSF and all the others. But as the years went by a new approach became more and more popular – the Ajax web applications, with GMail in the lead.

Fat clients never looked better and the usability was excellent. It is almost as if we are using desktop applications (!?!). JavaScript was never so cool. Libraries like JQuery are born every day as well as some new solutions like GWT to make our life with JavaScript easier.

But the story doesn’t end here. With the birth of the smart cellphones an old player came back to life – that’s right, the installed application. The small screen and slow connection makes the rich client web sites a bit hard to handle. IPhone followed by Android and Blackberry clearly encourage this approach with their application markets, so obviously installed applications are dominators in the mobile network applications arena.

But what’s next? Will the mobile installed applications suffer the same fate as the desktop applications? Clearly the arrival of HTML5 won’t make their life easier. Or maybe the installed applications will survive with the help of technologies such as JavaFX. Maybe both will manage to have a share.

What do you think?

I love discovering new music. Recently I am using blip.fm a lot. I like the idea of being proposed music I would love by someone who has the same taste of music like me. For me, it is the ultimate internet use.

One trouble though, is that it usually takes me at least 3-5 times to hear a song before I would know I actually like it. I have found that the best thing is to download about 10-20 songs to my cellular phone and hear them again and again for a few times.

In this post I will show you how to do that quite easily using fiddler and firefox.

You can also do the same to download other file types like swf movies and so on.

If you are using other browser than Firefox, that’s OK, it can also work with other browsers.

Step 1 – Download and install Fiddler

• Fiddler is a sniffing software which I like very much. It is super easy.
• Please download it from here and install it.
• You will also have to install the script editor add-on. Please download it from here. This add on lets you do a verity of actions to your web traffic, it is really a very useful add on.

Step 2 – Configure the script

• Open Fiddler.
• Go to “FiddlerScript” tab on the top right tab bar.
• Go to “OnBeforeResponse” function. You can do that by choosing it from the “Go to” drop down list.
• Paste this snippet to the end of the function body.

if(oSession.url.Contains(".mp3")){
         FiddlerApplication.Log.LogFormat("downloading "+oSession.url);
         System.Diagnostics.Process.Start("firefox.exe",oSession.url);
}

This script will cause the fiddler to execute firefox with the link of of each mp3 file he sniffs in the network traffic. Notice I am also appending a small parameter at the end of the file URL. I do this so the fiddler will not go into a loop and download the same file again and again.

• Press the “Save Script” button at the top of the script editor window.

• You may or may not need to do this step because your firefox is maybe already configured to download mp3 files.
• If it’s not or you are not sure please open up your firefox. Go to “Tools” > “options” > “Applications”. Type “mp3″ in the search input field and make sure that the action for this file type is “Save File”. Press “OK” and that is it.

• Go to blip.fm (or any other mp3 streaming site) and start listen to mp3s.
• Notice that in blip.fm you can listen to swf or mp3 files. The script I have shown you above, downloads only mp3s. You van easily change it to download swf files.
• Notice that blip.fm gives you the ability to skip the videos and just focus on the mp3s, this is even better for our use.

And that it is. While you listen to the music, for every mp3 the fiddler will sniff, it will fire up the firefox which will than start to download the mp3s to your computer automatically.
Actually you don’t even have to listen to the whole song, you can just wait for a few seconds until the song starts and go right away to the next song.