gabehabe Cool blog, bro.

Developing for Android, Part V

Publishing your apps

No code in this tutorial… and this is actually the last in the series. But never fear! I’ll be writing more tutorials, I’ve simply written these 5 to get you familiarised with android. Hopefully, you’re feeling quite confident on some of the aspects now, and you could well be on your way to developing the next killer app!

With that said, I’m going to explain how you can publish your app. It’s a simple process, but you also have to sign your apk before you can publish it to the market.

First off, we need to create a keystore. To do this, you’ll need the JDK installed. Open up a command prompt, and change to whereever you want to save the keystore. Then, type the following:
keytool -genkey -v -keystore mykeystore.keystore -alias my_alias -keyalg RSA -validity 10000
NOTES:
- Replace mykeystore.keystore with whatever_you_want_to_call_it.keystore
- Replace my_alias with whatever alias you want to use (example, android)

Also, if you get this error:
'keytool' is not recognised as an internal or external command, operable program or batch file.
You may want to set the PATH variable. You can do it in the computer properties, but since this isn’t exactly a windows tutorial, I won’t go into that much detail. Instead, let’s do this:
PATH="C:\Program Files\Java\jdk1.6.0_14\bin"
then try the first command again.
NOTE: Replace the path with the path of wherever you installed Java. (Typically you’ll find it in C:\Program Files\Java\jdk%.%.%_%%\bin)
ANOTHER NOTE: This is of course a windows path. Depending on your operating system, this may vary.

After executing the keytool command, it will ask you for various details. Simply enter the values, and it will create your keystore. Make sure you take note of your alias and password, it will ask you for it every time you come to sign an app!

For reference, the questions it will ask are:

• Enter keystore password:
• Re-enter new password:
• What is your first and last name?
• What is the name of your organisational unit?
• What is the name of your organisation?
• What is the name of your City or Locality?
• What is the name of your State or Province?
• What is the two-letter country code for this unit?

You now have your keystore. When you want to sign an apk, you will need to use the following command:
jarsigner -verbose -keystore "/path/to/mykeystore.keystore" "/path/to/myapk.apk" my_alias
Enter your password, and you will see some output similar to this:

adding: META-INF/ALIAS_NA.SF
adding: META-INF/ALIAS_NA.RSA
signing: res/drawable/icon.png
signing: res/layout/main.xml
signing: AndroidManifest.xml
signing: resources.arsc
signing: classes.dex

Your apk file is now signed! (Note that you need to sign it every time before uploading, since building will reset it)

Publishing your app

The next step is of course publishing your newly signed apk file to the android market. Simply navigate your web browser to the market home and follow the steps to register as a developer. If you want to register to sell your apps, you will also need to go through an additional process to become a “registered seller”.

Once you’ve registered and logged in, you’ll reach the page which displays all your registered apps. Of course, if you’re following this tutorial, you probably don’t yet have any, so you won’t have a list of apps to see. :)
NOTE: This page uses a hell of a lot of javascript. Make sure it’s turned on.

When you’re ready, click on “Upload Application”. You will then be presented with a form where you can upload the apk and a maximum of two screenshots, a promotional graphic, and fill in various details such as the title, description and price.

As soon as you click publish, your application will be on the market — there’s no approval system like the iPhone’s app store, so as soon as you search in the market, you should see your app.

You are now officially a dev. Make me proud. :’)

Developing for Android, Part IV

Databases and Menus

Two for the price of one in this tutorial, actually. We’re going to learn about SQLite databases and menus. I’m hoping you’ll at least be slightly familiar with databases already, though SQLite is really quite simple. You can pick up the basics, of which we’ll be using in this tutorial, at the following links:

• CREATE TABLE
• INSERT
• SELECT

It may look a little intimidating, but once you get to grips with it, it’s actually quite close to English. :)

Let’s get to it. As usual, we’re creating a package:

package dreamincode.tutorials.dic_tut4;

…and we’ll import the usual suspects.

import android.app.Activity;
import android.os.Bundle;

Now there’s quite a lot that we’re going to import that hasn’t already been covered, but do not panic. I’ll explain it all as we go along, and it’s honestly nothing to worry about. First up, a ListView. This is just another widget, and it’s… well, it’s a list. :)

import android.widget.ListView;

Next, we’ll import the stuff related to the menu. We’ll be using a Menu, and a couple of MenuItems.

import android.view.Menu;
import android.view.MenuItem;

The next bits are related to the database. The first is self-explanatory, it’s a database. The second is a Cursor. A cursor is a way we can store temporary results from a table in memory. (We select stuff into it, explained a little later… keep reading!)

import android.database.sqlite.SQLiteDatabase;
import android.database.Cursor;

And finally, we’re going to import an ArrayList to add our results into, and an ArrayAdapter to basically plug our ArrayList into the list. Again, this will be explained later, at this point all we really have is an overview.

import android.widget.ArrayAdapter;
import java.util.ArrayList;

On to the main part of the code, now. :) First off, we’ll open up our class and add a few variables. We’ll have a ListView, an SQLiteDatabase, and a few ints for the IDs of our menu items.

public class dic_tut4 extends Activity {
	ListView list;
	SQLiteDatabase db;
 
	private static final int MENU_ADD = Menu.FIRST;
	private static final int MENU_QUIT = Menu.FIRST + 1;

You’ll see why we use these a little later. :)

This is where it gets a little different. I’ll give you one method at a time, and talk through each line.

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        this.list = new ListView(this);
        setContentView(this.list);
 
    	this.db = this.openOrCreateDatabase("dic_tut4", MODE_PRIVATE, null);
    	this.db.execSQL("CREATE TABLE IF NOT EXISTS table_of_dics(value REAL)");
    	this.update_list();
    }

So, the start is nothing new. Nothing to worry about here. Then we initialise the list. Nothing new here, either. It’s exactly the same as when we created a dynamic layout in part 3. Then we do some new things with our database. First we use openOrCreateDatabase("dic_tut4", MODE_PRIVATE, null);
– this creates a database if it doesn’t exist, or opens it if it does.
– parameter 1 is the name of the database we’re looking to create/open.
– parameter 2 is the mode, doesn’t require much explanation at this point. (Don’t want to give you an information overload) :)
– parameter 3, you don’t even need to worry about. If you’re interested, do some digging on CursorFactory.

Then another new line: this.db.execSQL("CREATE TABLE IF NOT EXISTS table_of_dics(value REAL)");
– this will create a table if it doesn’t already exist
– it will add a single field into the table, called value. It is of type REAL, which is just like a double in Java.

And finally, this.update_list(); … this is actually a custom method we’ll be writing to query the database and populate the list. More info later, for now let’s focus on the menu.

Creating a menu

Simple stuff actually. We use onCreateOptionsMenu(), which is called when the user hits the menu button.

    @Override 
    public boolean onCreateOptionsMenu(Menu menu) {
    	menu.add(0, MENU_ADD, 0, "Add").setIcon(android.R.drawable.ic_menu_add);
    	menu.add(0, MENU_QUIT, 0, "Quit").setIcon(android.R.drawable.ic_menu_close_clear_cancel);
    	return super.onCreateOptionsMenu(menu);
    }

We’re simply adding 2 items: “Add”, and “Quit”. We also set the icons for them using some default android resources. If you want a full list, this site is pretty cool.

The next method we’ll be using is onOptionsItemSelected(), which is called when the user selects an item in the menu. We use the IDs we assigned in onCreateOptionsMenu() MENU_ADD and MENU_QUIT to decide what to do.

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
    	switch(item.getItemId()) {
    		case MENU_ADD:
	        	db.execSQL("INSERT INTO table_of_dics(value) VALUES(" + String.valueOf(Math.random()) + ")");
	        	this.update_list();
    			break;
    		case MENU_QUIT:
    			this.db.close();
    			this.finish();
    	}
 
    	return super.onOptionsItemSelected(item);
    }

So, we’re using a switch() to find the ID of the menu item which called this method. If it’s add, we’re going to perform some SQL and insert a random value into the table. Then we’ll update the list, just like we did in onCreate(). (Remember, we’re defining this method ourselves later)

If the user selected the “Quit” option, we’ll simple close the database and finish the activity. :)

NOTE: The SQL used here, INSERT INTO will insert a random value into the table. Remember to refer to the links at the beginning if you get stuck on the SQL.

Lastly, we’re going to define our method for updating the list. It’s quite simple, but the code is quite different to what we’ve done so far. If you’ve ever done any database work through software/web before, you may notice a few similarities here. We basically execute the query. Then loop through each row in the result, adding it into an ArrayList. Lastly, we set the adapter for the list to display the arraylist we created. The code looks a tad complex, but it’s really quite simple:

    private void update_list() {
    	ArrayList<string> db_results = new ArrayList><String>();
    	Cursor cursor = db.rawQuery("SELECT value FROM table_of_dics ORDER BY value", null);
	    while(cursor.moveToNext()) {
	    	db_results.add(String.valueOf(cursor.getDouble(cursor.getColumnIndex("value"))));
	    }
	    cursor.close();
 
	    this.list.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, db_results));
    }

I’ll break this one up:
ArrayList db_results = new ArrayList>(); — create an ArrayList, where we’ll store the results to display in the list.

Cursor cursor = db.rawQuery("SELECT value FROM table_of_dics ORDER BY value", null); — create a cursor based on the query (this select statement will return all the values stored in the table, and order them)

while(cursor.moveToNext()) { — while there is still something in the cursor to read (while we still have another row to read)

db_results.add(String.valueOf(cursor.getDouble(cursor.getColumnIndex("value")))); — add the value from the row into the arraylist we created.

} — this is self explanatory, really. :)

cursor.close(); — close the cursor: we’re done with it now. We have all our results in the ArrayList, which we can now set as the adapter:

this.list.setAdapter(new ArrayAdapter(this, android.R.layout.simple_expandable_list_item_1, db_results)); — set the adapter.
- parameter 1: the activity we want it for
- parameter 2: the layout type (we can add multiple widgets to a list item, but simple_list_item_1 is a default in android: simply a single TextView.
- parameter 3: the arraylist which we created and populated earlier.

And that’s it! Don’t forget to close off your class

}

Complete code:

package dreamincode.tutorials.dic_tut4;
 
import android.app.Activity;
import android.os.Bundle;
import android.widget.ListView;
import android.view.Menu;
import android.view.MenuItem;
import android.database.sqlite.SQLiteDatabase;
import android.database.Cursor;
import android.widget.ArrayAdapter;
import java.util.ArrayList;
 
public class dic_tut4 extends Activity {
	ListView list;
	SQLiteDatabase db;
 
	private static final int MENU_ADD = Menu.FIRST;
	private static final int MENU_QUIT = Menu.FIRST + 1;
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        this.list = new ListView(this);
        this.registerForContextMenu(this.list);
 
    	this.db = this.openOrCreateDatabase("dic_tut5", MODE_PRIVATE, null);
    	this.db.execSQL("CREATE TABLE IF NOT EXISTS table_of_dics(value REAL)");
    	this.update_list();
 
        setContentView(this.list);
    }
 
    @Override 
    public boolean onCreateOptionsMenu(Menu menu) {
    	menu.add(0, MENU_ADD, 0, "Add").setIcon(android.R.drawable.ic_menu_add);
    	menu.add(0, MENU_QUIT, 0, "Quit").setIcon(android.R.drawable.ic_menu_close_clear_cancel);
    	return super.onCreateOptionsMenu(menu);
    }
 
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
    	switch(item.getItemId()) {
    		case MENU_ADD:
	        	db.execSQL("INSERT INTO table_of_dics(value) VALUES(" + String.valueOf(Math.random()) + ")");
	        	this.update_list();
    			break;
    		case MENU_QUIT:
    			this.db.close();
    			this.finish();
    	}
 
    	return super.onOptionsItemSelected(item);
    }
 
    private void update_list() {
    	ArrayList<String> db_results = new ArrayList<String>();
    	Cursor cursor = db.rawQuery("SELECT value FROM table_of_dics ORDER BY value", null);
	    while(cursor.moveToNext()) {
	    	db_results.add(String.valueOf(cursor.getDouble(cursor.getColumnIndex("value"))));
	    }
	    cursor.close();
 
	    this.list.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, db_results));
    }
}

Developing for Android, Part III

Dynamic Layouts in Android

No XML in this tutorial! We’ll be completely designing our application in Java, and creating our layout completely dynamically. The benefits of this are that we can add an undefined amount of widgets at run time. This is a pretty useful skill, but not brilliantly documented. (Everything is ZOMG LAYOUT.XML FTW!!1!)

Okay, so let’s get started. We won’t be touching on events in this tutorial, our app won’t actually do anything, per se… it’s merely an example of adding stuff dynamically. You’ll notice how we set the properties through Java, quite similarly to how we define them in the XML.

To start off, remember we’re creating a package, as usual.

package dreamincode.tutorials.dic_tut3;

Next, we’re going to import the usual suspects… Activity and Bundle.

import android.app.Activity;
import android.os.Bundle;

The next two are new. One you may recognise from our layouts before… LinearLayout. We’re also going to use a ScrollView. The reason we’ll be using a ScrollView is that we’re going to add a hell of a lot of widgets, and they wouldn’t all fit on screen. If we don’t put our LinearLayout inside a ScrollView, it simply won’t scroll and the user won’t be able to reach all the widgets!

import android.widget.ScrollView;
import android.widget.LinearLayout;

The last things we need to import are our widgets. We’ll be using an EditText, a TextView, a Button and a CheckBox. We’ve already seen the first three in parts 1 and 2 of this tutorial, but the CheckBox is new. (And I hope the name is self-explanatory for what it is!) ;)

import android.widget.Button;
import android.widget.TextView;
import android.widget.EditText;
import android.widget.CheckBox;

Now it’s time to get on with our code. We’re only going to extend Activity this time, remember we won’t be using events. This bit’s nothing new, so I’ll just throw in the opening of the class and the opening of the onCreate() method. (Note, if you’re not familiar with this, check part 1 and part 2)

public class dic_tut3 extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

Time to get dirty. Dynamic layouts aren’t always the most elegant of solutions, but they can be fun, and sometimes easier to implement. They’re also really useful for certain occasions (such as SmartCalc, my app: it uses a dynamic layout to decide how many textboxes are needed at runtime)

Code first, explanation afterwards.

        ScrollView sv = new ScrollView(this);
        LinearLayout ll = new LinearLayout(this);
        ll.setOrientation(LinearLayout.VERTICAL);
        sv.addView(ll);

LINE 1: Creates a ScrollView object, which is a part of this Activity.
LINE 2: Creates a LinearLayout object, which you hopefully remember from the layout.xml we discussed before.
LINE 3: Sets the orientation of our LinearLayout. Remember how we used android:orientation="vertical" before? Same principal applies here.
LINE 4: Adds the LinearLayout to the ScrollView. Remember, we want to be able to Scroll the LinearLayout View.
NOTE: A ScrollView can **only** have one view added to it. If you try to add more than one, your application WILL force close. If you need to reset it, use ScrollView.removeAllViews(); and re-add whatever you need. (This is why we’re going to add all our widgets to the LinearLayout as opposed to the ScrollView!)

Adding widgets dynamically
Actually, this same principal applies to all our widgets. But I’ll use a few, just to demonstrate. :) This one should look relatively familiar, since we played with TextView.setText() in part 2.

        TextView tv = new TextView(this);
        tv.setText("Dynamic layouts ftw!");
        ll.addView(tv);

Notice how we use addView() on ll, our LinearLayout, just like we added ll to sv? That’s all it takes! :)

Now, let’s do a Button and a EditText. Same principal, just like I said:

        EditText et = new EditText(this);
        et.setText("weeeeeeeeeee~!");
        ll.addView(et);
 
        Button b = new Button(this);
        b.setText("I don't do anything, but I was added dynamically. :)");
        ll.addView(b);

(Remember, when you run the application, the button won’t actually do anything: We haven’t added an OnClickListener! If you want, you may want to revisit the button at the end of this tutorial and try adding an event by yourself. (Use part 2 of this series as a reference if you get stuck)

The next is still the same principal, but I’ve added it in a loop. 20 pointless CheckBoxes, coming up!

        for(int i = 0; i < 20; i++) {
	        CheckBox cb = new CheckBox(this);
	        cb.setText("I'm dynamic!");
	        ll.addView(cb);
        }

This is really just to pad out our layout, so we can really see how useful that ScrollView is. :)

The very last thing we need to do is use setContentView() — similar to how we did before. Remember the this.setContentView(R.layout.main);? Pretty much the same, only now we’re going to use the ScrollView we created earlier instead:

this.setContentView(sv);

And lastly, close off the method and class!

    }
}

Now, if you run this, you'll get a rather crude, but biiiig layout, complete with all the widgets that we added dynamically.

Complete code:

package dreamincode.tutorials.dic_tut3;
 
import android.app.Activity;
import android.os.Bundle;
import android.widget.ScrollView;
import android.widget.LinearLayout;
import android.widget.Button;
import android.widget.TextView;
import android.widget.EditText;
import android.widget.CheckBox;
 
public class dic_tut3 extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        ScrollView sv = new ScrollView(this);
        LinearLayout ll = new LinearLayout(this);
        ll.setOrientation(LinearLayout.VERTICAL);
        sv.addView(ll);
 
        TextView tv = new TextView(this);
        tv.setText("Dynamic layouts ftw!");
        ll.addView(tv);
 
        EditText et = new EditText(this);
        et.setText("weeeeeeeeeee~!");
        ll.addView(et);
 
        Button b = new Button(this);
        b.setText("I don't do anything, but I was added dynamically. :)");
        ll.addView(b);
 
        for(int i = 0; i < 20; i++) {
	        CheckBox cb = new CheckBox(this);
	        cb.setText("I'm dynamic!");
	        ll.addView(cb);
        }
        this.setContentView(sv);
    }
}

See if you can add an OnClickListener to the button, just have a play about with it until you feel fairly confident... I won't be explaining too much about the layouts in the coming tutorials, more on actual features such as SQLite. :)

Developing for Android, Part II

Again, originally written for </dream.in.code> but I like to add this stuff to my blog as well. :)

Basic Layouts and Events

Now that we got the basics done, it’s time to get into developing our first app. It’s not the most impressive application, but it’s a great starting point.

This will most likely seem very familiar if you’ve learned programming on the console in the past. We’re going to prompt for a name, and display a customised message. However, we’ll have a user interface rather than printing on the console. :)

We’re going to start with the XML. We need a layout which we can program around.

Step 0: Creating the project

So we’re on the same wavelength, let’s use the same project name, package, etc.

Step 1: Putting the UI XML together

I’ll run through this one element at a time. it’s all really simple, and you should recognise a lot of this from part 1.

To start, remember, it’s XML:

< ?xml version="1.0" encoding="utf-8"?>

We’re going to use a linear layout, which fills the parent and has a vertical layout (again)

<linearlayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    ></linearlayout>

Next, we’re going to the first TextView. Remember, the TextView is like a “Label”, from .NET. At this point, all we need to do is set the width, height, and set the text. This time, we’re just going to use a static string, rather than linking into the ./res/values/strings.xml file.

    <textview android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Enter your name:"
    />

The next thing we need in our LinearLayout is an EditText. This is basically a TextBox.

    <edittext android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:id="@+id/txt_name"
    />

Only one new thing here, we give it an ID. We need to give it an ID so that we can reference it in the actual Java application.
android:id=”@+id/txt_name” — I’ll call it txt_name, I like to prefix my widgets so they’re easier to remember and reference later on.
Only two things left now: The Button, and the TextView. Nothing new in either of these now.

    <button android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:id="@+id/btn_confirm"
      android:text="Confirm~"
    />
    <textview android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:id="@+id/tv_welcome"
    />

Note that we don’t set the android:text attribute in the final TextView? That’s because we’re going to give it its text when the user presses the “Confirm” button. (btn_confirm)

Lastly, we just need to close off our layout:

Step 2: Bringing it all together in Java

This time we’re going to write our own Java. We’re going to use multiple inheritance (don’t be put off, it’s really very simple) so that we can make our class both an Activity (the main application) and an OnClickListener (to listen for clicks on the button)

First up, remember we’re working on a package:

package dreamincode.tutorials.part_two;

Next, we’re going to import some stuff. The first two are nothing new:

import android.app.Activity;
import android.os.Bundle;

Remember we used both of these in part 1.

This is where it gets interesting, though. We’re going to import three widgets.

import android.widget.TextView;
import android.widget.EditText;
import android.widget.Button;

I won’t explain them… hopefully your memory is good enough to remember that we used these names in the XML layout earlier. :)

The next two will take a little explaining.

import android.view.View;
import android.view.View.OnClickListener;

- We import the View because that’s the parameter which our onClick event requires.
- We import the OnClickListener because, well… we want our Activity to be an OnClickListener, too.

This is where the multiple inheritance comes in. We’re calling our class dic_tut2, and it’s going to extend Activity, just like we did in part 1. It’s also going to implement OnClickListener because we’re going to be listening for clicks on the button.

public class dic_tut2 extends Activity implements OnClickListener {

Now it’s time for the onCreate method. Just like we did in part 1, only with a few extra lines (explained afterwards!)

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        Button b = (Button)this.findViewById(R.id.btn_confirm);
        b.setOnClickListener(this);
    }

Specifically, the last two lines are the new ones. We’re going to create a Button from R.id.btn_confirm (remember, that’s the ID we used in the XML!) Then we’re simply going to set this as the onClickListener for said button. Simple stuff, eh? :)
NOTE: We need to cast the return value of findViewById() to a Button, by default it will return a View.

The very last thing we need to do is set our onClick method: the one which is called when the user clicks the button (after we set this as the OnClickListener for said button!)

    @Override
    public void onClick(View v) {
    	TextView tv = (TextView)this.findViewById(R.id.tv_welcome);
    	EditText et = (EditText)this.findViewById(R.id.txt_name);
 
    	String text = "Hello, " + et.getText().toString() + ".\n\n";
    	text += "Welcome to android development. :)";
 
    	tv.setText(text);
    }

Note that we use findViewById() again to get the TextView for which we’re going to set the text, and also the EditText which contains the user’s name. Then, all we do is create our string (I hope this is nothing new!) and simply setText() on our TextView which displays the final message.

Don’t forget to close off your class!

}

Finally, here’s the complete code. dic_tut2.java:

package dreamincode.tutorials.part_two;
 
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.EditText;
import android.widget.Button;
import android.view.View;
import android.view.View.OnClickListener;
 
public class dic_tut2 extends Activity implements OnClickListener {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        Button b = (Button)this.findViewById(R.id.btn_confirm);
        b.setOnClickListener(this);
    }
 
    @Override
    public void onClick(View v) {
    	TextView tv = (TextView)this.findViewById(R.id.tv_welcome);
    	EditText et = (EditText)this.findViewById(R.id.txt_name);
 
    	String text = "Hello, " + et.getText().toString() + ".\n\n";
    	text += "Welcome to android development. :)";
 
    	tv.setText(text);
    }
}

And the layout, main.xml:

< ?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:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Enter your name:"
    />
    <edittext android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:id="@+id/txt_name"
    />
    <button android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:id="@+id/btn_confirm"
      android:text="Confirm~"
    />
    <textview android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:id="@+id/tv_welcome"
    />
</linearlayout>

Enjoy! :)