Platform Architecture

Today, we are going to look at more interesting Android projects than the simple Hello World one we built slightly over a week ago.
If you are following along in our Android book, Chapter 1 and 2 cover up to that first app (although running on hardware which we'll get to in a bit is also discussed).
Chapter 3-4 more directly talks about Android programming.
If you recall, Android is built on top of Linux, but we program applications in Java.
These applications are compiled to .dex files rather than .jar files which run on Android's Dalvik VM.
More explicitly, when you run an App in Android, a new process is created and the Dalvik VM is run in this process. Your app is the executed on this VM.
Your app in turn may have several threads.
We next look at the libraries/frameworks associated with running your application...

Application Framework

The libraries in Android are different from Java SE and ME but have a fair amount of overlap.
The Application Framework layer of Android has several key components:

Activity Manager
controls the lifecycle of applications

Content Manager
encapsulates data that needs to be shared between apps

Resource Manager
manages all that is in your program that is not code

Location Manager
handles informations such as GPS which tells the phone where it is

Notification Manager
handles events such as arriving messages, appointments, etc.

Quiz

Which of the following is true?

Calling a release on an Objective-C object invokes the runtime garbage collector which immediately destroys the object.
In HTML5, tag attributes whose name begins with 'data-' are user-defined attributes
UILabel is a subclass of IBOutlet.

Some Lifecycle Methods

onCreate(Bundle) is called on first startup of an activity. Bundle is either null, or information saved by onSaveInstanceState().
onStart() is called just before the activity is displayed to the user.
onResume() is called when your activity can start interacting with the user. (Can draw an initial screen here)
onPause() is called when the activity is about to go into the background because some other activity has been launched. This is where you should save any persistent state of your program
onStop() is called when the activity is no longer visible to the user. (System might just terminate your process rather than calling.
onDestroy() is called before your activity is gotten rid of (if the system doesn't just kill your process).
onSaveInstanceState(Bundle) is called to save the state of the current activity's instance. you won't need to override this
onRestoreInstanceState(bundle) is called when the activity is being reintialized if its state was saved using onSaveInstanceState().

To test state saving code you can just test how your app works when the screen orientation changes. In the emulator you can test this by hitting CTRL-F11.

Application Building Blocks

Here are some key building blocks of an Android App:

Activities: used for application interface screens. Can be configured using a Context class
Intents: are mechanisms for saying you want something accomplished, but you are leaving the details of how to do it up to Android/another acitivty. For example, "switch between activities of the same app", "make a phone call", "send an email", etc.
Services: are background tasks. For example, you might have a music player which keeps playing even when the user switches to a different program.
Content Providers: are a data source wrapped up in some object that is accessed using some standard API. For example, there is a content provider for contacts that allows you to get names, addresses, etc.
Resources: text strings, bitmaps, or other small pieces of noncode info. These are created and stored in the res directory. The Android resource compiler processes these according to which subfolder they are in: res/drawable, res/layout, etc. After processing these resources it generates a class R (in gen folder) which contains constant id's which can be used to refer to these resources.

Fun with Views

Let's start making some more Android Programs...
If we create a new project, and click on gen we see the R class mentioned on the last slide is not generated yet.
In the Package Explorer pane, look at res/layout and open activity_main.xml in a text editor.

It should look like:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.example.secondproject.MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />

</RelativeLayout>

Notice that we have a RelativeLayout tag. This says each item contained with this tag should be placed relative to the last item.

Another possibility is a LinearLayout for example:

<?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="@string/hello_world"
    />
</LinearLayout>

The orientation attribute can be horizontal or vertical and says in this case we want to place items one beneath another.
The next two attributes layout_width, layout_height say how we want items to fill this line. Another possibility is: wrap_content
On the layout, we have a TextView which essentially draws some text. We can view it as like a label.
Other things we might have in a Layout are: Button, CheckBox, ImageView, EditText, RadioGroup (which has RadioButton's on it), AnalogClock, etc.
Notice the TextView tag has a text attribute: this pulls strings from the strings.xml file in res/values
You can have multiple layouts in the same file, you can nest them, etc.
Some other possible choices for layout are: RelativeLayout, TableLayout, ListLayout, etc.
A good link for different layout possibilities is:
http://developer.android.com/resources/tutorials/views/index.html.

A Layout with a Button

Let's add a button to our 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:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    />
<ImageView
    android:id ="@+id/my_photo"  
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:src="@drawable/myphoto"
	/>
<Button android:id ="@+id/button"
 android:text="Click Me"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
/>    
</LinearLayout>

Comments on the New Layout

We are making use of an ImageView. To get this to compile I created a png image myphoto.png and placed it under drawable-mpdi folder. The android:src attribute then is set to "@drawable/myphoto" to refer to it.
Notice we have the line: @+id/button. When we compile our project Android resource compiler (aapt -- Android Asset Packaging Tool) will add a line to the id class for this button to the R class in gen.

This class will look like:

/* AUTO-GENERATED FILE.  DO NOT MODIFY.
 *
 * This class was automatically generated by the
 * aapt tool from the resource data it found.  It
 * should not be modified by hand.
 */

package org.pollett.androidtest;

public final class R {
    ... //lots of junk we're skipping in ...
    public static final class id {
    ...
        public static final int button=0x7f05003d;
    ...
    }
    ...
    public static final class string {
        ...
        public static final int hello_world=0x7f040000;
    }
    ...
}

Using The Button

One easy way to handle events in our application's Activity is to have it implement an event listener.
In an old project I had, a app similar to the one we just started where the images showed a person taking off and putting on shoes.

The base activity was ViewExperiment class in ViewExperiment.java in src/org.pollett.ViewExperiment. To add the ability to respond to buttons I had it implement OnClickListener:

package org.pollett.ViewExperiment;

import android.app.Activity;
import android.os.Bundle;
import android.content.Intent;
import android.view.View;
import android.view.View.OnClickListener;


public class ViewExperiment extends Activity implements OnClickListener {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        //Here is where we set up the button when the Activity starts
        View button = this.findViewById(R.id.button);
        button.setOnClickListener(this);
    }
    
      
    public void onClick(View v)
    /**
       Handles clicks events for this activity -- new code we added

       @param v - view that event is coming from
    */
    {
    	switch(v.getId())
    	{
        /* handle the case coming from thing on our Activity with id button 
        */
    	case R.id.button: 
          // launch the SecondView Activity
    	  Intent i = new Intent(this, SecondView.class); 
    	  startActivity(i);
    	  break;
    	}
    }
}

The SecondView Class

By right-clicking on the src folder we can choose to add a new class and add the following code to it:

package org.pollett.ViewExperiment;

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


public class SecondView extends Activity {
	
	@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
      
        // here we use a new layout that we will need to create
        setContentView(R.layout.second);
    }
}

second.xml

We will put the code for the layout for the SecondView class in the res/layout folder in the file second.xml. This looks like:

<?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="second screen"
    />
</LinearLayout>

AndroidManifest.xml

The last thing we need to do before our project will work is to add a new activity to the AndroidManifest.xml file. Here is the code of that file:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="org.pollett.ViewExperiment"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".ViewExperiment"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".SecondView"
                  android:label="@string/app_name">
        </activity>       
    </application>
    <uses-sdk 
        android:minSdkVersion="8"
        android:targetSdkVersion="20"
     />
</manifest>

Android Layouts, Activities, and Intents

Outline