An Android application is a collection of tasks, each of which is called an activity. Each activity within an application has a unique purpose and user interface.
Designing application - It has five screens:
• Splash - This screen acts as a startup screen, with the game logo and version. It might also play some music.
• Menu - On this screen, a user can choose from among several options, including playing the game, viewing the scores, and reading the help text.
• Play - This screen is where game play actually takes place.
• Scores - This screen displays the highest scores for the game (including high scores from other players), providing players with a challenge to do
better.
• Help - This screen displays instructions for how to play the game, including controls, goals, scoring methods, tips, and tricks.
There are no real user interface requirements on the Android platform, other than that the application must be stable, responsive and play nice with the rest of the Android system. That said, the best and most popular applications leverage the users’ existing experience with user interfaces. It’s best to improve upon those features, when necessary.
Determining application activity requirements
You need to implement five activity classes, one for each feature of the game:
• SplashActivity - This activity serves as the default activity to launch. It simply displays a layout (maybe just a big graphic), plays music for
several seconds and then launches MenuActivity.
• MenuActivity - This activity is pretty straightforward. Its layout has several buttons, each corresponding to a feature of the application. The
onClick() handlers for each button trigger cause the associated activity to launch.
• PlayActivity - The real application guts are implemented here. This activity needs to draw stuff onscreen, handle various types of user input,
keep score and generally follow whatever game dynamics the developer wants to support.
• ScoresActivity - This activity is about as simple as SplashActivity. It does little more than load a bunch of scoring information into a TextView
control within its layout.
• HelpActivity - This activity is almost identical to ScoresActivity, except that instead of displaying scores, it displays help text. Its TextView
control might possibly scroll.
Using the application context
The application context is the central location for all top-level application functionality. You use the application context to access settings and resources shared across multiple activity instances.
You can retrieve the application context for the current process by using the getApplicationContext() method, like this:
Context context = getApplicationContext();
Retrieving Application Resources
You can retrieve application resources by using the getResources() method of the application context. The most straightforward way to retrieve a resource is by using its unique resource identifier, as defined in the automatically generated R.java class. The following example retrieves a String instance from the application resources by its resource ID:
String greeting = getResources().getString(R.string.hello);
Accessing other application functionality using contexts
The application context provides access to a number of top-level application features. Here are a few more things you can do with the application context:
• Launch Activity instances
• Retrieve assets packaged with the application
• Request a system-level service provider (for example, location service)
• Manage private application files, directories and databases
• Inspect and enforce application permissions
Launching Activities
There are a number of ways to launch an activity, including the following:
• Designating a launch activity in the manifest file
• Launching an activity using the application context
• Launching a child activity from a parent activity for a result
Designating a launch activity in the manifest file
Each Android application must designate a default activity within the Android manifest file. In the manifest file of a Droid1 project, DroidActivity might be designated as the default activity.
Other Activity classes might be designated to launch under specific circumstances. You manage these secondary entry points by configuring the Android manifest file with custom filters.
Launching activities using the application context
The most common way to launch an activity is to use the startActivity() method of the application context. This method takes one parameter, called an intent. We will talk more about the intent in a moment, but for now, let’s look at a simple startActivity() call.
The following code calls the startActivity() method with an explicit intent:
startActivity(new Intent(getApplicationContext(), MenuActivity.class));
Launching an Activity for a Result
Sometimes an activity wants to launch a related activity and get the result, instead of launching an entirely independent activity. In this case, you can use the Activity.startActivityForResult() method. The result will be returned in the Intent parameter of the calling activity’s onActivityResult() method.