Techno Talk

Most Android application user interfaces are defined using specially formatted XML
files called layouts. Layout resource files are included in the /res/layout directory.
You compile layout files into your application as you would any other resources.

Here is an example of a layout resource file:

<?xml version=”1.0” encoding=”utf-8”?>
<LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”>
<TextView
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”@string/hello” />
</LinearLayout>
You might recognize this layout: It is the default layout, called main.xml, created
with any new Android application. This layout file describes the user interface of the only activity within the application. It contains a LinearLayout control that is used as a container for all other user interface controls—in this case, a single TextView control. The main.xml layout file also references another resource: the string resource called @string/hello, which is defined in the strings.xml resource file.
There are two ways to format layout resources. The simplest way is to use the layout resource editor in Eclipse to design and preview layout files. You can also edit the XML layout files directly.

Images resources are encapsulated in the class BitmapDrawable. To access a graphic resource file called /res/drawable/logo.png, you would use the getDrawable() method, as follows:

BitmapDrawable logoBitmap =
(BitmapDrawable)getResources().getDrawable(R.drawable.logo);

Most of the time, however, you don’t need to load a graphic directly. Instead, you
can use the resource identifier as an attribute on a control such as an ImageView
control. The following code, for example, sets and loads the logo.png graphic into
an ImageView control named LogoImageView, which must be defined within the
layout:

ImageView logoView = (ImageView)findViewById(R.id.LogoImageView);
logoView.setImageResource(R.drawable.logo);

Supported images format their description and required extension is given below

Supported Image  Format                Description                   Required Extension

Portable Network Graphics              Preferred format                    .png

Nine-Patch Stretchable Images         Preferred format                   .9.png

Joint Photographic Experts Group    Acceptable format                   .jpg

Graphics Interchange Format               Discouraged but                   .gif

To specify the size of a user interface control such as a Button or TextView control,you need to specify different kinds of dimensions. You tag dimension resources with the <dimen> tag and store them in the resource file /res/values/dimens.xml. This XML resource file is not created by default and must be created manually.

Here is an example of a dimension resource file:
<?xml version=”1.0” encoding=”utf-8”?>
<resources>
<dimen name=”thumbDim”>100px</dimen>
</resources>
Each dimension resource value must end with a unit of measurement. Given below is the  list that shows the dimension units that Android supports.


Type of Measurement        Description                           Unit String
Pixels                                 Actual screen pixels                     px
Inches                                Physical measurement                 in
Millimeters                          Physical measurement                 mm
Points                                Common font measurement          pt
Density-independent pixels  Pixels relative to 160dpi                dp
Scale-independent pixels     Best for scalable font display         sp

You can apply color resources to screen controls. You tag color resources with the
<color> tag and store them in the file /res/values/colors.xml. This XML
resource file is not created by default and must be created manually.



Here is an example of a color resource file:
<?xml version=”1.0” encoding=”utf-8”?>
<resources>
<color name=”background_color”>#006400</color>
<color name=”app_text_color”>#FFE4C4</color>
</resources>
The Android system supports 12-bit and 24-bit colors in RGB format. Given below is the list that how many color formats that the Android platform supports.


Color Formats Supported in Android

Format                  Description                         Example
#RGB                     12-bit color                       #00F (blue)
#ARGB                 12-bit color with alpha         #800F (blue, alpha 50%)
#RRGGBB             24-bit color                        #FF00FF (magenta)
#AARRGGBB        24-bit color with alpha         # 80FF00FF (magenta, alpha 50%)

The following code retrieves a color resource named app_text_color using the
getColor() method:
int textColor = getResources().getColor(R.color.app_text_color);

Android provides a useful logging utility class called android.util.Log. Logging
messages are categorized by severity (and verbosity), with errors being the most
severe. Below see some commonly used logging methods of the Log class.

Method               Purpose

Log.e()                 Logs errors
Log.w()                Logs warnings
Log.i()                  Logs informational messages
Log.d()                 Logs debug messages
Log.v()                 Logs verbose messages


The first parameter of each Log method is a string called a tag. One common
Android programming practice is to define a global static string to represent the
overall application or the specific activity within the application such that log filters
can be created to limit the log output to specific data.
For example, you could define a string called TAG, as follows:
private static final String TAG = “MyApp”;
Now anytime you use a Log method, you supply this tag. An informational logging
message might look like this:
Log.i(TAG, “In onCreate() callback method”);

As a developer, you can adopt any one of the below way to provide input to the emulator:

. Use your computer mouse to click, scroll, and drag items (for example, side
volume controls) onscreen as well as on the emulator skin.
. Use your computer keyboard to input text into controls.
. Use your mouse to simulate individual finger presses on the soft keyboard or
physical emulator keyboard.
. Use a number of emulator keyboard commands to control specific emulator
states.

Applications may also create their own intent types and allow other applications to call them, allowing for tightly integrated application suites.