Thursday, 5 November 2015

Sunday, 4 October 2015

Android: Enabling logs on Snowplow

As the tracking solutions in mobile is increasing, Snowplow could be a good solution to centralize the list of trackers.

By default, the logs on Snowplow is disabled. To enabled, use the follow code:

// Ask Logger level of Snowplow to log data com.snowplowanalytics.snowplow.tracker.utils.Logger.updateLogLevel(LogLevel.VERBOSE);

There are three log levels in Snowplow: e, d, and v, which corresponding to error, debug and verbose, respectively. So, there are four options for the parameter:

  • LogLevel.VERBOSE
  • LogLevel.DEBUG
  • LogLevel.ERROR
  • LogLevel.OFF
The last one is the one which comes by default, which turns offs the logs.

The another thing to take into accounts is the tags for the logging for Snowplow starts with "SnowplowTracker->"

Finally, this options must be done once the emitter and the tracker are set, otherwise they will turn off the logs.

Friday, 26 June 2015

Postman pattern

Postman Pattern is a improved Observer pattern specially for mobile phones. It deals with the problem that from the mobile phone, the observer could be not in the foreground when the data is coming from observable.

For this case, the observable acts like the postman, leaving the data (package) in the observer. When the Observer became visible again, it will check if it has some data (package) to be processed. If so, the data will be processed.

It includes the implementation for Android and some highlight for the source code, which is stored in GitHub here:

Friday, 5 June 2015

Adding Floating action button from Android design support library

Google released the Android design support library last weekend. It comes with some nice features to work Material design principles. Here I am going to explain how to use the Floating action button.

The source code of this project could be found here:

1. Integration
To integrate the library to our project, we just have to add the follow line to our build.gradle file:

compile ''

2. Adding the icon to the layout
Once the project has been synchronised, it is ready to add the icon. Here is an example of layout:



There two important things:
1. The main layout must be RelativeLayout, a layout which extends from it or any layout which uses layers. The FloatingActionButton must be the last element in the layout. This is because by using layers, one above the another, the order they are written in the XML file determines the superposition of the elements. This is, the last element is always the one on the top.

2. FloatingActionButton has been extended from ImageView, so it accepts src as parameters. To make the life easier, Google has released a set of icons that could be useful. They could be find here:

Just download the project and use the color and the size you like most.

3. Changing the color of the icon (Optional)
By default, the floating action button get the color from the accent color in the style. In my case, I am using Indigo. For more colours, check the Google design guide for colours.

To do so, the first thing is add the colours and the styles in the resources:
    <!-- Base application theme. -->
    <style name="Indigo" parent="Theme.AppCompat.Light.DarkActionBar">
        <item name="colorPrimary">@color/primary</item>
        <item name="colorPrimaryDark">@color/primary_dark</item>
        <item name="colorAccent">@color/accent</item>

    <!-- Indigo -->
    <color name="primary">#3F51B5</color>
    <color name="primary_dark">#303F9F</color>
    <color name="accent">#FF4081</color>
    <color name="text_primary">#D9FFFFFF</color>
    <color name="text_secondary">#D9000000</color>

Note that I am using the support library as it. If your minimal API is 21, you could use "android:colorPrimary" or so.
For more information about the theming for pre-Lollipop, check the Theming part of this guide:

Once this is done, just use the theme Indigo as the default theme:
    android:theme="@style/Indigo" >

Source code

More information

Wednesday, 3 June 2015

Android Interview questions

Update: By request of TopTal, I am including the questions they listed in their blog.
Here are a list of questions and possible answers that could be useful for the interview for Android developer.

Feel free to share them. I will try to update them over time.

1. How do you check if a specific value has been updated/set in Shared Preferences
Answer: With a rooted device or in a emulator, becoming superuser and then, check the follow folder:


There will be a xml file with the name of the shared preferences with all the values.

2. How do you know if an app is based on WebView or it is native
Answer1: With a rooted device or in a emulator, becoming superuser and then, check the follow folder:


If it is a web app, folders related with Web app will appears there. (Cache, SQL, etc)

Answer2: In the options of the developer, activate the option to show the design limits. If the app is native, all the elements of ui will have its own limits. Otherwise, there will a whole block of limits in the WebView element.

(TopTal) 3. There are four Java classes related to the use of sensors on the Android platform. List them and explain the purpose of each.

- 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.

(Toptal) 4. What is a Content Provider and what is it typically used for?

A ContentProvider manages access to a structured set of data. It encapsulates the data and provider mechanisms for defining data security. ContentProvider is the standard interface that connects data in one process with code running in another process.

(TopTal) 5. Under what condition could the code sample below crash your application? How would you modify the code to avoid this potential problem? Explain your answer.

Intent sendIntent = new Intent();
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType(HTTP.PLAIN_TEXT_TYPE);  // "text/plain" MIME type

An implicit intent specifies an action that can invoke any app on the device able to perform action. Using an implicit intent is useful when your app cannot perform the action, but other apps probably can. If there is more than one application registered that can handle this request, the user will be prompted to select which one to use.

However, it is possible that there are no application 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 event
// (resolveActivity returns null if none are registered)
if (sendIntent.resolveActivity(getPackageManager()) != null) {

(TopTal) 6. The last callback in the lifecycle of an activity is 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(). Describe a scenario, through, 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.

Best practice in Android development is to have the activity perform most cleanup during onPause() and onStop(). However, if the activity includes background thread that are created during onCreate(), or other long-running resources that could potentially leak memory if not properly closed, you should kill them during onDestroy().

Author note: I am not so agree with last part of the answer that TopTal gives. There is not guarantee that onDestroy() will be called when the O.S. need to clean up the memory. In fact, the unique method that for sure the O.S. will call is onPasuse().

The best practice is having the resources created on onStart() and on onResume() and those same resources be destroyed/saved in onStop() and on onPause() respectively.

More info here:
Android Developers - Activity

(Toptal) 7. Which of the code snippets below is the correct way to check if a Compass sensor is present on the system? Explain your answer.

Answer 1:
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 doe snot 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

The correct answer is Answer1, the version that uses 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 mehtod like hasSystemFeature() which is used for evaluation of system capabilities.

Android devices 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 <uses-feature> element in your app's manifest file to specify a non-negotiable dependency.

However, if you just want to disable specific element 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.

(TopTal) 8. Describe three common use cases for using an Intent

Common use cases for using an Intent includes:
- 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 abroadcast to other apps by passing an intent to sendBroadcast().

(TopTal) 9. Suppose that you are starting a service in an Activity as follows:

Intent service = new Intent(context, MyService.class);

Where MyService accesses a remote server via an Internet connection.

If the Activity is showing an animation that indicates some kind of progress, what issue might you encounter and how could you address it?

Responses from a remote service via the Intent can often take some time, either due to networking latencies, or load on the remote server, or the amount of time it takes for the remote service to process and respond to the request.

As 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 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.

(Toptal) 10. Normally, in the process of carrying out a screen reorientation, the Android platform tears down the foreground activity and recreate it, restoring each of the view values in the activity's layout.

In an app you're working on, you notice that a view's 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?

You should verify that it has a valid 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.

(Toptal) 11. What is DDMS? Describe some of its capabilities.

DDMS is the Dalvik Debug Monitor Service that ships with Android. It provides a wide array of debugging features including:
- 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

(Toptal) 12. What is the relationship between in the life cycle of an AsyncTask and an Activity? What problems can this result in? How can these problems be avoided?

An AsyncTask is not tied to the lifecycle of the Activity that contains it. So, for example, if you start an AsyncTask inside an Activity and the user rotates the device, the Activity will be destroyed (and a new Activity instance will be created) but the AsyncTask will not die but instead goes on living until it completes.

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)

There's also the potential for this to result in a memory leak since the AsyncTask maintains a reference to the Activity, 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.

(Toptal) 13. What is an Intent? Can it be used to provide data to a ContentProvider? Why or why not?

The Intent object is common mechanism for starting new activity and transferring data from one activity to another. However, you cannot start a ContentProvider using Intent.

When you want to access data in a ContentProvider, you must instead use the ContentResolver object in your application's 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.

(Toptal) 14. What is the difference between a fragment and an activity? Explain the relationship between two.

An activity is typically a single, focused operation that a user can perform(such as dial a number, take a picture, send an email, view a map, etc.). Yet at the same time, there is nothing that precludes a developer from creating an activity that is arbitrarily complex.

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, which its own lifecycle and input events, and which can be added or removed at will. It is important to remember, though, that a fragment's lifecycle is directly affected by its host activity's 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.

(Toptal) 15. What is difference between Serializable and Parcelable? Which is best approach in Android?

Serializable is a standard Java interface. You simply mark a class Serializable y implementing the interface, and Java will automatically serialize it in certain situations.

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.

(Toptal) 16. What are "launch modes"? What are the two mechanisms by which they can be defined? What specific types of launch modes are supported?

A "launch mode" is the way in which a new instance of an activity is to be associated with the current task.

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 its onNewIntent() method, rather then 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 ot the existing instance thorugh a call to its onNewIntent() method. Only one instance of the activity can exist at a time.

    - singleInstance. Same as singleTask, except that the system doesn't launch any other activities into the task holding the instance. The activity is always the single and only member of its task; any activities started by this one open in a separate task.

- Intent flags. Calls to startActivity() can include a flag in the Intent that declares if an how the new activity should be associated with the current task. Supported values include:

    - FLAG_ACTIVITY_NEW_TASK. Same as singleTask value in the Manifest. (see above)
    - FLAG_ACTIVITY_SINGLE_TOP. Same as singleTop value in the Manifest file (see above).
    - FLAG_ACTIVITY_CLEAN_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 the top of it are destroyed and this intent is delivered to the resumed instance of the activity (now on top), through onNewIntent(). There is no corresponding value in the Manifest file that produces this behavior.

Toptal - 14 Essential Android Interview Questions