The Vital Guide to Android Interviewing
Posted On:
Sensor
: Provides methods to identify which capabilities are available for a specific sensor.SensorManager
: Provides methods for registering sensor event listeners and calibrating sensors.SensorEvent
: Provides raw sensor data, including information regarding accuracy.SensorEventListener
: Interface that defines callback methods that will receive sensor event notifications.
ContentProvider
and what is it typically used for?ContentProvider
manages access to a structured set of data. It encapsulates the data and provide mechanisms for defining data security. ContentProvider
is the standard interface that connects data in one process with code running in another process. Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType(HTTP.PLAIN_TEXT_TYPE); // "text/plain" MIME type
startActivity(sendIntent);
However, it is possible that there are no applications that can handle your intent. In this case, your application will crash when you invoke
startActivity()
. To avoid this, before calling startActivity()
you should first verify that there is at least one application registered in the system that can handle the intent. To do this use resolveActivity()
on your intent object:// Verify that there are applications registered to handle this intent
// (resolveActivity returns nullif none are registered)
if (sendIntent.resolveActivity(getPackageManager()) != null) {
startActivity(sendIntent);
}
See the Android developers guide for more information about implicit intents.onDestroy()
. The system calls this method on your activity as the final signal that your activity instance is being completely removed from the system memory. Usually, the system will call onPause()
and onStop()
before calling onDestroy()
.4. Describe a scenario, though, where
onPause()
and onStop()
would not be invoked.onPause()
and onStop()
will not be invoked if finish()
is called from within the onCreate()
method. This might occur, for example, if you detect an error during onCreate()
and call finish()
as a result. In such a case, though, any cleanup you expected to be done in onPause()
and onStop()
will not be executed.Although
onDestroy()
is the last callback in the lifecycle of an activity, it is worth mentioning that this callback may not always be called and should not be relied upon to destroy resources. It is better have the resources created in onStart() and onResume(), and have them destroyed in onStop() and onPause, respectively.Explain your answer.
PackageManager m = getPackageManager();
if (!m.hasSystemFeature(PackageManager.FEATURE_SENSOR_COMPASS)) {
// This device does not have a compass, turn off the compass feature
}
Answer 2: SensorManager m = getSensorManager();
if (!m.hasSystemFeature(SensorManager.FEATURE_SENSOR_COMPASS)) {
// This device does not have a compass, turn off the compass feature
}
Answer 3: Sensor s = getSensor();
if (!s.hasSystemFeature(Sensor.FEATURE_SENSOR_COMPASS)) {
// This device does not have a compass, turn off the compass feature
}
PackageManager
.SensorManager
and Sensor
are part of Android Sensor Framework and are used for direct access and acquisition of raw sensor data. These classes do not provide any method like hasSystemFeature()
which is used for evaluation of system capabilities.Android defines feature IDs, in the form of ENUMs, for any hardware or software feature that may be available on a device. For instance, the feature ID for the compass sensor is
FEATURE_SENSOR_COMPASS
.If your application cannot work without a specific feature being available on the system, you can prevent users from installing your app with a
element in your apps manifest file to specify a non-negotiable dependency.However, if you just want to disable specific elements of your application when a feature is missing, you can use the
PackageManager
class. PackageManager
is used for retrieving various kinds of information related to the application packages that are currently installed on the device.To learn more about compatibility and handling different types of devices or sensors please refer to the Android developers guide.
Intent
.Intent
include:- To start an activity: You can start a new instance of an Activity by passing an Intent to
startActivity()
method. - To start a service: You can start a service to perform a one-time operation (such as download a file) by passing an Intent to
startService()
. - To deliver a broadcast: You can deliver a broadcast to other apps by passing an Intent to
sendBroadcast()
,sendOrderedBroadcast()
, orsendStickyBroadcast()
.
Intent service = new Intent(context, MyService.class);
startService(service);
where MyService
accesses a remote server via an Internet connection.7. If the Activity is showing an animation that indicates some kind of progress, what issue might you encounter and how could you address it?
As a result, if such a delay occurs, the animation in the activity (and even worse, the entire UI thread) could be blocked and could appear to the user to be frozen while the client waits for a response from the service. This is because the service is started on the main application thread (or UI thread) in the Activity.
The problem can (and should) be avoided by relegating any such remote requests to a background thread or, when feasible, using an an asynchronous response mechanism.
Note well: Accessing the network from the UI thread throws a runtime exception in newer Android versions which causes the app to crash.
In an app youre working on, you notice that a views value is not being restored after screen reorientation. What could be a likely cause of the problem that you should verify, at a minimum, about that particular view?
id
. In order for the Android system to restore the state of the views in your activity, each view must have a unique ID, supplied by the android:id
attribute.More information is available here.
- port-forwarding services
- screen capture
- thread and heap information
- network traffic tracking
- incoming call and SMS spoofing
- simulating network state, speed, and latency
- location data spoofing
AsyncTask
and an Activity
? What problems can this result in? How can these problems be avoided?Then, when the AsyncTask does complete, rather than updating the UI of the new Activity, it updates the former instance of the Activity (i.e., the one in which it was created but that is not displayed anymore!). This can lead to an Exception (of the type
java.lang.IllegalArgumentException
: View not attached to window manager if you use, for instance, findViewById
to retrieve a view inside the Activity).Theres also the potential for this to result in a memory leak since the AsyncTask maintains a reference to the Activty, which prevents the Activity from being garbage collected as long as the AsyncTask remains alive.
For these reasons, using AsyncTasks for long-running background tasks is generally a bad idea . Rather, for long-running background tasks, a different mechanism (such as a service) should be employed.
Intent
? Can it be used to provide data to a ContentProvider
? Why or why not?Intent
object is a common mechanism for starting new activity and transferring data from one activity to another. However, you cannot start a ContentProvider
using an Intent
.When you want to access data in a
ContentProvider
, you must instead use the ContentResolver
object in your applications Context
to communicate with the provider as a client. The ContentResolver
object communicates with the provider object, an instance of a class that implements ContentProvider
. The provider object receives data requests from clients, performs the requested action, and returns the results.Activity implementations can optionally make use of the Fragment class for purposes such as producing more modular code, building more sophisticated user interfaces for larger screens, helping scale applications between small and large screens, and so on. Multiple fragments can be combined within a single activity and, conversely, the same fragment can often be reused across multiple activities. This structure is largely intended to foster code reuse and facilitate economies of scale.
A fragment is essentially a modular section of an activity, with its own lifecycle and input events, and which can be added or removed at will. It is important to remember, though, that a fragments lifecycle is directly affected by its host activitys lifecycle; i.e., when the activity is paused, so are all fragments in it, and when the activity is destroyed, so are all of its fragments.
More information is available here in the Android Developers Guide.
Parcelable is an Android specific interface where you implement the serialization yourself. It was created to be far more efficient than Serializable, and to get around some problems with the default Java serialization scheme.
Launch modes may be defined using one of two mechanisms:
- Manifest file. When declaring an activity in a manifest file, you can specify how the activity should associate with tasks when it starts. Supported values include:
standard
(default). Creates a new instance of the activity in the task from which it was started and route the intent to it.singleTop
. If an instance of the activity already exists at the top of the current task, the system routes the intent to that instance through a call to itsonNewIntent()
method, rather than creating a new instance of the activity.singleTask
. Creates a new task and instantiates the activity at the root of the new task. However, if an instance of the activity already exists in a separate task, the system instead routes the intent to the existing instance through a call to itsonNewIntent()
method. Only one instance of the activity can exist at a time.singleTop
. This is almost the same assingleTask
, but has the activity itself always as the unique member of its stack.
- Intent flags. Calls to startActivity() can include a flag in the Intent that declares if and how the new activity should be associated with the current task. Supported values include:
FLAG_ACTIVITY_NEW_TASK
. Same assingleTask
value in Manifest file (see above).FLAG_ACTIVITY_SINGLE_TOP
. Same assingleTop
value in Manifest file (see above).FLAG_ACTIVITY_CLEAR_TOP
. If the activity being started is already running in the current task, then instead of launching a new instance of that activity, all of the other activities on top of it are destroyed and this intent is delivered to the resumed instance of the activity (now on top), throughonNewIntent()
. There is no corresponding value in the Manifest file that produces this behavior.