Download Detect Calls Sample (25)

In one of my project, I wanted to detect incoming and outgoing calls. I used BroadcastReceiver with action android.intent.action.NEW_OUTGOING_CALL and android.intent.action.PHONE_STATE.

The android.intent.action.NEW_OUTGOING_CALL will be broadcasted when an outgoing call is initiated. The receiving intent will have an extra string variable Intent.EXTRA_PHONE_NUMBER which contains the outgoing number. This requires the permission android.permission.PROCESS_OUTGOING_CALLS.

To detect the incoming call, we register a BroadcastReceiver for the action android.intent.action.PHONE_STATE. This will be broadcasted when there is a change in phone state. The receiving intent will have an extra string variable TelephonyManager.EXTRA_STATE which describes the phone state. If this state is TelephonyManager.EXTRA_STATE_RINGING then there will be another extra string variable TelephonyManager.EXTRA_INCOMING_NUMBER. This variable contains the incoming phone number. Note that this variable will not be present when the state is not TelephonyManager.EXTRA_STATE_RINGING.

The sample application is a simple one just for demonstration. The application registers for these actions and when the calls are detected it just displays a toast.

Download Connectivity Sample (19)

Most of the time we need to connect to internet to download or upload data. If the downloading or uploading is a lengthy process, we need to know when the network connected or gone, so that we can temporarily pause the uploading or downloading and resume once the connection is established. In Android we can register a BroadcastReciver with action ConnectivityManager.CONNECTIVITY_ACTION. System will broadcast this whenever a change in the network connectivity occurs.

Information regarding the connection will be there in the receiving intent. Some of them are:

ConnectivityManager.EXTRA_EXTRA_INFO
A string value indicating the network state.

ConnectivityManager.EXTRA_IS_FAILOVER
A boolean value indicates whether the connection manager is failing over or not.

ConnectivityManager.EXTRA_NETWORK_INFO
A NetworkInfo class with network information.

ConnectivityManager.EXTRA_NO_CONNECTIVITY
A boolean value indicating there is no internet connectivity.

ConnectivityManager.EXTRA_OTHER_NETWORK_INFO
A NetworkInfo class with network information of another network that may be connected.

ConnectivityManager.EXTRA_REASON
A String value about the reason of the connection failure.

You can check either ConnectivityManager.EXTRA_EXTRA_INFO or NetworkInfo.State from the ConnectivityManager.EXTRA_NETWORK_INFO key.

Download Log Viewer Sample (21)

Here is a sample application to view logcat messages on device. The application runs the command “logcat” using Runtime class, reads each log string and adds the string to a list view. Whenever you click on an item, an alert box is displayed with the corresponding log message.

Download RSS Reader (21)

Just for fun and time-pass I created a sample RSS reader application based on this article. I think it is better to share it here.

Point of Interest: Downloading XML data from Internet, XML parsing, AsyncTask.

Download Camera Demo (75)

Almost all mobile phones have a built in digital camera. Android phones are no exception. In Android device, to access the camera hardware we use Camera class along with SurfaceView.

The Camera class let you change the settings, preview and take still pictures. The SurfaceView class is used to show the preview to the user. To use the camera feature you should have the android.permission.CAMERA permission.

First we create a SurfaceView to show the live preview. The SurfaceView class holds the surface to draw. We use the interface SurfaceHolder to access the underlying surface. We implement the callback interface SurfaceHolfer.Callback and add this to the SurfaceHolder using SurfaceHolder.addCallback method. The SurfaceHolfer.Callback interface has three methods:

abstract void surfaceChanged(SurfaceHolder holder, int format, int width, int height)
abstract void surfaceCreated(SurfaceHolder holder)
abstract void surfaceDestroyed(SurfaceHolder holder)

The surfaceCreated method will be called after the surface is created, surfaceChanged will be after any changes have been made to the surface and surfaceDestroyed will be called after the surface is destroyed.

To find more about the SurfaceView and SurfaceHolder interface refer to the Google documentation.

Once our surface is created we open the Camera using Camera.open() method. After opening the camera, we set the live preview surface using setPreviewDisplay() method of the Camera class. We open and set the preview surface once the surfaceCreated() method is called because at this point the surface will be created and initialized properly.

Now we have to set the appropriate parameters to start the camera using the Camera.Parameters class. We can get the current camera parameter using the getParameters() method of the Camera class. We set the camera parameter once the surfaceChaneged() method is called. Once we set all the camera parameters we can start preview using Camera.startPreview() method. This will start the live preview.

The Camera class uses different callback interface to report different events to the application. The following callback interfaces are used to notify the events;

Camera.AutoFocusCallback
Camera.ErrorCallback
Camera.PictureCallback
Camera.PreviewCallback
Camera.ShutterCallback

The Camera.AutoFocusCallback interface is used to notify the completion of auto focus. Note that all devices may not have auto-focus feature. The onAutoFocus() will be called once the auto focus in finished. We use Camera.autoFocus() method to start the auto focus.

The Camera.ErrorCallback interface is used to notify when an error occurred. The onError() method will be called if an error occurred during the camera operation.

The Camera.PictureCallback interface is used to supply the image data after the picture is taken. The onPictureTaken() method will be called once the data is available. The format of the data depends on the current camera picture format which can be set using Camera.Parameters class.

The Camera.PreviewCallback interface is used to notify the supply the current preview frame. The onPreviewFrame() method will be called when the preview frame is available. Again the format of the data depends on the current camera picture format.

The Camera.ShutterCallback interface is to notify when the picture is captured from the camera. The onShutter() method will be called once the picture is taken from the camera.

To take a still picture, we use the method Camera.takePicture() The takePicture() method has three parameters. First one is a Camera.ShutterCallback interface to notify when the picture is captured from the camera. Second one is Camera.PictureCallback interface to notify when raw data is available from the camera. The third one is another Camera.PictureCallback interface when the JPEG data is available from the device.

In API version 5 or above there is another variant of takePicture() method. This method accepts 4 parameters. The first and second are same as the previous one. The third is the Camera.PictureCallback interface which is used to notify when completely scaled postview image is available. The forth one is the same as the third parameter in the first variant.

The data will be supplied to the calling application, the application can use this data for post processing or saving to a file.

In API version 8 or above, we can use the method Camera.setDisplayOrientation() method to set the orientation of the display. This is used by portrait applications to correctly display the live preview. In versions prior to 8, we can safely use the landscape mode to correctly display the preview.

The sample application displays the live preview. When the take picture button is clicked the image is saved to sdcard using time as the filename.

Happy Camera Coding

Download Application Launcher Source Code (37)

In Android we use intent to start an activity, start a service, send broadcasts, etc. Intent is used for late runtime binding of applications. In Android intent represents the action to be performed. There are two primary information in an intent, they are action and data. Action attribute represents the action to be performed such as edit, view, dial, etc. The data attribute is the data to be operated on. Some of the common actions are ACTION_VIEW, ACTION_DIAL, ACTION_EDIT, ACTION_PICK, ACTION_SEND, ACTION_SEARCH, ACTION_CALL, etc. The following code snippets show some of the examples:

Start the email client

final String[] addressList = new String[] { toAddress };

final Intent email_intent = new Intent(android.content.Intent.ACTION_SEND);
email_intent.setType("message/rfc822");
email_intent.putExtra(android.content.Intent.EXTRA_EMAIL, addressList);
email_intent.putExtra(android.content.Intent.EXTRA_SUBJECT, "Sample mail");
email_intent.putExtra(android.content.Intent.EXTRA_TEXT, "Sample mail for testing purpose");

startActivity(Intent.createChooser(email_intent, "Send mail..."));

Dial a number

// needs permission android.permission.CALL_PHONE
Intent intent = new Intent(Intent.ACTION_CALL,Uri.parse("tel://123456789"));

startActivity(intent);

Start a web search

Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);

intent.putExtra(SearchManager.QUERY, "Krishnaraj Varma");

startActivity(intent);

For a more detailed information about intent and intent action follow this link

There is another method to start an application using PackageManager class. This class has a method getLaunchIntentForPackage which will return the LAUNCHER intent of the specified package or null if not found. We can use this returned intent to start the application. The following code snippet starts the example application of this article:

PackageManager packageManager = getPackageManager();
String packageName = "com.varma.samples.applauncher";

try
{
	Intent intent = packageManager.getLaunchIntentForPackage(packageName);

	if(null != intent)
	{
		startActivity(intent);
	}

}
catch (NameNotFoundException e)
{
	e.printStackTrace();
}
catch (ActivityNotFoundException e)
{
	e.printStackTrace();
}

To enumerate all the installed application packages, we can use getInstalledApplications method of the PackageManager class. This method returns a list of ApplicationInfo class. The ApplicationInfo class contains information regarding and application such as package name, label, icon, etc. This information comes from the AndroidManifest.xml file of the particular application.

The example application lists all the installed applications in a list view and when you click on an item, the application will be launched if a LAUNCHER intent is found.

Download TimeZone sample (29)

Recently in one of my project, time has to be displayed in different time zone. I used the class SimpleDateFormat class to convert and format the local time. This class has one convenient method setTimeZone, which converts the location time to the given time zone while formatting. The following code snippet converts the local time to another time zone:

SimpleDateFormat format = new SimpleDateFormat("EEE, MMM d, yyyy h:mm a");
format.setTimeZone(timezone);
format.format(new Date());

If you want to enumerate all the time zones, you can use the method getAvailableIDs of the TimeZone class. The method returns an array of string which contains all the timezone ids. The sample application lists all the time zones and the corresponding time.

Download CheckGPS (51)

While searching for how to programmatically find whether GPS is enabled or not in device, I found this excellent answer and created a sample application based on it. I think it is better to share it here.

Download TTS Engine Sample (50)

Android supports TextToSpeech (TTS) from version 1.6 onwards. The Android TextToSpeech can speak different languages such as English, German, French, etc…, but we have to download the language resource files first before using it. We can install the language files by launching Intent with action set to TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA. The following code launches the installation of language data:

Intent intent = new Intent();
intent.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
startActivity(intent);

The class android.speech.tts.TextToSpeech is used for TTS in Android. The constructor has two parameters, Context and TextToSpeech.OnInitListener. The TextToSpeech.OnInitListener’s onInit method will be called when the TTS engine is initialized. The status is passed to the onInit(int status) method. The value TextToSpeech.SUCCESS indicates success and TextToSpeech.ERROR indicates error.

Once it is successfully initialized we can use the speak method to start speaking. The syntax of speak method is:

 public int speak(String text, int queueMode, HashMap params)

The first parameter is the text to speak, second is parameter is the queuing mode. This parameter can be either TextToSpeech.QUEUE_ADD or TextToSpeech.QUEUE_FLUSH. The value TextToSpeech.QUEUE_FLUSH tells the system to drop all entries in the queue and start with the new text. TextToSpeech.QUEUE_ADD tells the system to append the new text the queue. The third parameter is a HashMap The key can have values TextToSpeech.Engine.KEY_PARAM_STREAM or TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID. If the key is TextToSpeech.Engine.KEY_PARAM_STREAM, then the value is one of the AudioManger’s stream types. When you specify one of these values, the TextToSpeech engine will use the settings of that particular stream to speak the text. Some of the possible values are:

String.valueOf(AudioManager.STREAM_ALARM)
String.valueOf(AudioManager.STREAM_MUSIC)
String.valueOf(AudioManager.STREAM_RING)

If the key is TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, then the value is a user defined string id. This can be used to check whether the TTS engine finished speaking the text or not. When the TTS engine finished speaking the text, the TextToSpeech.OnUtteranceCompletedListener’s onUtteranceCompleted method will be called. This technique is used in the sample application. For more information refer to the source code of the sample.

We can change the TTS engine’s language by using the method setLocale(Locale loc). The parameter loc specifies the Locale corresponds to desired language.

The speech rate can be set by using the method setSpeechRate(float speechRate). The parameter speechRate specifies the rate of the speech. 1 is normal rate. Lower values slow the speech rate and higher values increases the rate.

To change the pitch we use setPitch(float pitch). The parameter pitch specifies the pitch to use. 1 means normal, less than 1 lowers the tone and greater that 1 increases the tone.

I hope this gives you an introduction to the TTS in Android, for more detailed information refer to this excellent article.

Happy TTS coding!

Download IP Address Sample (54)

For one of my project I need to get the IP address of the device, I searched a lot and found this link.

The method is to enumerate all network interfaces and find the IP address if it is not loop-back adapter. This will give the IP address if you are connected to a network (WiFi or Cellular).

You can also use the WifiManger to get he IP address if you are connected to WiFi network. The following code retrieves the WiFi IP address:

WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
int ipAddress = wifiInfo.getIpAddress();

Note that the getIpAddress returns an integer value. To convert to readable format we can use the following code:

String.format("%d.%d.%d.%d",
(ipAddress & 0xff),
(ipAddress >> 8 & 0xff),
(ipAddress >> 16 & 0xff),
(ipAddress >> 24 & 0xff))

Note: To use the first method you need the android.permission.INTERNET permission, otherwise it will throw unknown error. For the second method you need android.permission.ACCESS_WIFI_STATE.