Android – Part 6 – Menus and XML File Processing



Android – Part 6 – Menus and XML File Processing

Current 04/11/2012

Menus

An Android Activity can have an options menu. This is a grid of labeled rectangles that appears at the bottom of the screen when the user presses the dedicated hardware menu button (usually a little 2 x 2 array of squares). The menu that appears will overlay the bottom part of the screen. Normally you will see up to two rows of menu options. If there are more, they are accessible by pressing a “more” button on the menu grid. Each menu option can have a single submenu, but additional sub-sub-menus are not allowed.

When menu items are used to jump to other screens (Activities) they have the same function as a tab button. However, since they only appear when the hardware menu button is pressed, they do not continually take up screen space. Also, they might not be available all screens – the programmer has to decide and implement an options menu separately for each screen that requires one. So for any screen, the options menu could be the same or different than other screens, or could be missing entirely.

In addition to options menus, Android also supports context menus. A context menu is a small pop-up menu, typically triggered by a long press on a widget with a context menu.

Some typical uses and examples of these are given in the text, Beginning Android 2, in Chapter 11.

has an excellent reference about menus in general with links to all the usual suspects.

The use mentioned above, using an options menu item to jump to a different Activity, is covered below.

Option menus are created and set up in a callback method named onCreateOptionsMenu(). This method is an @Override method and it gets a menu argument when called. So the method signature is:

@Override

public void onCreateOptionsMenu(android.view.Menu menu)

In this method you need to do the following, in order:

1. Call the superclass method, passing it the menu argument

2. Define the captions and the actions to be taken for each menu item. The specification of a menu item action varies with the desired action (see below).

3. Return true so the menu will display

(Note: options menus can also be defined in xml and “inflated” in your code.)

To do Step 2 for the “jump-to-new-screen” action, you will code the something like the following for each menu item:

menu.add(“Menu Caption”)

.setIntent(new Intent(this, SomeActivity.class));

Here, the call to add() adds a MenuItem to menu and also returns (or “becomes”) a MenuItem. Then the setIntent() method is called for that MenuItem (to see this, just ignore the line break: add(---).setIntent(---);

A longer – but possibly clearer way would be:

MenuItem item = menu.add(“Menu Caption”);

item.setIntent(new Intent(this, SomeActivity.class));

You can sometimes chain a series of methods using this syntax:

menu.add(“Menu Caption”)

.setIcon(android.R.drawable.ic_menu_view)

.setIntent(new Intent(this, SomeActivity.class));

However, this will not always work, depending on the order of the methods called. For example, in the example above, reversing the order of the two sets results in a compile error indicating that setIcon() is not a method of Intent.

This is all you need to do if the intent is to jump to a different Activity (screen). But don’t forget to add all the “SomeActivity” classes to the android manifest file. (You will probably have several menu items, each specifying a jump to a different Activity.)

For each such class, add a child element to similar to the following:

Here, the label can be anything, but name indicates that a class file named About.class is going to be used in the project. If you forget to include these your app will terminate with the “closed unexpectedly” message.

Also, remember: if you are using an options menu in the more traditional sense of allowing the user to set options, you will need to @Override onOptionsItemSelected()to respond to menu clicks (as demonstrated in the text).

XML File Processing

• XML files provide a structured way to store data in a convenient (if somewhat tedious to code) manner.

• XML files are pure text files.

• XML files are good at representing repeated elements with a given structure, and in particular, xml can represent a hierarchical (parent-children) structure very nicely.

• XML was designed to describe data and is self-describing.

• XML tags are not predefined in XML. You must define your own tags. Generally, the tags contain data structured as a name-value pair, where the name describes the data element and the value, always a quoted string, supplies a value. Each of these name-value pairs is an attribute.

• XML is commonly used to facilitate exchange of data among disparate computer systems.

You have seen enough xml in the course so far to have a good intuitive knowledge of how it works and what it looks like. If you feel you need a well-organized brief introduction to xml, try the following web site:



You can create an xml file for your App’s project in Eclipse by

1. first selecting the your-project\res directory in Eclipse’s left-hand Project Explorer window.

2. then, select Eclipse’s File/New/Other and

3. then in the wizard that appears, select XML/XML File (not Android/XML file).

4. click on Next and you should see your-project\res selected as the parent folder.

5. Supply the xml file name you want and

6. Click Finish to enter the wizard to write the file contents (you have a Design and a Source (text) screen to use in the wizard).

7. When finished, save the file.

So given the use of xml to allow the exchange and storage of data, the natural question that arises is: how do we extract the data from the forest of tags and < and /> and so on?

For Android and Java, you can use a class that implements the XmlPullParser interface that allows us to write code to discover the names and corresponding values embedded in an xml file. The names and values can be retrieved as Strings and then converted or used as necessary.

First, declare:

XmlPullParser xpp;

Then, when you are ready to open and parse the file:

xpp = getResources().getXml(R.xml.my_xml_file);

Here, the argument is the xml file’s constant as defined (automatically generated) in the R.java file. It comes from the file my_xml_file.xml (in this example) stored in the project’s \res\xml directory. The xpp object implements the interface. Complete details of the methods available in this interface can be found at



Of course, the xml parser has no idea of the specific structure, size, tag names, or attribute names or values in your file. It does have methods to scan through the file, test what kind of an element it gets at each step, and to extract attribute values.

Normally the logic for this is a while-loop:

while (xpp.getEventType()!=XmlPullParser.END_DOCUMENT)

{

// body processes an xml tag each time through the loop

// bottom of loop gets next element:

xpp.next();

}

The “priming read” is done automatically.

The whole loop should be in a try/catch block that catches IOException and XmlPullParserException.

You can use getEventType() to test for a beginning or ending element tag:

if (xpp.getEventType() == XmlPullParser.START_TAG)

or

if (xpp.getEventType() == XmlPullParser.END_TAG)

Then, if you are just starting an element, you can test which kind it is:

if (xpp.getName().equals("person"))

and then you can get the various attribute names and values by index number:

attr0Name = (String)xpp.getAttributeName(0);

value0 = (String)xpp.getAttributeValue(0);

attr1Name = (String)xpp.getAttributeName(1);

value2 = (String)xpp.getAttributeValue(1);

Here is a brief example. First an xml file representing hourly employees for a Fall payroll:

[ go to next page ]

Code to pull out the data values and display them.

XmlPullParser xpp;

xpp = getResources().getXml(R.xml.empl);

// should check that xpp is not null

try

{

while (xpp.getEventType()!=XmlPullParser.END_DOCUMENT)

{

Log.i(TAG, "in loop");

if (xpp.getEventType() == XmlPullParser.START_TAG)

{

Log.i(TAG, "got start tag");

Log.i(TAG, xpp.getName());

if (xpp.getName().equals("employee_hourly"))

{

// assume 3 attributes

Log.i(TAG, (String)xpp.getAttributeName(0));

Log.i(TAG, (String)xpp.getAttributeValue(0));

Log.i(TAG, (String)xpp.getAttributeName(1));

Log.i(TAG, (String)xpp.getAttributeValue(1));

Log.i(TAG, (String)xpp.getAttributeName(2));

Log.i(TAG, (String)xpp.getAttributeValue(2));

}

if (xpp.getName().equals("check"))

{

Log.i(TAG, "got 'check'");

// assume 2 attributes

Log.i(TAG, (String)xpp.getAttributeName(0));

Log.i(TAG, (String)xpp.getAttributeValue(0));

Log.i(TAG, (String)xpp.getAttributeName(1));

Log.i(TAG, (String)xpp.getAttributeValue(1));

}

} // end "START_TAG"

Log.i(TAG, "get next");

xpp.next();

} // end while

} // end try

catch (XmlPullParserException e)

{

Log.i(TAG, "xml_pp exception " + e.getMessage());

}

catch (IOException ioe)

{

Log.i(TAG, "io exception");

}

You should be able to embed this in a simple app’s onCreate() and watch the Logged output. Then you can play with it by adding additional employees or even other employee types (employee_salaried). You can add more Log statements as well to see other bits of information (e.g all the event start tag names) and even other events (like END_TAGs).

Also see the text’s example on pages 241 - 243.

This interface has many more methods that allow you to do more sophisticated and flexible parsing of xml files. For example, the code above assumed a certain number of attributes in each tag. However, the actual number in many xml files might vary. How do you know when to stop doing getAttributeName() and –Value() ?

Well, when you encounter a START_TAG you can call getAttributeCount() to find out how many attributes are in this tag. Scan the web page given earlier to learn more about XmlPullParser and its capabilities.

................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download