Android Signing Apps, Logging, Start Data Persistence

CS185c

Chris Pollett

Sep. 23, 2009

Outline

Getting your app on a Phone for Debugging
Handling rotations in Android.
Logging
Data Persistence

Getting your app on a Phone for Debugging

A lot of information about developing on a test phone can be found at:
http://developer.android.com/guide/developing/device.html.

In your AndroidManifest.xml file you can set the application tag to allow for debugging:

<application android:icon="@drawable/two_shoes" android:label="@string/app_name"
     android:debuggable="true">

On the device, you need to go to Settings, then Applications > Development. Set USB Debugging to true.
Next we need to sign the application.

Signing your App with a Debugging Certificate

Select your project, right-click (CTRL-click on a Mac), and select Android Tools > Export Signed Application Package.
Follow your way through the wizard, if you haven't created a keystore yet, you need to create one (can do as part of the wizard). You also might need to create a key if you don't have one.
When you compile and run, your project should go to your phone.

Handling Rotations in Android

We can change between Portrait or Landscape mode using CTRL-F12 in the emulator.
We've already seen that we can switch between two views in Android by calling the Activities: setContentView(R.layout.nameOfLayout) method.
So if we want our app to look good in both Portrait and Landscape orientation we could create two views -- one for each orientation.
This just leaves the problem of getting some code to run, when the orientation changes.
When the orientation changes, recall the system goes through the process of saving instance state, pausing, stopping and destroying, then creating a new instance of the activity.
So we can just check for the orientation change in onCreate.

Handling Rotations in Android - cont'd

So we merely have to override this method with our code:

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if(getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) 
        {
        	 setContentView(R.layout.main_portrait);
        }
        else
        {
       	     setContentView(R.layout.main_landscape);       	
        }
    //other code of onCreate
    }

Alternatively, one could try to override the onConfigurationChanged(Configuration) method of Activity. However, for this to work we'd need to also change the AndroidManifest file's <activity>'s android:configChanges attribute ORing (take the | of the different config properties you want to be notified on) in orientation.

Logging

As with the iPhone, Android supports logging events.
To use logging you need to import android.util.Log .
To see a list of log messages one can use LogCat by going to Window > Show View > Other... > Android > LogCat .
There are several types of log messages you can write:
- Log.e(): Errors
- Log.w(): Warnings
- Log.i(): Information
- Log.d(): Debugging
- Log.v(): Verbose

Logging Example

Each of these logging methods takes either two or three arguments. The first is the tag, which is usually String name of the Activity; the second parameter is the message you want. If there is a third parameter it is a Throwable object which might be caught be some enclosing code.
```
Log.i("Hw1", "Main ViewCreated");
```

Storing and Retrieving Data

Like the iPhone, Android has a mechanism for storing application information persistently.
The three main ways to do this are: using a SharedPreferences object, through the Android filesystem, or using SQLite.
We will look at each of these in turn.

Using Preferences

You access a android.content.SharedPreferences object through the Context you are working in.
Many Android classes have a reference to, or themselves extend from Context.
For example, both Activity and Service extend Context.
A Context object includes a getSharedPreferences(String prefname, int accessmode); method.
prefname will correspond to a file prefname.xml that is stored in /data/data/PACKAGE_NAME/shared_prefs in the Android phone's filesystem.
accessmode - corresponds to one a list of predefined static constants in Content. This in turn corresponds to Unix filesystem modes: Context.MODE_WORLD_READABLE, Context.MODE_WORLD_WRITEABLE, etc. You can OR these together using +.
If you want to browse the emulator's filesystem one can, in Eclipse, go to: Window > Show View > Other... > Android > File Explorer.

More on Using Preferences

You typically would write preferences, either when the activity starts in onCreate, or when you are just about to switch activities.

Here is an example of some code to open a SharedPreferences and write to it:

SharedPreferences myPref = getSharedPreferences("MY_APP_PREFS", 
   Context.MODE_WORLD_WRITEABLE + Context.MODE_WORLD_READABLE);

Log.i("My_Activity", 
   "Old Some_Key" + myPref.getString("Some_Key","Key did not exist") );
//second arg is returned if key did not exist

Editor myPrefEditor = myPref.edit();
myPrefEditor.putString("Some_Key", "Some Value");
myPrefEditor.commit();