My First Android Application

Overview:

1. Eclipse Breakdown2. Activity Breakdown3. XML Files4. Debugging Options5. Incorporating Databases6. Sample Code/Output

Additional Resources

(1)Eclipse Breakdown

Eclipse is a cross-platform IDE (Integrated Development Environment) for Java programming. It supports Android development by extension (Android programs also being written in Java). Android development through Eclipse requires certain plugins/features to be installed and modified however, so don’t expect to begin developing right after installing Eclipse.

The basic “workspace” can be seen in the following, with key features circled/numbered for your convenience, and explained more thoroughly below:

42

3

1

1) As you can see, the current, working project is DatabaseTest. The project folder is expanded, showing all relevant folders and files of the project. Some important files to note:

a) src/package_name/ : contains all classes, activities, and other object oriented features of the application. In the above example, the only activity class is the DatabaseGUI.java file.

b) gen/package_name/ : contains R.java, an automatically-updated java file which contains information about the application. It is strongly discouraged to edit or touch this file in any way.

c) Library or platform : contains all necessary .jar files for compilation. In most Android applications, this will contain “android.jar”, and “usb.jar” and “maps.jar” if the platform is the Google API version.

d) assets/ : contains application-private files for internal use by the application.

e) res/ : contains drawable folders which hold all non-system images used by the application. In addition, it contains the layout folder, which holds all .xml layout files for the application (see section 3 for more information). Finally contains the values folder, which contains strings.xml, an xml file designated for storing basic string values (application name, activity names, etc.). Also sometimes contains a “raw” folder, which functions similarly to the assets directory in storing application-private files.

2) This tabbed portion contains all open files of the application. Try not to open unnecessary files, as it can become cluttered very quickly.

3) This window usually contains a host of useful windows pertinent to the current perspective. Since the current perspective is “Java”, the default tabs are:a) Console : used in Android development to update status of emulator/device activity,

such as the launching of activities.b) LogCat : a very useful debugging tool for Android development; functions similar to the

Console window for regular Java development by becoming a useful output screen for any text-printing statements.

4) Perspectives are a very important feature of Eclipse. If you’ve ever worked with Eclipse before, you know about the Java/Debug perspectives, which allow programming in a normal environment and access specific debugging information respectively. An Android-specific perspective however is the DDMS, whose default windows allow you to interact

with Android-based devices (emulated or not) very easily. By default it contains “Devices” and “File Explorer” tabs, in addition to the normal “Console” and “LogCat” frames usually included in the Java perspective.a) Devices : Used to monitor the status of Android devices.b) File Explorer : Used primarily to push/pull files from an Android device. Can also be used

to delete files, move files, and perform other formatting tasks.

(2)Activity Breakdown

An activity is basically the same as a java application class. Represented as code, every basic activity will have the same basic features:

Line 1: Package declaration – a necessary line which declares what package this class is a member of.

Line 3-8: Import statements – define any library resources which the class depends on. Eclipse actually has a built-in automatic-import hotkey (Ctrl-Shift-O). Using this will tell Eclipse to automatically generate any import statements not already declared and necessary for the program’s execution. This is a very useful tool.

Line 10: Extension – Make sure to extend your class as an activity! Obviously not all of your classes are going to be Activity classes, but those that are must extend Activity.

Line 13: onCreate method – this method is called when the Activity is first created, and must be implemented by every Activity class. This class will perform any tasks that the class must perform prior to user interaction.

Line 14: Calls the parent onCreate method – another necessary line in the file. Also, this must be the first line in the onCreate method!

Line 15: Sets the content view – this line basically assigns a certain XML file to act as a GUI screen for this Activity. In this case, the XML file “main.xml” is used.

(3)XML Files

XML files are the primary tools for GUI design in Android development. Although it is not necessary to use then to develop a GUI for your application, it is highly recommended. Designing the user interface in an XML file allows programmers to visually see every change they enact, and format things very easily. It also allows them to revise and change the GUI separate from the .java files/classes, allowing for overall better flexibility and code readability/reliability.

XML files can be edited in two ways: graphically, and with raw code. The following is an example of the graphic design of the xml file:

XML files can also be edited by changing the raw code, but this is much messier and not recommended for those who do not have extensive experience with XML programming. Here’s an example of the code of a very basic xml file:

While it would be possible to give you some basic GUI design tips, the best way to learn how to create the GUI portion of an application is to design it yourself. Experiment with different layouts, forms, and widgets, and find what works best for you.

(4) Debugging Options

LogCat:

One of the quickest debugging methods, this involves outputting certain values to the LogCat pane. This can help check values of important variables at specific times in the program. The only requirements for using this are to import the proper LogCat packages, and use correct syntax.

Debug mode:

Using TextViews to debug: This method is useful if you want to keep track of certain numbers/values in the GUI of the application itself, rather than having to check values in Eclipse. The process involves continual updating of the TextView by way of the setText() method (perhaps on a button click, or other event).

Some helpful tips:

I know this is common advice, but if your application just won’t seem to work (random crashing on starting, etc.), try restarting Eclipse. Try restarting the emulator. Maybe even your computer. If a certain Activity won’t load properly, you might try cutting and pasting the code back into the file. I can’t tell you how many hours can be wasted looking through code, only to restart something and have the application magically begin working again.

If your emulator is slow or takes a long time to boot up, don’t worry! There’s not much you can do to expedite the process, so you might as well just use the time productively. Even once the emulator is up and running, it can be very sluggish, and you might have latency issues that don’t exist on a real device.

Test your application on the device you intend to run it on if possible. This does not mean an emulated version, but the real thing. Emulators are nice to test out ideas, but make sure the application is debugged on a real device before you call it “finished”. Of course this applies more to actual development than to homework assignments, but it’s still a good practice to have.

Last but not least, look things up online! There are a host of online resources out there for Android development, I suggest using them.

(5) Incorporating Databases

Implementing databases in your Android applications is a relatively simple task, provided that you know some basic SQL (Structured Query Language). Even without a good

comprehension of database programming, getting a database up and running is by no means a difficult feat.

The first step is building the database itself. This can be done with the following code snippet, placed inside the appropriate Activity:

SQLiteDatabase myDB = null;myDB = this.openOrCreateDatabase("DatabaseName", MODE_PRIVATE, null);

where “DatabaseName” can be whatever you want to name the database.

Now that the database is created, we need to create a table, and insert some information into the table. This is done using simple SQL commands, in the following code snippet:

myDB.execSQL("CREATE TABLE IF NOT EXISTS " + "Table1" + " (Field1 VARCHAR, Field2 INT(3));");

where, once again, “Table1” can be whatever you want to name the table, and Field1/Field2 can be whatever you want to name your fields. The “VARCHAR” and “INT(3)” denote what type of data Field1 and Field2 contain. Obviously, you can incorporate as many fields of as many types of data as you see fit. It’s important to note that the .execSQL command can be used to perform any SQL command which does not return data (i.e. don’t use it for SELECT commands). Also, this specific command will create the table only if it does not already exist; it will not delete the contents of the table, merely cause all actions to append it.

Now, to insert some data, we will use the following command:

myDB.execSQL("INSERT INTO " + "Table1" + " (Field1, Field2)" + " VALUES ('Bob', 10);");

Here, we are inserting a single entry which has Field1 equal to ‘Bob’, and Field2 equal to 10.

To access data from our table, we must use a Cursor object. Cursors are used to manipulate database data, and are used for queries. We begin by creating our cursor, and querying the database one of two ways:

Cursor queryCursor = null;

Here we use the standard SQL code, simply executing our query with the .rawQuery command.

queryCursor = myDB.rawQuery("SELECT * FROM Table1", null);

Here, instead of using the actual query, we let our Cursor object build the query for us, based on our parameters, using the .query command.

queryCursor = myDB.query("Table1", null, null, null, null, null, null, null);

Both Cursor objects are equivalent, and have both executed the basic query of selecting every row of data from Table1.

Our last step is to actually access the data. This can be achieved through a simple while loop, and using our Cursor object to access the data for us:

String data="";queryCursor.moveToFirst();while(!queryCursor.isAfterLast()){

data+="{" + queryCursor.getString(0) + ",";data+=queryCursor.getInt(1) + "}";queryCursor.moveToNext();

}

The basic idea of this code is to use the Cursor object to return the value of each variable of each row, store the data into a basic String variable called “data”, and then move onto the next row. Note that queryCursor.getString(0)corresponds to the first variable, and queryCursor.getInt(1) corresponds to the second. In this way, it is possible to retrieve each data member individually, or simply store them all together in a String object (like we did in this example, with the String variable “data”). The final step is to close the database, which is just a simple, one-line command:

myDB.close();

Now that we have the entirety of database’s data stored in a String variable, it’s possible to output it in a variety of ways, depending on what purpose the data will serve. If it’s for debugging purposes, we can call a log statement to output the data to the LogCat pane. If however we want to output it to the screen in an Activity, it’s simple to just use a TextView object.

Continuing our example Activity from earlier, we can use the following code to allow us to interact directly with the TextView object present in our XML file (the id is textview1):

TextView tv1 = (TextView) findViewById(R.id.textview1);tv1.setText(data);

This concludes our final step, and will display each data member to the screen with the specified formatting.

(6)Sample Code/Output

The following code encompasses everything addressed in this handout, and provides a visual representation of the Activity as a whole:

(The XML file is the same as before – “main.xml” from Section 3 with a LinearLayout format, and 1 TextView object with id “textview1”)

Additional Resources

http://developer.android.com/ http://stackoverflow.com/