Itsplanned.com

Itsplanned.com is created as an alternative to the more advanced project management tools that already exists. It is built based on the goal that it should be very easy to use, with a simple set of functions that quickly gives the user a clear and clean view of the tasks that are planned.

Own tasks

Itsplanned.com gives the use a set of tool, where the users can create there own tasks or project, that they need to track. When the tasks are created, the user can sort and change priority of the tasks, simply by drag’n'drop the tasks up and down in the task overview.

Groups and moves

Tasks can also be moved into another task, where it will be a subtask. Itsplanned.com opens for the possibility, where every single tasks easily is movable among the other tasks.

Overview and userability

The overview can quickly be changed from listing a task summary to be listing a more detailed output. The overview can both display or hide closed and finished tasks, by selecting a checkbox.

Task descriptions are changed with the user friendly built-in HTML (WYSIWYG) editor.

When the first real-world tests have been completed, the source-code will be released to download.

More details and screenshots can be found at itsplanned.com

My setup

Server:
Debian Lenny (IP 192.168.1.123)
Standard NFS-server
A simple export setup (1 share) /mnt/storage

Client:
Ubuntu 10.04
Autofs 5.0.4-3.1ubuntu5
Autofs5 5.0.4-3.1ubuntu5

Autofs configuration

The first problem is this:

syntax error in nsswitch config near [ syntax error ]

This error message appears in my message log file on my client after installing Autofs. No configuration has yet been changed. So this is by default not working.
There are, as far as I have tested, two workarounds:
1: outcomment the line with ‘+auto.master’ at the bottom of the /etc/auto.master
2: insert a line with ‘automount:files’ in the /etc/nsswitch.conf

Now – restart autofs and verify that the error message is gone:

#sudo service autofs restart

The Autofs setup step 1

Edit /etc/auto.master and add a line like this:

/media/nfsshares /etc/auto.nfs

This will tell autofs to create a folder named nfsshares inside the /media/ folder and that there are further configuration entries in the file /etc/auto.nfs

The Autofs setup step 2

Create a file called auto.nfs in the /etc/ folder and edit it with your favorite editor:

# vim /etc/auto.nfs

Enter one or more shares like this:

myservershare 192.168.1.123:/mnt/storage

Save the file and we are done.

Starting and testing Autofs

All options are now created, so lets (re)start Autofs and move on:

# service autofs restart

The Autofs is now running and we should see a newly created folder inside your /media directory:

# cd /media

# ls -al
...
drwxr-xr-x  3 root root     0 2010-07-15 21:22 nfsshares
...

Try to change directory to the nfsshares folder:

# cd nfsshares

# ls -al

What the …. It’s empty. Where is the myservershare folder? Don’t worry, just try and cd’e into the folder:

# cd myservershare

Well well well. The directory is now accessible and visible.

If you would like the directory structure to be visible at all times – even at first entry – add the ghost parameter to the auto.master like this:

/media/nfsshares /etc/auto.nfs --ghost

The Autofs is now up and running.

I have a setup, where I with the dump/restore utilities on my Debian box are running a set of scheduled backup jobs. To make it short, I use the dump utility to backup the different mount points on my system.

How to backup with dump

To backup the root (/) partition I run a command like this:

dump -0 -u -f - / | gzip > /mnt/backup/root-gziped.gz

This runs the dump utility with a set of options (please referrer to the man page for further options). -0 means a level 0 backup, -u updated a log file with the date of the last update and -f outputs everything to standard output. Afterwards the gzip command will pack the dump data and store it in a file.
This is the way I do it. Feel free to use other options.

How to restore a backup made with dump

If your hard drive is failing or perhaps running low on disk space and you need to upgrade it, one way is to do it by restoring from a backup.

What you need, is some kind of running Unix system where you can access the new hard drive and you also need access to the backup file. I have plugged my new drive in another Unix machine as a secondary drive. In this case I am using an Ubuntu 10.4 workstation, where I have installed the dump utility.

Partitioning the new hard drive

To get access to the new drive we need to partition it first. I am using the GParted program in my Ubuntu and have created a partition layout like this:

NB. This screenshot shows disk usage, because the screenshot it taken after a successful restore.

Mounting the new layout

Before we can start the restore, we need to mount the new partition. This is done from the console (terminal) like this:

#mkdir /media/root

#mount /dev/sdb1 /media/root

NB. Please note that I am using sdb (and not sda like the screenshot above shows). This is because the hard drive is not the system drive yet.

The hard drive is now mounted in the /media/root directory and we can begin the restore.

Restoring data

I am using the restore command with the interactive shell to select the files and directories that I need to restore.

# gunzip root-gziped.tar.gz  | restore -ivf -
Verify tape and initialize maps
Input is from a local file/pipe
Input block size is 32
Dump   date: Thu Jul  8 21:35:37 2010
Dumped from: the epoch
Level 0 dump of / on myserver.mynetwork.com:/dev/sda1
Label: none
Extract directories from tape
Initialize symbol table.
restore >

At the prompt it is possible to browse the media with the normally used ‘cd’ and ‘ls’ commands. When we have found what we need we can go ahead a add it to the queue. To help the restore utility getting the folder permissions correct I usually runs the command setmodes as the first thing.

restore > setmodes
Set directory mode, owner, and times.
restore > add boot
restore > add bin
...
...
restore > extract

The ‘add’ command adds folders or files to the queue and the extract command will start the restoring process.

When this is finished you will be asked if you want to set folder permissions on ‘.’. Answer Yes here.

...
Add links
Set directory mode, owner, and times.
set owner/mode for '.'? [yn] y
restore >

This is it. The files are now restored and the hard drive is almost ready to begin its new life.

Installing grub boot loader

Before the disk can boot up and start the operating system, it needs to have a boot manager. My previously system was using Grub, so I will just reinstall this on the new drive. For this job, we can use an Ubuntu Live cd-rom and boot this.

When this is done and the Ubuntu Live version has booted we need to get access to the new drive (now known as /dev/sda).

Open up a terminal window and enter:

#mkdir /mnt/root

#sudo mount /dev/sda1 /mnt/root

#sudo chroot /mnt/root /bin/bash

#grub-install /dev/sda

These commands will create a mount point, mount the new drive, get root access to the new content and install a grub boot loader on the new.

Power off the machine, pull out the hard drive and install it in the old server again.

To get this working, you need two systems – a server and a client.

Installing the NFS Server

I have en Debian server running, where I would like easy access to some of the folders from my workstation. To do this, I will install the nfs-kernel-server and the portmap packages like this:

# aptitute install nfs-kernel-server portmap

The NFS server and the portmap service is now installed and up and running.

Which folders to share

To defined which folder we want to share and to which client, we have to take a look at the /etc/exports file. So open /etc/exports in you favorite editor and insert a line like this:

/home/js 192.168.1.2(rw)

This tells the NFS service, that I want to share my home folder /home/js to the client at IP 192.168.1.2 with read-write (rw) access.

To reload the defined exports I have to run the exportfs command like this:

# exportfs -a

That’s it – we done here

Access the NFS share from an Ubuntu Client

I am using Ubuntu 10.4 as my primary workstation, so I would like to access my home folder on my server. To do this, I have to install the nfs-common package, so I will select my System menu, goto Administration and click on Synaptic Package Manager. Here I will find the nfs-common package and install it as shown here:

All that’s left is to mount the share. I will just enter the share to my fstab file and it will then be ready to mount (and automatically mounted on the startup). Again – use your favorite editor to add a line to the /etc/fstab:

192.168.1.1:/home/js /media/serverhome   nfs rw 0 0

This will let the system mount the /home/js share located on the server with the IP 192.168.1.1, into the local folder /media/serverhome with read-write (rw) access.

When this is done, we must create the folder /media/serverhome on the locale machine and then, either reboot the system or manually mount the share like this:

# mount /media/serverhome

And we are done.

Installing a fresh Debian 5.0

I am using Virtual Box on my Ubuntu Workstation. This gives me the option to install the OpenQRM in a closed internal network, without having access to new hardware.

To start with I am doing a fresh installation of Debian 5.05 without any additions. No server software, no desktop software, nothing. Just like this:

Installing the basic packages for building the OpenQRM source

Now I have the most basic Debian installation. The OpenQRM will be installed from the svn repository, so I have to install the subversion and make programs. I will also install the mysql-server-5.0 and postfix manually before starting, as it seems something gets messed up if the OpenQRM installation handles these two:

root@openqrm:~# aptitude install subversion make postfix mysql-server-5.0
Reading package lists... Done
Building dependency tree
Reading state information... Done
Reading extended state information
Initializing package states... Done
Reading task descriptions... Done
The following NEW packages will be installed:
  bsd-mailx{a} ca-certificates{a} file{a} libapr1{a} libaprutil1{a} libdb4.5{a} libdbd-mysql-perl{a} libdbi-perl{a}
  libexpat1{a} libhtml-template-perl{a} libldap-2.4-2{a} liblockfile1{a} libmagic1{a} libmysqlclient15off{a}
  libneon27-gnutls{a} libnet-daemon-perl{a} libplrpc-perl{a} libpq5{a} libserf-0-0{a} libsqlite3-0{a} libsvn1{a}
  libterm-readkey-perl{a} libxml2{a} mailx{a} make mime-support{a} mysql-client-5.0{a} mysql-common{a}
  mysql-server-5.0 openssl{a} openssl-blacklist{a} perl{a} perl-modules{a} postfix psmisc{a} python{a}
  python-minimal{a} python2.5{a} python2.5-minimal{a} sgml-base{a} ssl-cert{a} subversion xml-core{a}
0 packages upgraded, 43 newly installed, 0 to remove and 0 not upgraded.
Need to get 64,1MB of archives. After unpacking 189MB will be used.
Do you want to continue? [Y/n/?] Y

During the installation of mysql-server-5.0 you will be asked to type in a MySQL root user password. I am entering ‘openqrm’ – you can choose whatever you like, as long as you can remember it later on.
The postfix packages will ask how to deliver mail from the system. This depends on your setup, but I will select the “Internet Site” option, so that the server can delivery mail directly on the internet.

Download OpenQRM from the svn repository

When this is done, the next step is the fetch the newest version from the svn repository:

root@openqrm:~# svn co https://openqrm.svn.sourceforge.net/svnroot/openqrm openqrm
...
Checked out revision 1998.

This can take a few minutes and it finishes by displaying which revision I have checked out.

Compiling the OpenQRM source

Next step is to change to the src-folder and start the code compiling by running the ‘make’ command:

openqrm:~# cd openqrm/trunk/src/
openqrm:~/openqrm/trunk/src# make
...
...

This will download and install all the needed Debian packages by itself.

Installing the OpenQRM source

To install the OpenQRM software run the ‘make install’ command, when the previously ‘make’ command has finished:

openqrm:~/openqrm/trunk/src# make install

This will copy all files to the correct positions on the system.

OpenQRM system scripts

The final installation step is to run the ‘start’ command, which activates all startup scripts and installs the last required system software:

openqrm:~/openqrm/trunk/src# make start
...

Accessing the Web interface

All software has now been installed and the final step is to prepare the MySQL-database.

This is done by accessing the OpenQRM website. My server has the IP address 192.168.1.26, so I will point my browser at http://192.168.1.26/openqrm/ and type in ‘openqrm’ in the username and password prompt.

Step 1

I am clicking ‘next’:

Step 2

I am selecting the MySQL option:

Step 3

Now enter the password for the MySQL root user and click ‘Initialyze’

All done

The OpenQRM should now be installed without any errors:

The browser will now redirect to the main screen and we are ready to go.

- Create a new class for the activity
- Add the class to the Android Manifest
- Start the activity

Create a class for the user interface

Lets call this file UI:

import android.app.Activity;

public class UI extends Activity {

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // type your magic code here
    }

}

That it basically it. A class extending the Activity – the onCreate is called when the activity is started.
NB: the super.onCreate is very important – without it the code will fail to run!

Editing the AndroidManifest.xml

The register the intent in the application, we have to edit the AndroidManifest.xml file like this:

...
<application...>
        ...
        <activity android:name=".UI" android:label="@string/app_name">
        </activity>
        ...
</application>

This enables us to access the UI intent created earlier.

Starting the activity

All we have to do now, is to start the new intent. This can be done with the startActivity()-function like this:

...
startActivity(new Intent(this, UI.class));
...

I hope this small guide is helpful to you. If you would like an example with more details, please let me know

I asked around a bit and everyone said I should take a look at ‘git’, so that I did and I will here summarize what I found so far.

What is Git?

The git version control is a decentralized system that runs along side your code projects. This means that your are not depended on a shared/central server to manage your requests. This have many advantages compared to say cvs and subversion (svn), but I will not go into details with this.

Basic file handling

I have writing a small Hello World sample i php, which looks like this:

<?
  print "Hello world!";
?>

Nothing fancy – just a starting point.

Initializing a project

To start up a new project, you have to use the init-option. Standing in the root folder of your project run this:

$ git init
Initialized empty Git repository in /home/js/helloworld/.git/

This creates a .git-folder in the root of the project folder and your project is ready to go.

Adding files to the git repo

To add the newly created helloworld.php file to the git repository, you have to use the add option like this:

$ git add helloworld.php

The helloworld.php is now queued for adding to the project.

Committing changes

When files are marked to be added to the project, you have to commit the changes to the repo. This is done with the commit option

$ git commit

This opens up your default editor, where you can type in a comment for your update. When this is done and the content is saved, just quit your editor and the file should now be committed.

$ git commit
[master (root-commit) 22aff8e] Initial commit
 1 files changed, 3 insertions(+), 0 deletions(-)
 create mode 100644 helloworld.php

Showing a log/history of the project

To see what has happen to the project, you can always run the log option like this:

$ git log
commit 22aff8e5f227c6284307363d036fbe06806ad4a5
Author: js <js@w(none)>
Date:   Sun May 16 22:54:13 2010 +0200

    Initial commit

Here we can see, that I have submitted a change, which I have commented “Initial commit”.

Updating existing files

So lets make some changes to the helloworld.php file:

<?
  print "Hello world... Hello world!";
?>

I have here added some text to the print command.

When using the diff option we can see which changed has been entered:

$ git diff
diff --git a/helloworld.php b/helloworld.php
index 4450c89..50f9c46 100644
--- a/helloworld.php
+++ b/helloworld.php
@@ -1,3 +1,3 @@
 <?
-  print "Hello world";
+  print "Hello world... Hello world!";
 ?>

Here we can see, that there is a difference in the helloworld.php file.

To save these changes in the repo, just commit them like shown above:

$ git commit -a
[master d6bcc84] Added more text
 1 files changed, 1 insertions(+), 1 deletions(-)

Reverting back to previous versions

Doh!, this is all wrong. It should only print out “Hello world” and nothing else. Well, then we just have to fetch the previous version of the helloworld.php file.

Lets use the log function to see which change we have to get back to:

$ git log
commit d6bcc84950f5968e8c5d3fc0522e55cfb3cc8dab
Author: js <js@w(none)>
Date:   Sun May 16 23:04:17 2010 +0200

    Added more text

commit 22aff8e5f227c6284307363d036fbe06806ad4a5
Author: js <js@w(none)>
Date:   Sun May 16 22:54:13 2010 +0200

    Initial commit

We then want to go back to the initial commit by using the hash value stated on the commit line:

$ git checkout 22aff8e5f227c6284307363d036fbe06806ad4a5
Note: moving to '22aff8e5f227c6284307363d036fbe06806ad4a5' which isn't a local branch
If you want to create a new branch from this checkout, you may do so
(now or later) by using -b with the checkout command again. Example:
  git checkout -b <new_branch_name>
HEAD is now at 22aff8e... Initial commit

Listing the content of the helloworld.php will now verify that we have gone back to the original version.

But as you can see, we now have to work with branches. I will not cover branches in this article, so just save a branch and move it to the master like this:

$ git checkout -b test
Switched to a new branch 'test'
$ git branch -M master

There you go – a previous update was found and we can continue our coding from here.

I will cover branches and much more later on.

The basic databaseHandler

There are properly tons of ways to make a databaseHandler and I will not discuss why and when to use what. Use my examples as you want or if you want to.

The databaseHandler is the class that handles the connection from the application to the database.

This is the most basic database handle class:

package huuah.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.SQLException;

public class databaseHelper extends SQLiteOpenHelper {

  private static final String DBNAME = "myfancydatabase";
  private databaseHelper myDBHelper;
  private SQLiteDatabase myDB; 

  private final Context myContext;

  public databaseHelper(Context context) {
    super(context, DBNAME, null, 2);
    this.myContext = context;
  }

  @Override
  public void onCreate(SQLiteDatabase db) {
  }

  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  }

  public databaseHelper open() throws SQLException {
     myDBHelper = new databaseHelper(myContext);
     myDB = myDBHelper.getWritableDatabase();
     return this;
  }
}

When the open() function is called, it will activate the constructor and a new database (in this case named ‘myfancydatabase’) will be created inside the database path for your app.

The database path is located in /data/data/YOURPACKAGENAME/databases/.

To run the code add something like this to your application:

...
import huuah.db.databaseHelper;
...
databaseHelper dbCon = new databaseHelper(this);
dbCon.open();
...

Use the DDMS in Eclipse or the ADB tool to check if the database is created correctly.

Copying from assets to database path

What if we would like to distribute the application with a default database? Almost as simple as creating a new. Copy your SQLite database to the assets folder of your project. From here we will copy it to the correct database folder on the phone.

...
  public void createDatabase() throws IOException {

    InputStream assetsDB = myContext.getAssets().open("localdb");
    OutputStream dbOut = new FileOutputStream("/data/data/huuah.db/database/myfancydatabase");

    byte[] buffer = new byte[1024];
    int length;
    while ((length = assetsDB.read(buffer))>0){
      dbOut.write(buffer, 0, length);
    }

    dbOut.flush();
    dbOut.close();
    assetsDB.close();
}
...

This will copy the database ‘localdb’ found in the assets folder and copy it to the database folder of my huuah.db package and naming it myfancydatabase. All done.

Using DDMS or the ADB tool

Sometimes it is a good idea to check if your files and databases are created properly. This can be done with the DDMS in the Eclipse IDE or with the ADB tool.

Eclipse DDMS

Go to the Window-menu, select Open Perspective and click the “Other” option. Select the DDMS option and click OK. This will open up a File Explorer and some other windows. The File Explorer can be used to view, delete and copy to and from the emulator by pulling or pushing files.

ADB tool

The adb-tool can, among many things, be used for file exploring. Open a adb shell and list the content of the database folder like this:

$ adb shell
# cd data/data/huuah.db/databases
# ls
myfancydatabase
#

Creating a SQLite database with a Firefox plugin

If your are using Firefox, there is a great simple plugin that lets your create and edit SQLite database. It can be found here. When downloaded and installed, goto the tools menu in Firefox and select the SQLite manager and your are ready.

There is only one thing you must remember, when creating the databases from scratch like this, is to manually create the android structure. This is done by running these to SQL commands:

CREATE TABLE "android_metadata" ("locale" TEXT DEFAULT 'en_US');
INSERT INTO "android_metadata" VALUES ('en_US');

Close and save the database, and copy the file to your assets folder.

Where I got stuck

I ran into quite a few obstacles when making the database connection for the very first time. I did find some answers as well:

Problem: public type databaseHelper must be definded

Solution: Well, I wasn’t thinking when creating my databaseHelper, so I just wrote it in the same file as my main function. Don’t do this. Bad idea. New classes must be placed in its own .java file.

Problem: I was getting loads of “database failure 14″

Solution: Don’t manually create the /data/data/PACKAGENAME/databases directory. User rights on the databases folder will be wrong and your are not allowed to write to the directory from your Android App. Remove the directory and let the Android software create it for you.

The end

I hope your found my post useful. Please post any comments you may have.

How to float it

Well – it can sometimes be quite difficult to understand how the float universe works. I will try to give some basic pointers and examples on the float left and float right technique and how it reacts in the layout.

The basic of id and classes

There are two ways to access HTML elements from CSS. You can either use id’s or class’es. Almost every HTML tag, if not all, allows the assignment of an id or class name. When element has an id or class, it can be accessed from CSS by using . or #.

ID are accessed with # (hash). Lets say we have a <div>-tag with the id set to mydiv:

<div id="mydiv">some content here</div>

The mydiv can then be access like this from CSS

#mydiv {
  width: 100px;
  height: 100px;
}

If we are using a class instead of an id, the code would lookup like this:

<div class="mydiv">some content here</div>

And

.mydiv {
  width: 100px;
  height: 100px;
}

id’s and class’es will not be covered in more details here.

Starting point

This article will use the following HTML as a starting point. It holds a simple div-”container” with contains another 3 divs.

<div class="container">
  <div class="class1">This is the first class</div>
  <div class="class2">This is the second class</div>
  <div class="class3">This is the third class</div>
</div>

Without any CSS it would look like this:

Not really that pretty and nice as we would like it to be, right?

Basic styling

Lets do some basic styling of the above code, to better see what’s going on.

.class1 {
  width: 200px;
  background-color: light-grey;
}
.class2 {
  width: 300px;
  background-color: white;
}
.class3 {
  width: 500px;
  background-color: grey;
}

This outputs:

Okay – now we can better see the difference between the 3 divs.

Lets float it

When floating left, the selected element will be placed along the left side of the next element.
When floating right, the selected element will be placed along the right side of the next element.

Left floating the first class:

.class1 {
  width: 200px;
  background-color: light-grey;
  float: left;
}

Okay, that went kinda like expected. Although – the class2 has a width set to 300px, so why does it wrap like that, when it should have enough space – the class1 is 200px and the class3 is 500px, so class1 and class2 should will up the exact same space as class3 below.

This is one of those questions I used to ask a friend of mine over at spiced2.com and he always answered “when in doubt, float left”. Ok then. Lets float class2 left as well:

.class1 {
          width: 200px;
          background-color: #DEDEDE;
          float: left;
}
.class2 {
          width: 300px;
          background-color: #006699;
          float: left;
}
.class3 {
          width: 500px;
          background-color: #009900;
}

Now it’s a lot better, but what will happen if we try to float right?

The first class is now floating right, and is therefor aligned to the right side of class2:

.class1 {
          width: 200px;
          background-color: #DEDEDE;
          float: right;
}
.class2 {
          width: 300px;
          background-color: #006699;
}
class3 {
          width: 500px;
          background-color: #009900;
}

The next step

Lets try a bit more advanced setup, where we will wrap some text around another element. To do this we have to place one element inside another like this:

<div class="container">
  <div class="class1"> <span class="class2">This is the second class</span>This is the first class This is the first class This is the first class This is the first class This is the first class This is the first class </div>
  <div class="class3">This is the third class</div>
</div>

To get the text in class wrapped around the class2 element, we have to set a float right on the class2. This makes it right aligned, and the text in class1 will then wrapped around it.

The CSS looks as follows:

.class1 {
          width: 500px;
          background-color: #DEDEDE;
          float: left;
}
.class2 {
          width: 200px;
          background-color: #006699;
          float: right;
}
.class3 {
          width: 500px;
          background-color: #009900;
}

Last words

That it. A very small and basic intro tutorial on the mysterious left and right floating. Enjoy.

A progress bar is quit easy to make, which I have described here is the Dialog Boxes post here and I will therefor not go into details with this.

Simple test layout

I have created a simple test layout like this:

XML layout:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >

<TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Maximum value"></TextView>

<EditText android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="100" android:id="@+id/maximum"></EditText>

<TextView android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Increment by"></TextView>

<EditText android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="5" android:id="@+id/increment"></EditText>

<Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Start" android:id="@+id/startbtn"></Button>

</LinearLayout>

There are two text fields. One to set the maximum value of the progress bar and one to set the increment value. When pushing the Start button a progress bar is displayed and in this example it will just update the progress bar every half a second (500ms) to demonstrate the result.

Updating the progress bar

To update the progress bar in the background, while something else is running the application has to use threads. I will be setting up a thread when the Start button is clicked. The thread will then execute some code, in this case just a simple handler that will update the progress bar, and when finished the thread will terminate itself.

When the Start button is activated the application will display a progress bar – I have set a maximum value of 200 and a increment value of 14:

Complete Java code

The complete java code looks like this. I have added comments in the code, so it should be self explanatory – if not just post a comment last on this page.

package huuah.progressthread;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.app.ProgressDialog;

public class progressthread extends Activity implements OnClickListener {
    ProgressDialog dialog;
    int increment;

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

        Button startbtn = (Button) findViewById(R.id.startbtn);
        startbtn.setOnClickListener(this);
    }

    public void onClick(View view) { 

        // get the increment value from the text box
        EditText et = (EditText) findViewById(R.id.increment);
        // convert the text value to a integer
        increment = Integer.parseInt(et.getText().toString());

        dialog = new ProgressDialog(this);
        dialog.setCancelable(true);
        dialog.setMessage("Loading...");
        // set the progress to be horizontal
        dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        // reset the bar to the default value of 0
        dialog.setProgress(0);

        // get the maximum value
        EditText max = (EditText) findViewById(R.id.maximum);
        // convert the text value to a integer
        int maximum = Integer.parseInt(max.getText().toString());
        // set the maximum value
        dialog.setMax(maximum);
        // display the progressbar
        dialog.show();

        // create a thread for updating the progress bar
        Thread background = new Thread (new Runnable() {
           public void run() {
               try {
                   // enter the code to be run while displaying the progressbar.
                   //
                   // This example is just going to increment the progress bar:
                   // So keep running until the progress value reaches maximum value
                   while (dialog.getProgress()<= dialog.getMax()) {
                       // wait 500ms between each update
                       Thread.sleep(500);

                       // active the update handler
                       progressHandler.sendMessage(progressHandler.obtainMessage());
                   }
               } catch (java.lang.InterruptedException e) {
                   // if something fails do something smart
               }
           }
        });

        // start the background thread
        background.start();

    }

    // handler for the background updating
    Handler progressHandler = new Handler() {
        public void handleMessage(Message msg) {
            dialog.incrementProgressBy(increment);
        }
    };
}