Outline

• Basic Android Application Lifecycle
• Creating Views with Different Layouts
• Subclassing Activity

Application Framework

• Today, we are going to look at more interesting Android projects then the simple Hello World one we built slightly over a week ago.
• 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 Androids Dalvik VM.
• 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.

More on Applications

• When a user runs an application, Android starts it and brings in to the foreground.
• It is possible for a user to invoke another application within an application. All the programs and screens of applications get stored on the application stack which is managed by the activity manager.
• The back button can be used to go back in this stack.
• User interface screens are typically represented by subclasses of the Activity class, and a given application may have one or more activity.
• An application is thus one or more activities together with a process to contain them.
• Applications can outlive the process used to contain its activities.

Activity Lifecyle

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

Intents

are mechanisms for defining a specific action. For example, "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 contentt 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 main.xml in a text editor.
• It should look 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="@string/hello"
      />
  </LinearLayout>
  

• Notice that we have a LinearLayout tag. This says each item contained with this tag should be placed in a line.
• 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 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/guide/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"
      />
  <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

• Notice we have the line: @+id/button. When we compile our project Android resource compiler (aapt) 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.ViewExperiment;
  
  public final class R {
      public static final class attr {
      }
      public static final class drawable {
          public static final int icon=0x7f020000;
      }
      public static final class id {
          public static final int button=0x7f050000;
      }
      public static final class layout {
          public static final int main=0x7f030000;
      }
      public static final class string {
          public static final int app_name=0x7f040001;
          public static final int hello=0x7f040000;
      }
  }
  

Using The Button

• One easy way to handle events in our application's Activity is to have it implement an event listener. For example, we could have ViewExperiment class in ViewExperiment.java in src/org.pollett.ViewExperiment 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="2" />
  </manifest> 
  

Screenshots