Do you know that? 17% jobs posted on Elance are for Writing & Translation next

See right interview answers on 30 common job interview questions


Collapse | Expand

1. Can a device have a different user interface and still becompatible?

The Android Compatibility Program focuses on whether a device can run third-party applications. The user interface components shipped with a device (such as home screen, dialer, color scheme, and so on) does not
  generally have much effect on third-party apps. As such, device builders are free to customize the user interface as much as they like. The Compatibility Definition Document does restrict the degree to which OEMs may alter the system user interface for areas that do impact third-party apps.

2. Can I write code for Android using C/C++?

Yes, but need to use NDK
  Android applications are written using the Java programming language. Android includes a set of core libraries that provides most of the functionality available in the core libraries of the Java programming language.
  Every Android application runs in its own process, with its own instance of the Dalvik virtual machine. Dalvik has been written so that a device can run multiple VMs efficiently. The Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The VM is register-based, and runs classes compiled by a Java language compiler that have been transformed into the .dex format by the included “dx” tool.
  Android only supports applications written using the Java programming language at this time.

3. Describe android Activities in brief.

Activity provides the user interface. When you create an android application in eclipse through the wizard it asks you the name of the activity. Default name is MainActivity. You can provide any name according to the need. Basically it is a class (MainActivity) that is inherited automatically from Activity class. Mostly, applications have oneor more activities; and the main purpose of an activity is to interact with the user. Activity goes through a numberof stages, known as an activity's life cycle. 

Example:

packagecom.example.careerride; //Application name careerride

importandroid.os.Bundle; // Default packages
importandroid.app.Activity; // Default packages
importandroid.view.Menu;

public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
publicbooleanonCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
} 
}

When you run the application onCreate method is called automatically.

4. Describe android Activities in brief?

Activity provides the user interface. When you create an android application in eclipse through the wizard it asks you the name of the activity. Default name is MainActivity. You can provide any name according to the need. Basically it is a class (MainActivity) that is inherited automatically from Activity class. Mostly, applications have oneor more activities; and the main purpose of an activity is to interact with the user. Activity goes through a numberof stages, known as an activity’s life cycle.

Example:

packagecom.example.careerride; //Application name careerride
    
  importandroid.os.Bundle; // Default packages
  importandroid.app.Activity; // Default packages
  importandroid.view.Menu;

public class MainActivity extends Activity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  }
  @Override
  publicbooleanonCreateOptionsMenu(Menu menu) {
  // Inflate the menu; this adds items to the action bar if it is present.
  getMenuInflater().inflate(R.menu.main, menu);
  return true;
  } 
  }

When you run the application onCreate method is called automatically.

5. Describe Android Application Architecture.

Android Application Architecture has the following components:

  • Services - like Network Operation
  • Intent - To perform inter-communication between activities or services 
  • Resource Externalization - such as strings and graphics 
  • Notification signaling users - light, sound, icon, notification, dialog etc.
  • Content Providers - They share data between applications

6. Describe Briefly the Android Application Architecture?

Android application architecture allows the simplification and reuse of any application. It provides a better way to publish the capabilities of the application so that any other application can make good use of those capabilities. This architecture includes the following components:
  
  Intent: perform some operation on some activity and service
  
  Resource Externalization - such as strings and graphics
  
  Notification signaling users - light, sound, icon etc.
  
  Content Providers – sharing of data between various applications

7. Describe Intents in detail.

An Android application can contain zero or more activities. If you want to navigate fromone activity to another then android provides you Intent class. This class is available inandroid.content.Intent package.One of the most common uses for Intents is to start new activities.

There are two types of Intents.

Explicit Intents
Implicit Intents

Intents works in pairs: actionand data. The action defines what you want to do, such as editing an item, viewingthe content of an item etc. The dataspecifies what is affected,such as a person in the Contacts database. The data is specified as anUri object.

Explicitly starting an Activity

Intent intent = newIntent (this, SecondActivity.class);

startActivity(intent); 

Here SecondActivity is the name of the target activity that you want to start. 

Implicitly starting an Activity

If you want to view a web page with the specified URL then you can use this procedure. 

Intent i = newIntent(android.content.Intent.ACTION_VIEW,Uri.parse(''http://www.amazon.com'')); 

startActivity(i); 

if you want to dial a telephone number then you can use this method by passing the telephone number in the data portion 

Intent i = newIntent (android.content.Intent.ACTION_DIAL,Uri.parse(''tel:+9923.....'')); 

startActivity(i);

In the above method the user must press the dial button to dial the number. If you want to directly call the number without user intervention, change the action as follows:

Intent i = newIntent (android.content.Intent.ACTION_CALL,Uri.parse(''tel:+9923.....''));

startActivity(i);

If you want to dial tel no or use internet then write these line in AndroidManifest.xml

<uses-permissionandroid:name=''android.permission.CALL_PHONE''/>
<uses-permissionandroid:name=''android.permission.INTERNET''/>

8. Describe Intents in detail?

An Android application can contain zero or more activities. If you want to navigate fromone activity to another then android provides you Intent class. This class is available inandroid.content.Intent package.One of the most common uses for Intents is to start new activities.

 

There are two types of Intents.

 

Explicit Intents
     Implicit Intents

 

Intents works in pairs: actionand data. The action defines what you want to do, such as editing an item, viewingthe content of an item etc. The dataspecifies what is affected,such as a person in the Contacts database. The data is specified as anUri object.

 

Explicitly starting an Activity

 

Intent intent = newIntent (this, SecondActivity.class);

 

startActivity(intent);

 

Here SecondActivity is the name of the target activity that you want to start.

 

Implicitly starting an Activity

 

If you want to view a web page with the specified URL then you can use this procedure.

 

Intent i = newIntent(android.content.Intent.ACTION_VIEW,Uri.parse(“http://www.amazon.com”));

 

startActivity(i);

 

if you want to dial a telephone number then you can use this method by passing the telephone number in the data portion

 

Intent i = newIntent (android.content.Intent.ACTION_DIAL,Uri.parse(“tel:+9923.....”));

 

startActivity(i);

 

In the above method the user must press the dial button to dial the number. If you want to directly call the number without user intervention, change the action as follows:

 

Intent i = newIntent (android.content.Intent.ACTION_CALL,Uri.parse(“tel:+9923.....”));

 

startActivity(i);

 

If you want to dial tel no or use internet then write these line in AndroidManifest.xml

 

<uses-permissionandroid:name=”android.permission.CALL_PHONE”/>
   <uses-permissionandroid:name=”android.permission.INTERNET”/>

9. Describe SharedPreference storage option with example.

SharedPreference is the simplest mechanism to store the data in android. You do not worry about creating the file or using files API.It stores the data in XML files. SharedPreference stores the data in key value pair.The SharedPreferences class allows you to save and retrieve key-value pairs of primitive data types. You can use SharedPreferences to save any primitive data: boolean, floats, int, longs, and strings.The data is stored in XML file in the directory data/data//shared-prefs folder.

Application of SharedPreference

  • Storing the information about number of visitors (counter). 
  • Storing the date and time (when your Application is updated). 
  • Storing the username and password. 
  • Storing the user settings.

For storing the data we will write the following code in main activity on save button:

SharedPreferences sf=getSharedPreferences("MyData", MODE_PRIVATE);
SharedPreferences.Editored= sf.edit(); 
ed.putString("name", txtusername.getText().toString()); 
ed.putString("pass", txtpassword.getText().toString()); 
ed.commit();

In this example I have taken two activities. The first is MainActivity and the second one is SecondActivity.When user click on save button the user name and password that you have entered in textboxes, will be stored in MyData.xml file. 

Here MyData is the name of XML file .It will be created automatically for you. 

MODE_PRIVATE means this file is used by your application only. 

txtusernameand txtpassword are two EditText control in MainActivity.

For retrieving the data we will write the following code in SecondActiviy when user click on Load button: 

Public static final String DEFAULT=''N? A''; 

DEFAULT is a String type user defined global variable.If the data is not saved in XML file and user click on load button then your application will not give the error. It will show message ''No Data is found''. Here name and pass are same variable that I have used in MainActivity. 

SharedPreferences sf=getSharedPreferences("MyData", Context.MODE_PRIVATE); 

String Uname=sf.getString("name", DEFAULT); 

String UPass=sf.getString("pass", DEFAULT); 

if(name.equals(DEFAULT)||Pass.equals(DEFAULT)) 
{
Toast.makeText(this, "No data is found", Toast.LENGTH_LONG).show(); 
}

else

{

Txtusername.setText(Uname);
Txtpassword.setText(UPass) ;
}

10. Describe the APK format?

The APK file is compressed the AndroidManifest.xml file, application code (.dex files), resource files, and other files. A project is compiled into a single .apk file.

11. Describe the SmsManager class in android.

SmsManager class is responsible for sending SMS from one emulator to another or device.

You cannot directly instantiate this class; instead, you call the getDefault() static method to obtain an SmsManager object. You then send the SMS message using the sendTextMessage() method:

SmsManagersms = SmsManager.getDefault();

sms.sendTextMessage("5556", null, "Hello from careerRide", null, null); 

sendTextMessage() method takes five argument. 

  • destinationAddress '' Phone number of the recipient. 
  • scAddress '' Service center address; you can use null also. 
  • text '' Content of the SMS message that you want to send. 
  • sentIntent '' Pending intent to invoke when the message is sent. 
  • deliveryIntent '' Pending intent to invoke when the message has been delivered.

12. Describe the SmsManager class in android?

SmsManager class is responsible for sending SMS from one emulator to another or device.

You cannot directly instantiate this class; instead, you call the getDefault() static method to obtain an SmsManager object. You then send the SMS message using the sendTextMessage() method:

SmsManagersms = SmsManager.getDefault();

sms.sendTextMessage("5556", null, "Hello from careerRide", null, null);

sendTextMessage() method takes five argument.

  • destinationAddress — Phone number of the recipient.
         • scAddress — Service center address; you can use null also.
         • text — Content of the SMS message that you want to send.
         • sentIntent — Pending intent to invoke when the message is sent.
         • deliveryIntent — Pending intent to invoke when the message has been delivered.

13. Explain about the exceptions of Android.

The following are the exceptions that are supported by Android

  • InflateException : When an error conditions are occurred, this exception is thrown
  • Surface.OutOfResourceException: When a surface is not created or resized, this exception is thrown
  • SurfaceHolder.BadSurfaceTypeException: This exception is thrown from the lockCanvas() method, when invoked on a Surface whose is SURFACE_TYPE_PUSH_BUFFERS
  • WindowManager.BadTokenException: This exception is thrown at the time of trying to add view an invalid WindowManager.LayoutParamstoken.

14. Explain about the exceptions of Android?

The following are the exceptions that are supported by Android
  * InflateException : When an error conditions are occurred, this exception is thrown
  * Surface.OutOfResourceException: When a surface is not created or resized, this exception is thrown
  * SurfaceHolder.BadSurfaceTypeException: This exception is thrown from the lockCanvas() method, when invoked on a Surface whose is SURFACE_TYPE_PUSH_BUFFERS
  * WindowManager.BadTokenException: This exception is thrown at the time of trying to add view an invalid WindowManager.LayoutParamstoken.

15. Explain AndroidManifest.xmlfile in detail.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.careerride" android:versionCode="1" android:versionName="1.0">

<uses-sdk android:minSdkVersion="8" android:targetSdkVersion="18" />

<application android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme">

<activity android:name="com.example.careerride.MainActivity" 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>

</manifest>

The AndroidManifest.xml file contains the following information about the application:

  • It contains the package name of the application. 
  • The version code of the application is 1.This value is used to identify the version number of your application. 
  • The version name of the application is 1.0 
  • The android:minSdkVersion attribute of the element defines the minimum version of the OS on which the application will run. 
  • ic_launcher.png is the default image that located in the drawable folders. 
  • app_name defines the name of applicationand available in the strings.xml file. 
  • It also contains the information about the activity. Its name is same as the application name.

16. Explain AndroidManifest.xmlfile in detail?

<?xml version="1.0" encoding="utf-8"?>
  <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.careerride" android:versionCode="1" android:versionName="1.0">

<uses-sdk android:minSdkVersion="8" android:targetSdkVersion="18" />

<application android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme">

<activity android:name="com.example.careerride.MainActivity" 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>
  
  </manifest>

The AndroidManifest.xml file contains the following information about the application:

  • It contains the package name of the application.
         • The version code of the application is 1.This value is used to identify the version number of your application.
         • The version name of the application is 1.0
         • The android:minSdkVersion attribute of the element defines the minimum version of the OS on which the application will run.
         • ic_launcher.png is the default image that located in the drawable folders.
         • app_name defines the name of applicationand available in the strings.xml file.
         • It also contains the information about the activity. Its name is same as the application name.

17. Explain in brief about the important file and folder when you create new android application.

When you create android application the following folders are created in the package explorer in eclipse which are as follows:

src: Contains the .java source files for your project. You write the code for your application in this file. This file is available under the package name for your project.

gen ''This folder contains the R.java file. It is compiler-generated file that references all the resources found in your project. You should not modify this file.

Android 4.0 library: This folder contains android.jar file, which contains all the class libraries needed for an Android application. 

assets: This folder contains all the information about HTML file, text files, databases, etc. 

bin: It contains the .apk file (Android Package) that is generated by the ADT during the build process. An .apk file is the application binary file. It contains everything needed to run an Android application. 

res: This folder contains all the resource file that is used byandroid application. It contains subfolders as: drawable, menu, layout, and values etc. 

18. Explain in brief about the important file and folder when you create new android application?

When you create android application the following folders are created in the package explorer in eclipse which are as follows:

src: Contains the .java source files for your project. You write the code for your application in this file. This file is available under the package name for your project.

gen —This folder contains the R.java file. It is compiler-generated file that references all the resources found in your project. You should not modify this file.

Android 4.0 library: This folder contains android.jar file, which contains all the class libraries needed for an Android application.

assets: This folder contains all the information about HTML file, text files, databases, etc.

bin: It contains the .apk file (Android Package) that is generated by the ADT during the build process. An .apk file is the application binary file. It contains everything needed to run an Android application.

res: This folder contains all the resource file that is used byandroid application. It contains subfolders as: drawable, menu, layout, and values etc.

19. Explain IP datagram, Fragmentation and MTU.

IP datagram can be used to describe a portion of IP data. Each IP datagram has set of fields arranged in an order. The order is specific which helps to decode and read the stream easily. IP datagram has fields like Version, header length, Type of service, Total length, checksum, flag, protocol, Time to live, Identification, source and destination ip address, padding, options and payload. 

MTU:- Maximum Transmission Unit is the size of the largest packet that a communication protocol can pass. The size can be fixed by some standard or decided at the time of connection

Fragmentation is a process of breaking the IP packets into smaller pieces. Fragmentation is needed when the datagram is larger than the MTU. Each fragment becomes a datagram in itself and transmitted independently from source. When received by destination they are reassembled. 

20. How all the activities that are running run in main thread?

All the applications that are running or can be accessed runs in main thread of user interface by default. The modification can be done to make it run differently or to make it run or not at all. The exception also comes defining that the code handles the IPC calls that are coming from other processes. The system used to maintain separate pools for all the processes and threads. One pool consists of the transaction threads that are in each process to dispatch all the incoming calls. It also allows the interpersonal calls to be handled in a specialized manner. This allows the creation of separate threads that is used for long-running code, and to avoid blocking of the main user interface threads. The services that run can be killed by the system if it is going out of memory. The system restart the service and implement onStartCommand() to bring the activities back in the memory pool?

21. How can I contribute to Android?

There are a number of ways you can contribute to Android. You can report bugs, write apps for Android, or contribute source code to the Android Open-Source Project.

There are some limits on the kinds of code contributions we are willing or able to accept. For instance, someone might want to contribute an alternative application API, such as a full C++-based environment. We would decline that contribution, since Android is focused on applications that run in the Dalvik VM. Alternatively, we won’t accept contributions such as GPL or LGPL libraries that are incompatible with our licensing goals.

We encourage those interested in contributing source code to contact us via the AOSP Community page prior to beginning any work. You can find more information on this topic at the Getting Involved page.

22. How to select more than one option from list in android xml file? Give an example.

Specify android id, layout height and width as depicted in the following example.

<ListView android:id="@+id/ListView01" android:layout_height="wrap_content" android:layout_width="fill_parent"></ListView> 

23. How to send SMS in android? Explain with example.

SMS messaging is one of the basic and important applications on a mobile phone. Now days every mobile phone has SMS messaging capabilities, and nearly all users of any age know how to send and receive suchmessages. Mobile phones come with a built-in SMS application that enables you to send and receiveSMS messages. If you want to send the SMS programmatically then follow the following steps.

Sending SMS Messages Programmatically

Take a button on activity_main.xml file as follows.

<Button android:id="@+id/btnSendSMS" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:layout_centerVertical="true" android:onClick=''sendmySMS'' android:text="sendSMS" /> 

According to above code when user clicks the button sendmySMS method will be called. sendmySMS is user defined method.

In the AndroidManifest.xml file, add the following statements

<uses-permissionandroid:name=''android.permission.SEND_SMS''/> 

Now we write the final step. Write the given below method in MainActivity,java file 

publicvoidsendmySMS(View v)
{
SmsManagersms = SmsManager.getDefault(); 
sms.sendTextMessage("5556", null, "Hello from careerRide", null, null);
}
In this example I have used two emulator. On the first Android emulator (5554), click the Send SMSbutton to send an SMS message to the second emulator(5556). 

24. How to send SMS in android? Explain with example?

SMS messaging is one of the basic and important applications on a mobile phone. Now days every mobile phone has SMS messaging capabilities, and nearly all users of any age know how to send and receive suchmessages. Mobile phones come with a built-in SMS application that enables you to send and receiveSMS messages. If you want to send the SMS programmatically then follow the following steps.

Sending SMS Messages Programmatically

Take a button on activity_main.xml file as follows.

<Button android:id="@+id/btnSendSMS" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:layout_centerVertical="true" android:onClick=”sendmySMS” android:text="sendSMS" />

According to above code when user clicks the button sendmySMS method will be called. sendmySMS is user defined method.

In the AndroidManifest.xml file, add the following statements

<uses-permissionandroid:name=”android.permission.SEND_SMS”/>

Now we write the final step. Write the given below method in MainActivity,java file

publicvoidsendmySMS(View v)
  {
  SmsManagersms = SmsManager.getDefault(); 
  sms.sendTextMessage("5556", null, "Hello from careerRide", null, null);
  }
  In this example I have used two emulator. On the first Android emulator (5554), click the Send SMSbutton to send an SMS message to the second emulator(5556).

25. How you can use built-in Messaging within your application?

You can use an Intent object to activate the built-in Messaging service. You have to pass MIME type “vnd.android-dir/mms-sms”, in setType method of Intent as shown in the following given below code.

Intent intent = new Intent (android.content.Intent.ACTION_VIEW);
  intent.putExtra("address", "5556; 5558;");// Send the message to multiple recipient.
  itent.putExtra("sms_body", "Hello my friends!"); 
  intent.setType("vnd.android-dir/mms-sms");
  startActivity(intent);

What are different data storage options are available in Android?

Different data storage options are available in Android are:

  • SharedPreferences
         • SQlite
         • ContentProvider
         • File Storage
         • Cloud Storage

26. Tell us something about activityCreator?

- An activityCreator is the initial step for creation of a new Android project.
- It consists of a shell script that is used to create new file system structure required for writing codes in Android IDE.

27. Tell us something about nine-patch image.

- The Nine-patch in the image name refers to the way the image can be resized: 4 corners that are unscaled, 4 edges that are scaled in 1 axis, and the middle one that can be scaled into both axes.
- A Nine-patch image allows resizing that can be used as background or other image size requirements for the target device.

28. What are the advantages of Android?

The following are the advantages of Android:* The customer will be benefited from wide range of mobile applications to choose, since the monopoly of wireless carriers like AT&T and Orange will be broken by Google Android.
  * Features like weather details, live RSS feeds, opening screen, icon on the opening screen can be customized
  * Innovative products like the location-aware services, location of a nearby convenience store etc., are some of the additive facilities in Android.
  Components can be reused and replaced by the application framework.
  *Optimized DVM for mobile devices
  *SQLite enables to store the data in a structured manner.
  *Supports GSM telephone and Bluetooth, WiFi, 3G and EDGE technologies
  *The development is a combination of a device emulator, debugging tools, memory profiling and plug-in for Eclipse IDE.Features of Android
   Application framework enabling reuse and replacement of components
   Dalvik virtual machine optimized for mobile devices
   Integrated browser based on the open source WebKit engine
   Optimized graphics powered by a custom 2D graphics library; 3D graphics based on the OpenGL ES 1.0 specification (hardware acceleration optional)
   SQLite for structured data storage
   Media support for common audio, video, and still image formats (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF)
   GSM Telephony (hardware dependent)
   Bluetooth, EDGE, 3G, and WiFi (hardware dependent)
   Camera, GPS, compass, and accelerometer (hardware dependent)
   Rich development environment including a device emulator, tools for debugging, memory and performance profiling, and a plugin for the Eclipse IDE.

29. What are the advantages of having an emulator within the Android environment?

- The emulator allows the developers to work around an interface which acts as if it were an actual mobile device.
- They can write, test and debug the code.
- They are safe for testing the code in early design phase

30. What are the approaches required to share persistent user-defined objects?

Persistent objects come when there is process that is in the running state and the system can perform any action like restart or kill. If there is any data that will persist and required from another data then it is very essential to save it and share it so that if one activity is down, another activity can be performed without any hindrance. To share the complex persistent user-defined objects, it is required to have the approaches like:
- Application preferences: that is used to allow the user to change the setting of preferences and make it accessible by some other objects.
- Files: permissions on the files can be set so that any other file can also use and share the objects
- Content providers: allow easy to follow patterns that allow the user to select the object and share it with other functions. 
- Database: the database can be used to store the user data and can easily link between the user and the entity that are present in it. 

31. What are the dialog boxes that are supported in android? Explain.

Android supports 4 dialog boxes:

AlertDialog : An alert dialog box supports 0 to 3 buttons and a list of selectable elements, including check boxes and radio buttons. Among the other dialog boxes, the most suggested dialog box is the alert dialog box.

ProgressDialog: This dialog box displays a progress wheel or a progress bar. It is an extension of AlertDialog and supports adding buttons.

DatePickerDialog: This dialog box is used for selecting a date by the user.

TimePickerDialog: This dialog box is used for selecting time by the user.

32. What are the differences between a domain and a workgroup?

In a domain, one or more computer can be a server to manage the network. On the other hand in a workgroup all computers are peers having no control on each other. In a domain, user doesn't need an account to logon on a specific computer if an account is available on the domain. In a work group user needs to have an account for every computer. 
In a domain, Computers can be on different local networks. In a work group all computers needs to be a part of the same local network.

33. What are the different approaches that are required to share the objects?

There are several types of approaches that are required to share the objects and all of them are listed below:
- Singleton class: is used for the application components that run in the same process. This allows the design to run only one instance at a time. It includes static methods with a name like getInstance(). This method returns the instance whenever it is called for the first time. This method also creates a global instance so that it can be called easily without using more memory in creation and destroying of the process. 

- A public static field or method: is used as an alternate method to make the data accessible across Activities and Services that is to be used by the public. This defines the static fields or methods that are used by other classes in the application. The method is used to share an object that gets created by the static field pointing to an object and other accessible fields. 

- A HashMap of WeakReferences to Objects: provide some long keys that map the activities that is called by an object from another object. This after mapping sends a key that is unique and long to show the truthfulness of the object.

34. What are the different data types used by Android?

The data can be passed between many services and activities using the following data types:
- Primitive Data Types: are used to share the activities and services of an application by using the command as Intent.putExtras(). This primitive data passes the command to show the persistent data using the storage mechanism. These are inbuilt data types that are used with the program. They provide simple implementation of the type and easy to use commands. 
- Non-Persistent Objects: are used to share complex and non-persistent objects. These are user-defined data types that are used for short duration and are also recommended to be used. These types of objects allow the data to be unique but it creates a complex system and increase the delay. 

35. What are the different forms of communication provided by the Android applications?

    

There are different forms of communication that is used by the Android application developers like:
  - Internet telephony: this is used to add SIP-based features to the application. This includes the full SIP protocol stack and includes integrated call management services. These services allow setting the ongoing and incoming voice calls without managing the sessions at the transport level. This provides the communication to be successful by determining the associated carriers.
  - NFC (Near field communications) - this is used to allow the communication to happen between the developers that create the new class of application. These new applications are created and provided as a service to the users, organizations, merchants and advertisers. It allows the tagging of application that interests the user. The tag allows the user to communicate through wireless telephony services and allow the use of device hardware. 

36. What are the different modes of operations used in services for Android?

There are two modes of operations that are necessary to run depending on the value returned by the startcommand(). The modes are as follows:
  - START_STICKY: this mode is used for the services that are explicitly started and stopped according to the need and the requirement of the user. 
  - START_NOT_STICKY or START_REDELIEVER_INTENT: this service mode is used for services that are running only when the processing command sent to them. That means these run on the basis of the command that is passed to them by giving the instruction of execution. 
  - Clients uses the Context.bindService() that is used to get the persistent connection for a service. To create a service that is not already running the command onCreate is used. 

37. What are the different phases of the Activity life cycle?

As an activity transitions from state to state, it is notified of the
  change by calls to the following protected methods:
  1) void onCreate(Bundle savedInstanceState)
  2) void onStart()
  3) void onRestart()
  4) void onResume()
  5) void onPause()
  6) void onStop()
  7) void onDestroy()
  Taken together, these seven methods define the entire lifecycle of an
  activity.

38. What are the different Storage Methods in android?

Android provides many options for storage of persistent data. It provides the solution according to your need. The storages which have been provided in Android are as follows:-
  
  Shared Preferences: Store private primitive data in key-value pairs
  
  Internal Storage: Store private data on the device memory.
  
  External Storage: Store public data on the shared external storage.
  
  SQLite Databases: Store structured data in a private database.
  
  Network Connection: Store data on the web with your own network server.

39. What are the different tools in Android? Explain them?

The Android SDK and Virtual Device Manager-

  It is used to create and manage Android Virtual Devices (AVD) and SDK packages. The AVD hosts an emulator running a particular build of Android, letting you specify the supported SDK version, screen resolution, amount of SD card storage available, and available hardware capabilities (such as touch screens and GPS).

  The Android Emulator-

  An implementation of the Android virtual machine designed to run within a virtual device on your development computer. Use the emulator to test and debug your Android applications.

  Dalvik Debug Monitoring Service (DDMS) -

  Use the DDMS perspective to monitor and control the Dalvik virtual machines on which you're debugging your applications.

  Android Asset Packaging Tool (AAPT) -

  Constructs the distributable Android package files (.apk).

  Android Debug Bridge,(adb) -

  Android Debug Bridge, is a command-line debugging application shipped with the SDK. It provides tools to browse the device, copy tools on the device, and forward ports for debugging.

40. What are the features of Android?

  • Components can be reused and replaced by the application framework.
  • Optimized DVM for mobile devices
  • SQLite enables to store the data in a structured manner.
  • Supports GSM telephone and Bluetooth, WiFi, 3G and EDGE technologies
  • The development is a combination of a device emulator, debugging tools, memory profiling and plug-in for Eclipse IDE.

41. What are the key components of Android Architecture?

Android Architecture consists of 4 key components:
- Linux Kernel
- Libraries
- Android Framework
- Android Applications

42. What are the methods to avoid memory leaks in Android?

Android applications are well bundled with the memory but they have a drawback of running lots of application that keeps in the memory to make the processing faster. The more application in the memory, the faster will be the switch between the applications. The memory leaks can be avoided by changing the context. The context is used for many operations but it is used to access the resources on android. The widgets have a context parameter in their constructors. There are mainly two types of context: either activity or application. The program is as follows:
@Override
protected void onCreate(Bundle state) {
super.onCreate(state);
TextView label = new TextView(this);
label.setText("Test memory leak");
setContentView(label);
}
if the context is having leaks in it then the activity then there is a possibility of the leaks of memory. The leaking of the entire activity can be checked. The system will automatically create and destroy one of the activities by default. Android will reload the application by using the rotation policy. And it will keep the entire static field maintained. 

43. What are the multimedia features involved in making Android popular?

    

There is the demand for the rich multimedia that involves many features that are used till now to make the Android market more popular in all the phases. The application includes the following:
  - Mixable audio effects - developer can easily create audio environments using the API key that is provided with it like creating equalization, bass boost, headphone feature, etc. The android provide the tools that can be used to mix the audio effects and apply it.
  - There is also support for new media formats like VP8 open video compression format that uses a container format that can run on all the platforms and add the support for AAC and AMR encoding. The applications provided allow higher quality video to be captured. 
  - The application allows the access to multiple cameras that allows the use of APIs to include the camera and its properties in one. The platform provides the application to include the camera with high and low resolution.

44. What are the security measures that are taken to make Android secure?

Android uses many security measures to keep them away from the hackers. They have designed by making changes to the devices or installing a software service on the mobile. Android application uses sandbox that is very popular and allow limited access to the information that is very private and sensitive for the user. It allows the permissions to be set for the use of the information. The security measures that are provided by android is the use of the encryption of the messages that allow user to remain without worry about there phone security. They also consists of user terms and agreements that also taken care of. Most of the time android doesn't allow other applications to run on their system but it can be done by using different resources that are available on-line. As, android is open source it is not fully secure but lots of security issues are being solved for make it more popular and bug free.

45. What are the services that can be allowed to run in a single process?

Android allows all the services and applications to run on a single process. This behavior is the default behavior that can be changed by using the different settings and functions. The process can be declared by using android: process attribute. This places the component explicitly on the process. Service is not a separate process and itself it's a process if not defined separately. The service is not used as a thread as well but it defines other threads in the program to do the work and create the application. The application runs and finds the errors in the program and the service just takes the necessary actions on them. The service also responds to the errors whenever necessary. 

46. What are the steps required in setting up the linkify calls intent?

Linkify is used to route the intent in an activity. This linkify allows the calls to be invoked and allow an activity to be handled. The process of executing the linkfy is as follows:
- linkfy is used to invoke the process in the TextView and allow the matching of the patterns to be turned into the intent links.
- Linkify monitors the intent links that is being selected by the user and allow it to be modified for further actions. 
- Linkfy allows the user to select the link and when user selects it, it calls the VIEW action on the content that uses an URI that is associated with the link.
- Android takes the content that is represented by the URI and the data that is used. It looks for the ContentProvider component that is registered with the system and matches the URI of the content that is getting produced. 
- If the match is found for the query done by android then the URI gets used by the ContentProvider and MIME type of data can be returned for the URI. 
- Android uses the activity registered in the system that uses the intent-filter matching both the VIEW action and the MIME type for the data that can be linked with the URI.

47. What are the steps required to avoid context related memory leaks?

The steps that are required to check and avoid the context-related memory leaks are as follows:
- Never keep the long-lived references linked with the context-activity. This reference can be of the same life as the activity or can be of different length that depends on the type of activity that is getting performed on the action. 
- Use of context-application is much better than the context-activity as it allows the application to be reused again and again and the activity can be viewed or executed only once. The application takes less time to execute and activity can take more due to consisting of more than one application in it. 
- Non-static inner classes should be avoided while getting used in the activity, as it doesn't control the life-cycle of the static-inner class and make some weak reference to the activities that are inside the process and getting used. 
- There should not be relying upon the garbage collector as it is not the ultimate solution for the memory leaks that are defined. 

48. What are the steps that are involved in converting the android in newer version?

    

To release a new version requires lots of changes and a process has to be developed to build the changes. The steps that is required:
  - In the beginning of the creation the software gets the built or the earlier version of the system image. This includes various certifications and deployment rules and regulations.
  - The built goes through operator testing and this is one of the important phase as it allows lot of bugs to be found and corrected. 
  - The release then goes the regulators, moderators and operators to produce the devices to release the source code. The code that is written is checked for errors and there is a sign of the agreement that take place between the contributors and some verification are performed. 
  - The production of the software begins and the release process starts and then the release will allow the users to grab the devices.

49. What are the steps that are required in Service Lifecycle?

The services allow the proper functioning of the system. 
  - The service starts with Context.startService() function and the system will retrieve the service using onCreate() method. To start the service it calls on onStartCommand(Intent, int, int)method with proper arguments that are given by the client. 
  - If the service is running and due to some problem the user doesn't want to run it then it uses Context.stopService()or stopSelf() method to properly implement the service for the user.
  - Due to multiple calls of the Context.startService() method the program doesn't do any nesting of the program and shows the stopping of the services. 
  - Services can use the command stopSelf(int)method to stop their own service. A service doesn't stop untill all the processes are processed. 

50. What data types are supported by AIDL?

AIDL supports following data types:
-string
-List
-Map
-charSequence
and
-all native Java data types like int,long, char and Boolean

51. What dialog boxes are supported in android?

There are 4 dialog boxes which have been supported by Android. These are as follows:
  AlertDialog: it supports 0 to 3 buttons with a list of selectable elements that includes check boxes and radio buttons. 
  
  -ProgressDialog: it displays the progress of any dialog or application. It is an extension of AlertDialog and supports adding buttons.
  -DatePickerDialog: it is used to give provision to the user to select the date
  - TimePickerDialog: it is used to give provision to the user to select the time

52. What do containers hold?

- Containers hold objects and widgets in a specified arrangement. 
- They can also hold labels, fields, buttons, or child containers. .

53. What do intent filters do?

- There can be more than one intents, depending on the services and activities that are going to use them. 
- Each component needs to tell which intents they want to respond to. 
- Intent filters filter out the intents that these components are willing to respond to.

54. What do you know about Intents?

- Notification messages to the user from an Android enabled device can be displayed using Intents. The users can respond to intents. 
- There are two types of Intents - Explicit Intent, Implicit Intent. 

55. What is .apk extension?

The extension for an Android package file, which typically contains all of the files related to a single Android application. The file itself is a compressed collection of an AndroidManifest.xml file, application code (.dex files), resource files, and other files. A project is compiled into a single .apk file.

56. What is a Content Provider?

Content Providers are the only way to share data across Androidapplications. They store and retrieve data thus making it accessible to all. Content Providers give a uniform interface to access the data.
  Android platform provides default implementations of content providers for data types like audio, video, images, contact information etc.

57. What is a Dalvik ?

The name of Android’s virtual machine. The Dalvik VM is an interpreter-only virtual machine that executes files in the Dalvik Executable (.dex) format, a format that is optimized for efficient storage and memory-mappable execution. The virtual machine is register-based, and it can run classes compiled by a Java language compiler that have been transformed into its native format using the included “dx” tool. The VM runs on top of Posix-compliant operating systems, which it relies on for underlying functionality (such as threading and low level memory management). The Dalvik core class library is intended to provide a familiar development base for those used to programming with Java Standard Edition, but it is geared specifically to the needs of a small mobile device.

58. What is a Resource ?

A user-supplied XML, bitmap, or other file, entered into an application build process, which can later be loaded from code. Android can accept resources of many types; see Resources for a full description. Application-defined resources should be stored in the res/ subfolders.

59. What is a Sticky Intent?

Intent is basically an abstract description of an operation that has to be performed for communication. Sticky Intent is also a type of intent which allows the communication between a function and a service. For example: sendStickyBroadcast() performs send Broadcast(Intent) which stays even after the broadcast is complete. It helps in retrieving the data quickly. The message ACTION_BATTERY_CHANGED of an operating system is an example of it.

60. What is a Theme ?

A set of properties (text size, background color, and so on) bundled together to define various default display settings. Android provides a few standard themes, listed in R.style (starting with “Theme_”).

61. What is a Toast Notification?

A toast notification is a message that pops up on the surface of the window. It only fills the amount of space required for the message and the user's current activity remains visible and interactive. The notification automatically fades in and out, and does not accept interaction events.

A Status Bar Notification: It is used for persistent reminders that come from the background and request the user's response.

  A Dialog Notification: It is Used for Activity-related notifications.

62. What is AIDL?

- AIDL is the abbreviation for Android Interface Definition Language. 
- It handles the interface requirements between a client and a service to communicate at the same level through interprocess communication. 
- The process involves breaking down objects into primitives that are Android understandable.

63. What is an Explicit Intent?

- Explicit intent specifies the particular activity that should respond to the intent. 
- They are used for application internal messages. 

64. What is an Implicit Intent?

- In case of Implicit Intent, an intent is just declared. 
- It is for the platform to find an activity that can respond to it.
- Since the target component is not declared, it is used for activating components of other applications. 

65. What is an Intent Filter ?

Activities and intent receivers include one or more filters in their manifest to describe what kinds of intents or messages they can handle or want to receive. An intent filter lists a set of requirements, such as data type, action requested, and URI format, that the Intent or message must fulfill. For Activities, Android searches for the Activity with the most closely matching valid match between the Intent and the activity filter. For messages, Android will forward a message to all receivers with matching intent filters.

66. What is an Intent?

A class (Intent) that contains several fields describing what a caller would like to do. The caller sends this intent to Android’s intent resolver, which looks through the intent filters of all applications to find the activity most suited to handle this intent. Intent fields include the desired action, a category, a data string, the MIME type of the data, a handling class, and other restrictions.

67. What is an URIs?

Android uses URI strings both for requesting data (e.g., a list of contacts) and for requesting actions (e.g., opening a Web page in a browser). Both are valid URI strings, but have different values. All requests for data must start with the string “content://”. Action strings are valid URIs that can be handled appropriately by applications on the device; for example, a URI starting with “http://” will be handled by the browser.

68. What is Android Runtime?

Android includes a set of core libraries that provides most of the functionality available in the core libraries of the Java programming language. Every Android application runs in its own process, with its own instance of the Dalvik virtual machine. Dalvik has been written so that a device can run multiple VMs efficiently. The
  Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The VM is register-based, and runs classes compiled by a Java language compiler that have been transformed into the .dex format by the included "dx" tool.

69. What is android?

Android is a stack of software for mobile devices which has Operating System, middleware and some key applications. The application executes within its own process and its own instance of Dalvik Virtual Machine. Many Virtual Machines run efficiently by a DVM device. DVM executes Java language?s byte code which later transforms into .dex format files.

70. What is APK format in Android? How to make an APK file?

APK termed as Application package file is a format that is used to distribute and install the application software for android, and middleware on the android operating system. To make an APK file, first android is compiled and then all of its parts are grouped in one file termed as package. The package consists of the entire program’s code (.dex files), resources, manifest file etc. The file is saved with .apk extension.

71. What is Dalvik Virtual Machine?

- It is Android's virtual machine. 
- It is an interpreter-only virtual machine which executes files in Dalvik Executable (.dex) format. This format is optimized for efficient storage and memory-mappable execution.

72. What is Drawable?

A compiled visual resource that can be used as a background, title, or other part of the screen. It is compiled into an android.graphics.drawable subclass.

73. What is involved in releasing the source code for a new Androidversion?

Releasing the source code for a new version of the Android platform is a significant process. First, the software gets built into a system image for a device, and put through various forms of certification, including
  government regulatory certification for the regions the phones will be deployed. It also goes through operator testing. This is an important phase of the process, since it helps shake out a lot of software bugs.
  Once the release is approved by the regulators and operators, the manufacturer begins mass producing devices, and we turn to releasing the source code.
  Simultaneous to mass production the Google team kicks off several efforts to prepare the open source release. These efforts include final API changes and documentation (to reflect any changes that were made
  during qualification testing, for example), preparing an SDK for the new version, and launching the platform compatibility information.Also included is a final legal sign-off to release the code into open source.
  Just as open source contributors are required to sign a Contributors License Agreement attesting to their IP ownership of their contribution, Google too must verify that it is clear to make contributions.
  Starting at the time mass production begins, the software release process usually takes around a month, which often roughly places source code releases around the same time that the devices reach users.

74. What is it important to set permissions in app development?

- Certain restrictions to protect data and code can be set using permissions. 
- In absence of these permissions, codes could get compromised causing defects in functionality.

75. What is needed to make a multiple choice list with a custom view for each row?

Multiple choice list can be viewed by making the CheckBox android:id value be ''@android:id /text1". That is the ID used by Android for the CheckedTextView in simple_list_item_multiple_choice.

76. What is Orientation?

- Orientation decides if the LinearLayout should be presented in row wise or column wise fashion. 
- The values are set using setOrientation()
- The values can be HORIZONTAL or VERTICAL

77. What is the Android Emulator?

The Android Development Tools (ADT) include an emulator to run an Android system. The emulator
  behaves like a real Android device (in most cases) and allows you to test your application without
  having a real device.
  You can configure the version of the Android system you would like to run, the size of the SD card, the
  screen resolution and other relevant settings. You can define several of them with different
  configurations.
  These devices are called Android Virtual Device and you can start several in parallel.

78. What is the Android Open Source Project?

We use the phrase “Android Open Source Project” or “AOSP” to refer to the people, the processes, and the source code that make up Android.The people oversee the project and develop the actual source code. The processes refer to the tools and procedures we use to manage the development of the software. The net result is the source code that you can use to build cell phone and other devices.

79. What is the difference between Service and Thread?

Service is like an Activity but has no interface. Probably if you want to fetch the weather for example you won't create a blank activity for it, for this you will use a Service. It is also known as Background
  Service because it performs tasks in background. A Thread is a concurrent unit of execution. You need to know that you cannot update UI from a Thread. You need to use a Handler for this

80. What is the main reason of using process lifecycle in Android?

The android system will keep all the process that are hosting the services together at one place till the time the service is not started or connected to the client. The priority of the process is divided when running low on memory or when the process has to be killed. The process lifecycle is as follows:
  - The service is running currently then the methods onCreate(), onStartCommand(), and onDestroy()methods, will run in the foreground to execute the process without being killed. 
  - The service is already started then the process can be considered as less important then the processes that are currently visible and used. This is done as there are only few processes that are visible to the users on the screen. 
  - The clients are bounded to the services they are providing requires more priority in the execution list. 
  - The service that is started uses startForeground(int, Notification)API to allow all the services to run in the foreground state. The system considers only the services where the user is still active as the services not to be killed. 

81. What is the Open Handset Alliance?

The OHA is a consortium of 84 technology and mobile companies that have joined hands to accelerate innovation in mobile technology and at the same time offer the end users a better, cost-effective and
  richer mobile experience. Members of this include Google, HTC, Sony, Dell, Intel, Motorola, Qualcomm, Texas Instruments, Samsung, LG, T-Mobile, Nvidia. The OHA was started on 5 November 2007 by Google and 34 other companies. Android is the main software of the alliance.

82. What is the procedure to check status of an activity in Android?

The status of an activity can be start and stop only. The start means the activity is up and running. It is in execution state and performing some actions. Whereas the stop state defines that the activity is being stopped and performing no action on the system. To see or check the status of an activity there is a command that has to be used like NEW_TASK_LAUNCH flag that keeps the track of all the activities that are running and the main command under which the flag resides is given as startActivity() call. To bring the activity stack in front of the process that is already running require the command mentioned above to be used. The activity can be started remotely by using the remote services. These services allow easy interaction with the client and provide the sample to show it on the local server.

83. What is the role of Android Market in compatibility?

Devices that are Android compatible may seek to license the Android Market client software. This allows them to become part of the Android app ecosystem, by allowing users to download developers’ apps from a catalog shared by all compatible devices. This option isn’t available to devices that aren’t compatible.
  The Android software can be ported to a lot of different kinds of devices, including some on which third-party apps won’t run properly. The Android Compatibility Definition Document (CDD) spells out the specific device configurations that will be considered compatible.
  For example, though the Android source code could be ported to run on a phone that doesn’t have a camera, the CDD requires that in order to be compatible, all phones must have a camera. This allows developers to rely on a consistent set of capabilities when writing their apps.

84. What is the role of compatibility that is used in Android?

    

The compatibility is defined in terms of android compatible devices that run any application. This application is written by third party developers using the Android platform that comes in the form of SDK and NDK. There are many filters that are used to separate devices that are there to participate in the compatibility mode for the Android applications. The devices that are compatible require the android to approve it for their trademark. The devices that are not passes the compatibility are just given in the Android source code and can use the android trademark. The compatibility is a way through which the user can participate in the Android application platform. The source code is free to use and it can be used by anyone 

85. What is the TTL (Time to Live)? Why is it required?

TTL is a value in data packet of Internet Protocol. It communicates to the network router whether or not the packet should be in the network for too long or discarded. Usually, data packets might not be transmitted to their intended destination within a stipulated period of time. 

The TTL value is set by a system default value which is an 8-bit binary digit field in the header of the packet. 

The purpose of TTL is, it would specify certain time limit in seconds, for transmitting the packet header. When the time is exhausted, the packet would be discarded. Each router receives the subtracts count, when the packet is discarded, and when it becomes zero, the router detects the discarded packets and sends a message, Internet Control Message Protocol message back to the originating host.

86. What is ViewGroup?

A ViewGroup is a special view that can contain other views (called children.) The view group is the base class for layouts and views containers. This class also defines the class ViewGroup.LayoutParams which serves as the base class for layouts parameters.

87. What?s the difference between file, class and activity in android?

File – It is a block of arbitrary information, or resource for storing information. It can be of any type.
  Class – Its a compiled form of .Java file . Android finally used this .class files to produce an executable apk
  Activity – An activity is the equivalent of a Frame/Window in GUI toolkits. It is not a file or a file type it is just a class that can be extended in Android for loading UI elements on view.

88. Whats are assets?How to Access assets ?

While the res directory contains structured values which are known to the Android platform, the assets
  directory can be used to store any kind of data.

You access this data via the AssetsManager which you can access the getAssets() method.
  The AssetsManager class allows to read a file in the assets folder as InputStream with the open()
  method. The following code shows an example for this.
  // Get the AssetManager
  AssetManager manager = getAssets();
  // Read a Bitmap from Assets

open = manager.open("logo.png");
  Bitmap bitmap = BitmapFactory.decodeStream(open);
  // Assign the bitmap to an ImageView in this layout
  ImageView view = (ImageView) findViewById(R.id.imageView1);
  view.setImageBitmap(bitmap);
  } ccaattcchh (IOException e) {
  e.printStackTrace();
  } ffiinnaallllyy {
  iiff (open != null) {
  ttrryy {
  open.close();
  } ccaattcchh (IOException e) {
  e.printStackTrace();
  }
  }
  }

89. Where are lay out details placed? Why?

- Layout details are placed in XML files
- XML-based layouts provide a consistent and standard means of setting GUI definition format. 

90. Which are the different tags that are required to create reusable user interface that include the layout?

Android offers wide range of user interface widgets through which the reusable user interface can be made. It requires some buttons to be made and also allow multiple widgets to be combined using the single and reusable component. There are XML layout files that are used in which each tag can be mapped to the class instance. The tags that are used are:
- <requestFocus />: this allows the component to remain in focus.
- <merge />: merge the components and their properties into one to create a reusable component code
- <include />: this includes the library files and visual components of XML. This also uses 
- <merge /> tag that can be combined with it to create the merging layout. 
To create the layout these are the tags that are required and essential. The XML visual components are also used to define the overall structure of the layout. 

91. Which dialog boxes are supported by android?

Android supports 4 dialog boxes:

a.) AlertDialog: Alert dialog box supports 0 to 3 buttons and a list of selectable elements which includes check boxes and radio buttons. 

b.) ProgressDialog: This dialog box is an extension of AlertDialog and supports adding buttons. It displays a progress wheel or bar.

c.) DatePickerDialog: The user can select the date using this dialog box. 

d.) TimePickerDialog: The user can select the time using this dialog box.

92. Why are parts of Android developed in private?

It typically takes over a year to bring a device to market, but of course device manufacturers want to ship the latest software they can.
  Developers, meanwhile, don’t want to have to constantly track new versions of the platform when writing apps. Both groups experience a tension between shipping products, and not wanting to fall behind.
  To address this, some parts of the next version of Android including the core platform APIs are developed in a private branch. These APIs constitute the next version of Android. Our aim is to focus attention on the
  current stable version of the Android source code, while we create the next version of the platform as driven by flagship Android devices. This allows developers and OEMs to focus on a single version without having to track unfinished future work just to keep up. Other parts of the Android system that aren’t related to application compatibility are developed in the open, however. It’s our intention to move more of these parts to open development over time.

The CDD will evolve over time to reflect market realities. For instance, the 1.6 CDD only allows cell phones, but the 2.1 CDD allows devices to omit telephony hardware, allowing for non-phone devices such as tablet-style music players to be compatible. As we make these changes, we will also augment Android Market to allow developers to retain control over where their apps are available. To continue the telephony example, an app that manages SMS text messages would not be useful on a media player, so Android Market allows the developer to restrict that app exclusively to phone devices.

93. Why is Google in charge of Android?

Launching a software platform is complex. Openness is vital to the long-term success of a platform, since openness is required to attract investment from developers and ensure a level playing field. However, the platform itself must also be a compelling product to end users.

  

That’s why Google has committed the professional engineering resources necessary to ensure that Android is a fully competitive software platform. Google treats the Android project as a full-scale product development operation, and strikes the business deals necessary to make sure that great devices running Android actually make it to market.

  

By making sure that Android is a success with end users, we help ensure the vitality of Android as a platform, and as an open-source project. After all, who wants the source code to an unsuccessful product?

  

Google’s goal is to ensure a successful ecosystem around Android, but no one is required to participate, of course. We opened the Android source code so anyone can modify and distribute the software to meet their own needs.

94. Why to use Android?

Android is useful because:

  • It is simple and powerful SDK
  • Licensing, Distribution or Development fee is not required
  • Easy to Import third party Java library
  • Supporting platforms are - Linux, Mac Os, Windows 

95. Write a program that shows the creation of reusable user interface that includes the layout.

The program that uses the reusable user interface including the layout is given below:
<com.android.launcher.Workspace
android:id="@+id/workspace"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
launcher:defaultScreen="1">
<include android:id="@+id/cell1" layout="@layout/work" />
<include android:id="@+id/cell2" layout="@layout/work" />
</com.android.launcher.Workspace>
The tag that is used in this are:
<include />: this is the element tag and it includes other XML layout files. It calls the layout files by using their name and including @layout. This @ defines the inclusion of layout file in the program. The same out in the example is included two times. The tag overrides some attributes that are included in the layout. The id can be added that uniquely identifies the application and the components that are used inside it. 

96. Write a program to show the addition and removing of the package.

The package is a collection of similar or different classes that can be added or removed. The package that is added with the following parameter in the command as PACKAGE_ADDED action this allow to broadcast the message of addition to the entire system and in the same way the remove command action i.e. PACKAGE_REMOVED is used. The program that performs both the action is as follows:

<receiver android:name ="com.android.samples.app.PackageReceiver">
<intent-filter>
<action android:name="android.intent.action.PACKAGE_ADDED"/>
<action android:name="android.intent.action.PACKAGE_REMOVED"/> 
<data android:scheme="package" />
</intent-filter>
</receiver>