Android coding guide lines

Topics:
1. Android Project Structure in Eclipse:
Source
Standard Comments
Naming Conventions
Variable Scope
GEN
ANDROID <version number>
Referencing a library project
Add jar files into Android Project
ASSETS
BIN
RES
Drawable
Layout
Various Layouts in Android
Values
Menu
AndroidManifest.xml file

Topics:
AndroidManifest.xml file
Support different screen size in android
Android Exceptions
Upload apk into Android Market
2.Effective Eclipse
3.Best Code Review Tools for Eclipse

Android Project Structure in Eclipse:
When we start a new Android project in Eclipse, it will
automatically creates a lot of files and folders for us.
We will look at the meaning and functions of each of these folders
in the Android project structure one by one.
After you create a new project in eclipse, you will see the
following top-level folders in your package explorer.

Structure of the Android Project:

Here is the brief description of important files/folders in the Android
project structure:
/src: The src folder contains the Java source code files of your
application organized into packages.
You can have more than one package in your Android application.
Its always a good practice to break the source code of your application
into different packages based on its core functionality.
All the source files of your Activities, Services etc. Goes into this folder.
In the above screen, you can see the source file of the Activity that we
created for our project.
We have to follow few standards while coding in java Classes.

© Changepond Technologies 2010-11. All rights reserved.
Standard Comments:
Every file should have a copyright statement at the top.
Then a package statement and import statements should follow, each
block separated by a blank line.
Then there is the class or interface declaration. In the Javadoc
comments, describe what the class or interface does.
Every class and nontrivial public method you write must contain a
Javadoc comment with at least one sentence describing what the class
or method does. This sentence should start with a 3rd person
descriptive verb.

Use TODO Comments:
Use TODO comments for code that is temporary, a short-term
solution, or good-enough but not perfect
TODOs should include the string TODO in all caps, followed by a
colon:
// TODO: Remove this code after the UrlTable2 has been checked in.
If your TODO is of the form "At a future date do something" make
sure that you either include a very specific date ("Fix by November
2005") or a very specific event ("Remove this code after all
production mixers understand protocol V7.").

Order Import Statements:
The ordering of import statements is:
1. Android imports
2. Imports from third parties (com, junit, net, org)
3. java and javax
Note: import com.InternetGMBH.Sample.Utilities.*;
The wildcard character (*) is used to specify that all classes with that
package are available to your program.
So, it occupies the more memory in our application. So, import only
required classes of the packages like:
import com.InternetGMBH.Sample.Utilities.URLComposer;

/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* http://www.apache.org/licenses/LICENSE-2.0
*/
package com.android.internal.foo;
import android.os.Blah;
import com.InternetGMBH.Sample.R;
import java.sql.ResultSet;
/**
* Does X and Y and provides an abstraction for Z.
*/
public class Foo {
...
/** Returns the correctly rounded positive square root of a double value. */
static double sqrt(double a) {
...
}
}
Syntax:

Naming Conventions:
What is Naming Convention?
Why use Naming Conventions?
Picking Name for your Identifier
Standard Java Naming Conventions

What is Naming Convention?
A naming convention is a rule to follow as you decide what to name
your identifiers (e.g. class, package, variable, method, etc..).
Why use Naming Conventions?
By using standard Java naming conventions they make their code
easier to read for themselves and for other programmers.
Readability of Java code is important because it means less time is
spent trying to figure out what the code does, leaving more time to fix
or modify it.

Picking Name for your Identifier
When choosing a name for an identifier make sure it's meaningful.
For instance, if your program deals with customer accounts then
choose names that make sense to dealing with customers and their
accounts (EX: customerName, accountDetails). Don't worry about the
length of the name.

Standard Java Naming Conventions
Packages:
Names should be in lowercase and the packages might be imported
into other classes, the names will normally be subdivided. Typically
this will start with the company domain before being split into layers
or features:
Example:
package com.mycompany.utilities
package org.bobscompany.application.userinterface

Classes:
Names should be in CamelCase. Try to use nouns because a class is
normally representing something in the real world:
Ex: class Customer
class Account
Interfaces:
Names should be in CamelCase. They tend to have a name that
describes an operation that a class can do:
Ex: interface Comparable
interface Enumerable

Methods:
Names should be in mixed case. Use verbs to describe what the
method does:
Ex: void calculateTax()
string getSurname()
Constants:
Names should be in uppercase.
Ex: static final int DEFAULT_WIDTH
static final int MAX_HEIGHT

Variables:
Names should be in mixed case. The names should represent what the
value of the variable represents:
string firstName
int orderNumber
Only use very short names when the variables are short lived, such as
in for loops:
for (int i=0; i<20;i++)
{
//i only lives in here
}

The scope of local variables should be kept to a minimum. By doing
so, you increase the readability and maintainability of your code and
reduce the likelihood of error.
Types of Scopes in Java:
1.Class Level Scope
2.Method Scope
3.Loop Scope
Variable Scope:

Class Level Scope:
The scope of these variables will need to be at the class level, and
there is only one way to create variables at that level – just inside the
class but outside of any methods. Let's take a look at an example:
Ex: public Class User{
private String username;
}
Method Scope:
Some variables you might want to make temporary and
preferably they are used for only one method. This would be an
example of method scope.
Ex:public static void main(Strings[] args){
int x = 5;
}

Loop Scope:
Any variables created inside of a loop are LOCAL TO THE
LOOP. This means that once you exit the loop, the variable can no
longer be accessed!
In the first example, x can ONLY be used inside of the for loop.
In the second example, you are free to use x inside of the loop as well
as outside of the loop because it was declared outside of the loop (it
has been declared at method scope).

/GEN: The files in the gen folder are automatically generated by the
ADT. Here the R.java file contains reference/index to all the resources
in the res we use in our program. Each time we add a new resource to
the project, ADT will automatically regenerate the R.java file
containing reference to the newly added resource. You should not edit
the contents of R.java file manually or otherwise your application may
not compile.
/ANDROID <version number> : This folder is also called Android
target library in Android project structure. The version number will be
same as the build target version that we choose while creating a new
project. The android.jar file contains all the essential libraries required
for our program.
Let see, how to add library projects and jar file to our project.

If you are developing an application and want to include the shared
code or resources from a library project, you can do so easily by
adding a reference to the library project in the application project's
Properties.
To add a reference to a library project, follow these steps:
1. In the Package Explorer, right-click the dependent project and select
Properties.
2. In the Properties window, select the "Android" properties group at
left and locate the Library properties at right.
3. Click Add to open the Project Selection dialog.
4. From the list of available library projects, select a project and click
OK.
5. When the dialog closes, click Apply in the Properties window.
6. Click OK to close the Properties window.
Referencing a library project:

As soon as the Properties dialog closes, Eclipse rebuilds the project,
including the contents of the library project. Below figure shows the
Properties dialog that lets you add library references and move them
up and down in priority.

Add Jar - to include jar files in you build path which are already present
in your project.
Add External jar - used to include jar files which are 'outside' your
eclipse project workspace folder.
To add to your Android Project, follow these steps:
1. In the Package Explorer, right-click the dependent project and select
Properties.
2. .In the Properties window, select the Java Build Path and then click
on Libraries Tab .
3. Here click on Add Jar's or Add External Jar's button and then browse
your jar file and select ok.
Add jar files into Android Project:

Screen Shot:

/ASSETS: The assets folder is used to store raw asset files. You can keep
any raw data in the assets folder and there’s an asset manager in
Android to read the data stored in the folder.
The raw data can be anything such as audio, video, images etc. On
important point about assets folder is that the data stored in this folder
can’t be referenced by an ID. To access a data in this folder, we have
to work with bits and bytes.
/BIN: /bin folder is where our compiled application files go. When we
successfully compile an application, this folder will contain java class
files, dex files which are executable under Dalvik virtual machine, apk
archives etc.
archives etc.
archives etc.

/RES:Res folder is where we store all our external resources for our
applications such as images, layout XML files, strings, animations,
audio files etc.
Sub folders:
/res/drawable: This folder contains the bitmap file to be used in the
program. There are three different folders to store drawables.
They are drawable-ldpi, drawable-mdpi, drawable-hdpi. The folders
are to provide alternative image resources to specific screen
configurations. Ldpi, mdpi & hdpi stands for low density, medium
density & high density screens respectively.
The resources for each screen resolutions are stored in respective
folders and the android system will choose it according to the pixel
density of the device.
/res/layout: XML files that defines the User Interface goes in this folder.
We have different Layouts in android, Those are:

1.LinearLayout : LinearLayout is used when we need to arrange the
widgets/views in a horizontal or vertical manner. The direction of
arrangement can be set to horizontal or vertical, by default it is being
horizontal.
2.TableLayout : If the Layout's widgets/views need to be arranged in
the form of rows and columns, we use this layout object. This is
similar to html tables. The cells can span columns.
TheTableLayout do not display its border. We can be made to shrink
and stretch by setting the respective properties of the columns
"TableRow" is another helper widget which should be used in
conjunction with the TableLayout.
Various Layouts in Android:

3.RelativeLayout : Here the position of each of the widgets/view is in
relative/dependent to each other. For example, when a layout is
needed such that it has a text view just to the left of an Edit Textbox,
and a button just below the EditText. The relation between the views
are taken care in one iteration, hence if view B’s position is dependent
on view A’s position, view A must come first in the layout.
4.FrameLayout : This is a very simply layout which is used to hold a
section of the screen blank, for displaying an item or group of items at
runtime.
5.AbsoluteLayout : When there is a need is to specify exact x and y
co-ordinate position of the view, then AbsoluteLayout need to be used.
This layout is difficult to maintain.

/res/values:This folder again contains XML files, which contain key
values pairs that will be referenced in the application.
These XML files declare Arrays, colors, dimensions, strings etc. The
main idea of having these values in a separate XML file is that the
values can be used based on the locale without actually changing the
source code.
/res/menu: XML files that define menus in your application goes in
this folder

AndroidManifest.xml file:
AndroidManifest.xml is one of the most important file in the Android
project structure. It contains all the information about your
application.
When an application is launched, the first file the system seeks is
the AndroidManifest file. It actually works as a road map of your
application, for the system.
The Android Manifest file contains information about:
Components of your application such as Activities, services etc.

User permissions required

Minimum level of Android API required
The structure of the Manifest file is:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="package of your application"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon"
android:label="@string/app_name">
<activity android:name=".Starting Activity Class Name"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-sdk android:minSdkVersion="9" />
</manifest>

Brief into Manifest File:

The package attribute defines the base package for the Java objects
referred to in this file. If a Java object lies within a different package,
it must be declared with the full qualified package name.

Google Play requires that every Android application uses its own
unique package. Therefore it is a good habit to use your reverse
domain name as package name. This will avoid collisions with other
Android applications.

android:versionName and android:versionCode specify the version of
your application.
versionName is what the user sees and can be any String.
versionCode must be an integer. The Android Market determine based
on the versionCode, if it should perform an update of the applications
for the existing installations. You typically start with "1" and increase
this value by one, if you roll-out a new version of your application.


The <activity> tag defines an Activity, i.e Starting Activity Class
Name. An intent filter is registered for this class which defines that
this Activity is started once the application starts (action
android:name="android.intent.action.MAIN" ). The category
definition category
android:name="android.intent.category.LAUNCHER" defines that
this application is added to the application directory on the Android
device.

The @string/app_name value refers to resource files which contain the
actual value of the application name. The usage of resource file makes
it easy to provide different resources, e.g. strings, colors, icons, for
different devices and makes it easy to translate applications.
The uses-sdk part of the AndroidManifest.xml file defines the
minimal SDK version for which your application is valid. This will
prevent your application being installed on unsupported devices.

For Different screen size, The following is a list of resource directories
in an application that provides different layout designs for different
screen sizes and different bitmap drawables for small, medium, high,
and extra high density screens. And few changes in Manifest file.
The following code in the Manifest supports all dpis.
<supports-screens android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:xlargeScreens="true"
android:anyDensity="true" />
support different screen size in android :

Add below shown drawable and layout folders in resource folder:
res/layout/my_layout.xml // layout for normal screen size ("default")
res/layout-small/my_layout.xml // layout for small screen size
res/layout-large/my_layout.xml // layout for large screen size
res/layout-xlarge/my_layout.xml // layout for extra large screen size
res/layout-xlarge-land/my_layout.xml // layout for extra large in landscape
orientation
res/drawable-mdpi/my_icon.png // bitmap for medium density
res/drawable-hdpi/my_icon.png // bitmap for high density
res/drawable-xhdpi/my_icon.png // bitmap for extra high density
Reference Link:
http://developer.android.com/training/multiscreen/screendensities.html

Handle the error gracefully and substitute an appropriate value in the
catch {} block.
/** Set port. If value is not a valid number, 80 is substituted. */
void setServerPort(String value) {
try {
serverPort = Integer.parseInt(value);
} catch (NumberFormatException e) {
serverPort = 80; // default port for server
}
}
Handle the Exception:

IllegalAccessException: Thrown when a program attempts to access a
field or method which is not accessible from the location where the
reference is made.
NullPointerException: Thrown when a program tries to access a field or
method of an object or an element of an array when there is no
instance or array to use, that is if the object or array points to null. It
also occurs in some other, less obvious circumstances, like a throw e
statement where the Throwable reference is null.
IllegalArgumentException: Thrown when a method is invoked with an
argument which it can not reasonably deal with. This can happen if the
user either dismisses the view (Ex: a dialog that can be backed out of)
or if the user switches to a different activity while your task is
running.
ClassNotFoundException: Thrown when a class loader is unable to find
a class.
Solution: compare the error to your Android Manifest very closely.
Few Exception in Android:

Upload apk into Android Market:
Steps for Create a certificate for Android Market apk:
1. If you are using Eclipse for Development just right click on your
project and click export.
2. Now choose Android and then Export Android Application. In
the next step confirm the project that you want to export.
3. Then click next and now you should be able to select create new
keystore.
4. Now fill in the required fields and your should be able to sign
your app.
5. Be sure to make a backup of the keystore file and remember your
password. Losing this will make it impossible to update your
application.
Refer the Link:
http://ofps.oreilly.com/titles/9781449383268/ch08_id35815995.html

Publishing Updates on Android Market :
1. At any time after publishing an application on Android Market,
you can upload and publish an update to the same application
package.
2. When you publish an update to an application, users who have
already installed the application may receive a notification that an
update is available for the application. They can then choose to update
the application to the latest version.
3. Before uploading the updated application, be sure that you have
incremented the android:versionCode and android:versionName
attributes in the element of the manifest file. Also, the package name
must be the same as the existing version and the .apk file must be
signed with the same private key.

Go to manifestfile and set the version code like this:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="your.package.name"
android:versionCode="2"
android:versionName="2.0" >
Here , old versioncode: 1 and new version code:2
4. If the package name and signing certificate do not match those of
the existing version, Market will consider it a new application, publish
it as such, and will not offer it to existing users as an update.
5. You have to have the same keystore file which you have used to
upload the 1st version of application on android market. If you have
lost this keystore file then you can't provide update to this application.
Note: Dont forgot to keep a backup of your keystore file.
Refer the Link:
http://developer.android.com/distribute/googleplay/publish/preparing.html

Shortcut keys for using eclipse in effective way:
Ctrl+Shift+L which displays a list of all the keyboard shortcut
combinations (just in case you forget any of those listed here) .
Site For Eclipse Shortcut keys:
http://eclipse.dzone.com/news/effective-eclipse-shortcut-key
Effective Eclipse:

FindBugs:
http://www.vogella.com/articles/Findbugs/article.html
PMD Tool:
http://about-android.blogspot.in/2010/03/android-codereview-tool-setup-pmd.html
Best Code Review Tools for Eclipse:

Android coding guide lines

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Android coding guide lines (20)

Recently uploaded (20)

Android coding guide lines