It has been a long time since I last posted to my journal. I’ve had a few hectic weeks as I’ve been working to finish the Android games course, I’ve started working with GH Hovagymian on his seesaw project, and had to prepare to share my second semester project from ITP at the Sony Wonderlab.

Today I am going to provide additional information regarding the structure of Android applications. A few weeks ago I wrote a post about the Java View class, which provides the basic building blocks for creating user interfaces. Today I will focus on providing an overview of the Java Activity and Thread classes.

Activities
An activity is a focused thing that an application can do. Almost all activities enable some type of interaction with the user. It is important to note that an activity is not an application. Applications are referred to a as a task in Android. Tasks usually contains multiple activities and often other components such as views, services, etc.

All activities live inside a window on the screen. Activities can be presented to the user as full-screen windows, as floating windows or embedded inside of another activity. There are two main methods that almost all  Activity subclasses will implement. These methods play crucial roles in the processes of setting up and leaving activities:

• onCreate(Bundle) is where you initialize your activity. Most importantly, here you will usually call setContentView(int) with a layout resource defining your UI, and using findViewById(int) to retrieve the widgets in that UI that you need to interact with programmatically.
• onPause() is where you deal with the user leaving your activity. Most importantly, any changes made by the user should at this point be committed (usually to the ContentProvider holding the data).

Activities are managed via an activity stack. The most recent activity is always added to the top of the stack. The previous activities remain on the stack and can be reactivated simply by removing the new activity from the stack.

The startActivity(Intent) method starts new activities by placing them at the top of the activity stack. It takes a single argument, an Intent, which describes the activity to be executed.

Activities ultimately have three main different states: foreground activity, visible activity, background activity. Foreground activities live on top of the activity stack. Users are only able to interact directly with activities that are in this state.

Visible activities can be viewed by the user but they are not at the top of the stack. The user usually cannot interact directly with these activities until those that are located higher in the stack are removed from the stack.

Background activities are lower down in the stack and are not visible to the user. These are the first types of activities to be killed when an Android device needs additional space.

To switch between these various states seven activity methods can be implemented in an Activity subclass (two of which I already discussed above). Here is the full list:

• protected void onCreate(Bundle savedInstanceState);
• protected void onStart();
• protected void onRestart();
• protected void onResume();
• protected void onPause();
• protected void onStop();
• protected void onDestroy();

Here is a graphical representation of the Android Activity lifecyle, from the Android Developer website.

Activities can be killed by the OS at any time if they are not in the foreground state. The following methods can be called when an activities location in the stack is changed: onPause(), onStop(), and onDestroy() – however, only the onPause() is guaranteed to be called before a process is killed. Therefore, it is recommended that you should use onPause() to store any data when you are removing an activity from the foreground.

Threads
Threads enable android applications to run more than one activity at a time. Threads can be created in two ways: by extending the thread class and overriding its run() method; or creating a class the implements the runnable interface. In both cases, the start() method is called within an activity to actually execute the new Thread.

For my game I leveraged the code example provided by Matt. He created an extension of the Thread class called GameThread that includes the required methods (run, start, and stop). It also features a few functions that are meant to be overwritten by the main activity when it creates the thread during runtime. I will post the current code and screenshots of my game by early next week.