SUMMER TRAINING REPORT

ON

Location sharing and message sender Android Application

  SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENT FOR THE AWARD OF THE DEGREE OF

BACHELOR OF TECHNOLOGY 

(INFORMATION TECHNOLOGY) AT

XPERT INFOTECH

SUBMITTED BY                                         SUBMITTED TO

NAME-KAVITA SHARMA                                      ER. XYZ

ROLL NO. 00370107711                                          CHAIRPERSON-ME DEPT. IT

SESSION 2013-2014

DEPARTMENT OF INFORMATION TECHNOLOGY

 ANSAL INSTITUTE OF TECHNOLOGY

  (AFFILIATED BY GURU GOBIND SINGH INDRAPRASTHA UNIVERSITY)

PLACE-122001

Acknowledgement

A research work owes its success from commencement to completion, to the people in love with researchers at various stages. Let me in this page express my gratitude to all those who helped us in various stage of this study. First, I would like to express my sincere gratitude indebtedness to Mr. Alok Kushwaha (HOD, Department of Computer Science & Engineering, Ansal Institute of Technology, Gurgaon) for allowing me to undergo the summer training at Xpert InfoTech in Android Application Development

I am grateful to our guide Mr. Narayanan Chandra for the help provided in completion of the project, which was assigned to me. Without his friendly help and guidance it was difficult to develop this project. I am also thankful to Mrs. Anju Bala, Assistant Professor CSE, for her true help, inspiration and for helping me to preparation of the final report and presentation.

Last but not least, I pay my sincere thanks and gratitude to all the Staff Members of for their support and for making our training valuable and fruitful.

Submitted to:

Mrs. Anju BalaIncharge Summer TrainingIT-2013

Certificate

This is to certify that Kavita Sharma of Bachelor of Information Technology ( B.Tech IT) ,has completed

Summer Training on the topic Android application Development from Xpert InfoTech , Nirman Vihar ,

Delhi organization as partial fulfillment of Bachelor of Engineering IT. The summer Training report and

presentation by her is genuine work done by her and the same is being submitted for evaluation.

Signature

Mrs. Anju Bala

In charge Summer Training

Department of CSE

Engineering College Bikaner

Preface

Location Tracer and automatic message sender is the android application helps android users to get distance and time to reach a particular destination, when user reached the destination, automatic message will send to the person ,whom user wants to inform that he has reached his destination. This application targeted all android devices tablet, cell phones etc. This Application trace users current location and compare it with the destination location which is set by the user at every one sec, if distance between both locations is less than hundred meter then message will send to a person whose number is set by the user. This application also helps users to get the minimum time required to reach the destination. Users can check distance and time at any time.It also displays route from his location to destination in Google Map with Red marker line.

Organization Introduction

 XPERT INFOTECH is the largest privately held provider of IT training, enterprise learning

services, software and Web Development solutions for information technology (IT) and

management professionals. XPERT INFOTECH provides end-to-end learning services and

solutions that create a quantifiable path to improved performance and increased knowledge for

enterprise customers around India.

XPERT INFOTECH the leading learning solutions and professional services provider in India. It

focused on meeting the growing need for Information and Communication Technology (ICT)

expertise in both global and local markets. Providing its clients with IT Training, Corporate

Training, Software development, Web Development and Consultancy Services. XPERT

INFOTECH enables its clients to accelerate their business growth through more effective use of

ICT in their respective industry.

XPERT INFOTECH Training Division is a professional training Company offering IT enabled

services & industrial trainings for B.E., B-Tech, MCA, BCA, MSc and MBA fresher’s and

experienced Developers/programmers in various platforms. Summer Training /industrial training

will be provided for the students of BCA, B-TECH, M.TECH, MBA and MCA only. Deserving

candidates may be awarded stipends, scholarships and other benefits, depending on their

performance and recommendations of the mentors.

1. Introduction to Android Application Development

World is contracting with the growth of mobile phone technology. As the number of users is increasing day by day, facilities are also increasing. Starting with simple regular handsets which were used just for making phone calls, mobiles have changed our lives and have become part of it. Now they are not used just for making calls but they have innumerable uses and can be used as a Camera , Music player, Tablet PC, T.V. , Web browser etc . And with the new technologies, new software and operating systems are required.

Introduction to android:

Android is a software bunch comprise not only operating system but also middleware and key applications. Android Inc was founded in Palo Alto of California, U.S. by Andy Rubin, Rich miner, Nick sears and Chris White in 2003. Later Android Inc. was acquired by Google in 2005. After original release there have been number of updates in the original version of Android.

Features and Specification

Android is a powerful Operating System supporting a large number of applications in Smart

Phones. These applications make life more comfortable and advanced for the users. Hardwares

that support Android are mainly based on ARM architecture platform. Some of the current

features and specifications of android are:

Android comes with an Android market which is an online software store. It was developed by Google. It allows Android users to select, and download applications developed by third party developers and use them. There are around 2.0 lack+ games, application and widgets available on the market for users.

 ApplicationsThese are the basics of Android applications:•      Android applications are composed of one or more application components (activities, services, content providers, and broadcast receivers)•      Each component performs a different role in the overall application behavior, and each one can be activated individually (even by other applications)•      The manifest file must declare all components in the application and should also declare all application requirements, such as the minimum version of Android required and any hardware configurations required•      Non-code application resources (images, strings, layout files, etc.) should include alternatives for different device configurations (such as different strings for different languages)

Building blocks to an Android application

There are four building blocks to an Android application:

Activity

Broadcast Intent Receiver

Service

Content Provider

Activity

Activities are the most common of the four Android building blocks. An activity is usually a

single screen in your application. Each activity is implemented as a single class that extends the

Activity base class. Your class will display a user interface composed of Views and respond to

events. Most applications consist of multiple screens. For example, a text messaging application

might have one screen that shows a list of contacts to send messages to, a second screen to write

the message to the chosen contact, and other screens to review old messages or change settings.

Each of these screens would be implemented as an activity. Moving to another screen is

accomplished by a starting a new activity. In some cases and activity may return a value to the

previous activity -- for example an activity that lets the user pick a photo would return the chosen

photo to the caller.

Intent and Intent Filters

Android uses a special class called Intent to move from screen to screen. Intent describes what an

application wants done. The two most important parts of the intent data structure are the action

and the data to act upon. Typical values for action are MAIN (the front door of the application),

VIEW, PICK, EDIT, etc. The data is expressed as a URI. For example, to view contact

information for a person, you would create intent with the VIEW action and the data set to a URI

representing that person.

There is a related class called an Intent Filter. While an intent is effectively a request to do

something, an intent filter is a description of what intents an activity (or Broadcast Receiver, see

below) is capable of handling. An activity that is able to display contact information for a person

would publish an Intent Filter that said that it knows how to handle the action VIEW when

applied to data representing a person. Activities publish their Intent Filters in the

AndroidManifest.xml file.

. The new activity is informed of the intent, which causes it to be launched. The process of

resolving intents happens at run time when start Activity is called, which offers two key benefits:

Activities can reuse functionality from other components simply by making a request in

the form of an Intent

Activities can be replaced at any time by a new Activity with an equivalent Intent Filter

BROADCAST INTENT RECEIVER

You can use a Broadcast Receiver when you want code in your application to execute in reaction

to an external event, for example, when the phone rings, or when the data network is available,

or when it's midnight. Broadcast Receivers do not display a UI, although they may use the

Notification Manager to alert the user if something interesting has happened. Broadcast

Receivers are registered in AndroidManifest.xml, but you can also register them from code using

Context.registerReceiver (). Your application does not have to be running for its

BroadcastReceivers to be called; the system will start your application, if necessary, when a

BroadcastReceiver is triggered. Applications can also send their own intent broadcasts to others

with Context.sendBroadcast ().

SERVICE

A Service is code that is long-lived and runs without a UI. A good example of this is a media

player playing songs from a play list. In a media player application, there would probably be one

or more activities that allow the user to choose songs and start playing them. However, the music

playback itself should not be handled by an activity because the user will expect the music to

keep playing even after navigating to a new screen. In this case, the media player activity could

start a service using Context.startService () to run in the background to keep the music going.

The system will then keep the music playback service running until it has finished. Note that you

can connect to a service (and start it if it's not already running) with the Context.bindService ()

method. When connected to a service, you can communicate with it through an interface exposed

by the service. For the music service, this might allow you to pause, rewind, etc.

CONTENT PROVIDER

Applications can store their data in files, an SQLite database, or any other mechanism that makes

sense. A content provider, however, is useful if you want your application's data to be shared

with other applications. A content provider is a class that implements a standard set of methods

to let other applications store and retrieve the type of data that is handled by that content

provider.

Not every application needs to have all four, but your application will be written with some

combination of these.

All the components needed for android application should listed in an xml file called

AndroidManifest.xml. This is an XML file where you declare the components of your

application and what their capabilities and requirements are.

Storing, Retrieving and Exposing Data

A typical desktop operating system provides a common file system that any application can use

to store and read files that can be read by other applications. Android uses a different system on

Android, all application data are private to that application. However, Android also provides a

standard way for an application to expose its private data to other applications. This section

describes the many ways that an application can store and retrieve data, expose its data to other

applications, and also how you can request data from other applications that expose their data.

Android provides the following mechanisms for storing and retrieving data:

Preferences

A lightweight mechanism to store and retrieve key/value pairs of primitive data types.

This is typically used to store application preferences.

Files

You can store your files on the device or on a removable storage medium. By default,

other applications cannot access these files.

Databases

The Android APIs contain support for SQLite. Your application can create and use a

private SQLite database. Each database is private to the package that creates it.

Content Providers

A content provider is an optional component of an application that exposes read/write

access to an application's private data, subject to whatever restrictions it wants to

impose. Content providers implement a standard request syntax for data, and a

standard access mechanism for the returned data. Android supplies a number of

content providers for standard data types, such as personal contacts.

Network

Don't forget that you can also use the network to store and retrieve data.

Security and Permissions in Android

Android is a multi-process system, where each application (and parts of the system) runs in its

own process. Most security between applications and the system is enforced at the process level

through standard Linux facilities, such as user and group IDs that are assigned to applications.

Additional finer-grained security features are provided through a "permission" mechanism that

enforces restrictions on the specific operations that a particular process can perform, and per-URI

permissions for granting ad-hoc access to specific pieces of data.

System Architecture

A central design point of the Android security architecture is that no application, by default, has

permission to perform any operations that would adversely impact other applications, the

operating system, or the user. This includes reading or writing the user's private data such as

contacts or e-mails, reading or writing another application's files, performing network access,

keeping the device awake, etc.

An application's process is a secure sandbox. It can't disrupt other applications, except by

explicitly declaring the permissions it needs for additional capabilities not provided by the basic

sandbox. These permissions it requests can be handled by the operating in various ways,

typically by automatically allowing or disallowing based on certificates or by prompting the user.

The permissions required by an application are declared statically in that application, so they can

be known up-front at install time and will not change after that.

Application Signing

All Android applications (.apk files) must be signed with a certificate whose private key is held

by their developer. This certificate identifies the author of the application. The certificate does

not need to be signed by a certificate authority: it is perfectly allowable, and typical, for Android

applications to use self-signed certificates. The certificate is used only to establish trust

relationships between applications, not for wholesale control over whether an application can be

installed. The most significant ways that signatures impact security is by determining who can

access signature-based permissions and who can share user IDs.

User IDs and File Access

Each Android package (.apk) file installed on the device is given its own unique Linux user ID,

creating a sandbox for it and preventing it from touching other applications (or other applications

from touching it). This user ID is assigned to it when the application is installed on the device,

and remains constant for the duration of its life on that device.

Using Permissions

A basic Android application has no permissions associated with it, meaning it can not do

anything that would adversely impact the user experience or any data on the device. To make use

of protected features of the device, you must include in your AndroidManifest.xml one or more

<uses-permission> tags declaring the permissions that your application needs.

The permissions provided by the Android system can be found at Manifest.permission. Any

application may also define and enforce its own permissions, so this is not a comprehensive list

of all possible permissions.

A particular permission may be enforced at a number of places during your program's operation:

At the time of a call into the system, to prevent an application from executing

certain functions.

When starting an activity, to prevent applications from launching activities of

other applications.

Both sending and receiving broadcasts, to control who can receive your broadcast

or who can send a broadcast to you.

When accessing and operating on a content provider.

Binding or starting a service

Declaring and Enforcing Permissions

To enforce your own permissions, you must first declare them in your AndroidManifest.xml using one or more <permission> tags.

The <protection Level> attribute is required, telling the system how the user is to be informed

of applications requiring the permission, or who is allowed to hold that permission, as described

in the linked documentation.

The <permission Group> attribute is optional, and only used to help the system display

permissions to the user. You will usually want to set this to either a standard system group (listed

in android.Manifest.permission_group) or in more rare cases to one defined by yourself. It is

preferred to use an existing group, as this simplifies the permission UI shown to the user.

Note that both a label and description should be supplied for the permission. These are string

resources that can be displayed to the user when they are viewing a list of permissions

(android:label) or details on a single permission ( android:description). The label should be short,

a few words describing the key piece of functionality the permission is protecting. The

description should be a couple sentences describing what the permission allows a holder to do.

Our convention for the description is two sentences, the first describing the permission, the

second warning the user of what bad things can happen if an application is granted the

permission.

Development Process for Android Application

To develop apps for Android devices, you use a set of tools that are included in the Android SDK. Once you've downloaded and installed the SDK, you can access these tools right from your Eclipse IDE, through the ADT plugin, or from the command line. Developing with Eclipse is the preferred method because it can directly invoke the tools that you need while developing applications.

The basic steps for developing applications (with or without Eclipse) are shown in figure 1. The development steps encompass four development phases, which include:

1. SetupDuring this phase you install and set up your development environment. You also create Android Virtual Devices (AVDs) and connect hardware devices on which you can install your applications.

2. Development

During this phase you set up and develop your Android project, which contains all of the source code and resource files for your application

3. Debugging and Testing

During this phase you build your project into a debuggable .apk package that you can install and run on the emulator or an Android-powered device. If you are using Eclipse, builds are generated each time you project is saved. If you're using another IDE, you can build your project using Ant and install it on a device using adb.

4. Publishing

During this phase you configure and build your application for release and distribute your application to users.

2. Introduction to Google Services for Android Developer

Google APIs ConsoleThe Google APIs Console is a web interface for managing and viewing traffic data, authentication, and billing information for the Google APIs that are used by your project. In the APIs Console, a project is a named collection of information about your application: auth information, team members' email addresses, the Google APIs that your application uses, and so on. You can create your own projects, or be added as a viewer or editor to existing projects created by other developers. At the top of the Console is a dropdown list that shows the projects that you have access to, as well as commands for creating and managing projects

The Console lets you see and manage the following project information:

Activated APIsActivate one or more APIs to enable traffic monitoring, filtering, and billing, and API-specific pages for your project.

Traffic informationThe Console reports traffic information for each activated API. Additionally, you can cap or filter usage by API.

Project keysEach project is identified by either an API key or an OAuth 2.0 token. Use this key/token in your API requests to identify the project, in order to record usage data, enforce your filtering restrictions, and bill usage to the proper project. You can use the Console to generate or revoke API keys or OAuth 2.0 certificates to use in your application.

Steps to enable API access

1. Open Google API console window with your Google account.

2. Click on API Access and go to create new Android key, enter the SHA1 certificate Fingerprint.

SHA1 certificate fingerprint accessed by the following command:

keytool -list -v -keystore C:\Users\leon\.android\debug.keystore -alias androiddebugkey -storepass android -keypass android

It displays three keys SHA1, SHA2, MD5, user has to copy SHA1 key and paste it into configure android key window

3. Now your API key is generated as shown below which can be used to access Google APIs.

4. Now click on Services tap to activate various services provided by Google like Google map, Location API, calendar API etc. There are number of services available, enable the services which you want to use in your project .

Services used in my project are:

5. Now with the help of your API key you can use activated services in your project.

.

Google Maps Android v2

With the Google Maps Android API, you can add maps based on Google Maps data to your application. The API automatically handles access to Google Maps servers, data downloading, map display, and response to map gestures. You can also use API calls to add markers, polygons, and overlays to a basic map, and to change the user's view of a particular map area. These objects provide additional information for map locations, and allow user interaction with the map. The API allows you to add these graphics to a map:

Icons anchored to specific positions on the map (Markers). Sets of line segments (Polylines). Enclosed segments (Polygons). Bitmap graphics anchored to specific positions on the map (Ground Overlays). Sets of images which are displayed on top of the base map tiles (Tile Overlays).

Steps to use Google Map in Android Application:1. Select File > Import > Android > Existing Android Code Into Workspace and click Next.2. Select Browse..., enter <android-sdk-folder>/extras/google/google_play_services/libproject/

google-play-services_lib, and click Finish.Once you have installed Google Play services, you can view the sample code, or run the sample app locally. The sample app is an Eclipse project that you can run on your device as follows:

1. Select File > Import > Android > Existing Android Code Into Workspace and click Next.2. Select Browse..., enter <android-sdk-folder>/extras/google/google_play_services/samples/

maps, and click Finish.3. Select Project > Properties, select Java Build Path, and navigate to Libraries.4. Select Add External Jars, include the following jar files, and click OK: + <android-sdk-

folder>/extras/android/compatibility/v4/android-support-v4.jar5. Add your own Google Maps Android API key.6. Select Run > Run to test the sample app.

The Map Object

The Google Maps Android API allows you to display a Google map in your Android application.

These maps have the same appearance as the maps you see in the Google Maps for Mobile

(GMM) app, and the API exposes many of the same features. Two notable differences between

the GMM Application and the Maps displayed by the Google Maps Android API are:

Map tiles displayed by the API don't contain any personalized content, such as personalized

smart icons.

Not all icons on the map are clickable. For example, transit station icons can’t be clicked.

However, markers that you add to the map are clickable, and the API has a listener callback

interface for various marker interactions.

In addition to mapping functionality, the API also supports a full range of interactions that are

consistent with the Android UI model. For example, you can set up interactions with a map by

defining listeners that respond to user gestures.

The key class when working with a Map object is the GoogleMap class. GoogleMap models the

map object within your application. Within your UI, a map will be represented by either

a MapFragment or MapView object.

GoogleMap handles the following operations automatically:

Connecting to the Google Maps service.

Downloading map tiles.

Displaying tiles on the device screen.

Displaying various controls such as pan and zoom.

Responding to pan and zoom gestures by moving the map and zooming in or out.

In addition to these automatic operations, you can control the behavior of maps with objects and

methods of the API. For example, Google Map has callback methods that respond to keystrokes

and touch gestures on the map. You can also set marker icons on your map and add overlays to

it, using objects you provide to Google Map.

Google Direction API

The Google Directions API is a service that calculates directions between locations using an HTTP request. You can search for directions for several modes of transportation, include transit, driving, walking or cycling. Directions may specify origins, destinations and waypoints either as

text strings (e.g. "Chicago, IL" or "Darwin, NT, Australia") or as latitude/longitude coordinates. The Directions API can return multi-part directions using a series of waypoints.

This service is generally designed for calculating directions for static (known in advance) addresses for placement of application content on a map; this service is not designed to respond in real time to user input, for example. For dynamic directions calculations (for example, within a user interface element), consult the documentation for the JavaScript API V3 Directions Service.Calculating directions is a time and resource intensive task. Whenever possible, calculate known addresses ahead of time (using the service described here) and store your results in a temporary cache of your own design.

Direction Responses

Directions responses are returned in the format indicated by the output flag within the URL request's path.

1. JSON Output2. XML Output

1. PROJECT DESCRIPTION AND OBJECTIVES

Description:

The Location Tracer and Automatic message sender Android Application is a travelling

Application. Sometimes, we forget to inform our friends or our family that we have reached our

destination and get busy with our work. This application helps users to set their destination and

automatically will be sending to their friends or family that he reached his destination. This

application also shows route in Google map from his source to destination.

PROJECT OVERVIEW

This android application has the following features:

1) It helps android users to get distance and time required to reach his destination

2) Automatic message will be send to the number set by the user when he reached his

destination

3) Show your location on Google Map

4) Get Route from your source to destination

Implementation

This Android Application is implemented using following concepts

1) Retrieving current Location at every second

2) Retrieving Geo Coordinates of Destination

3) Read Contacts

4) Send SMS

5) Use Google Direction API

6) Google Maps android v2

1. Retrieving the Current Location

Location Services automatically maintains the user's current location, so all your app has to do is retrieve it as needed. The location's accuracy is based on the location permissions you've requested and location sensors that are currently active for the device.

Location Services sends the current location to your app through a location client, which is an instance of the Location Services class LocationClientt. All requests for location information go through this client.

Specify Application Permission:

Apps that use Location Services must request location permissions. Android has two location permissions: ACCESS_COARSE_LOCATION and ACCESS_FINE_LOCATION. The permission you choose controls the accuracy of the current location. If you request only coarse location permission, Location Services obfuscates the returned location to an accuracy that's roughly equivalent to a city block.

Requesting ACCESS_FINE_LOCATION implies a request for ACCESS_COARSE_LOCATION. For example, to add ACCESS_COARSE_LOCATION, insert the following as a child element of the <manifest>element:

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

Create LocationManager instance as reference to the location service:

For any background Android Service, we need to get reference for using it. Similarly, location service reference will be created using getSystemService() method. This reference will be added with the newly created LocationManager instance as follows.

locationManager=(LocationManager)getSystemService(Context.Location_Service);

Request current location from Location Manager:

After creating the location service reference, location updates are requested using requestLocationUpdates() method of LocationManager. For this function, we need to send the

type of location provider, number of seconds, distance and the LocationListener object over which the location to be updated.

locationManager.requestLocationUpdates (LocationManager.GPS_PROVIDER, 0, 0, this);

Receive location update from Location Listener on change of location

Location Listener will be notified based on the distance interval specified or the number seconds.

It will return current latitude and longitude Geo coordinates to the user. Now we have current Geo Coordinates to compare with the destination coordinates.

2. Retrieving Destination Geo Coordinates

Geo Coordinates: A geographic coordinate system is a coordinate system that enables

every location on the Earth to be specified by a set of numbers or letters. The coordinates are often chosen such that one of the numbers represents vertical position, and two or three of the numbers represent horizontal position. A common choice of coordinates is latitude, longitude and elevation.

Geocoder Class: A class for handling geocoding and reverse geocoding. Geocoding is the process of transforming a street address or other description of a location into a (latitude, longitude) coordinates. Reverse geocoding is the process of transforming a (latitude, longitude) coordinate into a (partial) address. The amount of detail in a reverse geocoded location description may vary, for example one might contain the full street address of the closest building, while another might contain only a city name and postal code. The Geocoder class requires a backend service that is not included in the core android framework. The Geocoder query methods will return an empty list if there no backend service in the platform. Use the isPresent() method to determine whether a Geocoder implementation exists.

Public Constructor for Geocoder class:

public Geocoder (Context context, Locale locale);

Method to retrieve Geo Coordinates from the given location we have to use public methods of Geocoder class

Public Methods used:

Public Methods

List<Address> getFromLocation(double latitude, double longitude, int maxResults)Returns an array of Addresses that are known to describe the area immediately surrounding the given latitude and longitude.

List<Address> getFromLocationName(String locationName, int maxResults)Returns an array of Addresses that are known to describe the named location,

which may be a place name such as "Dalvik, Iceland", an address such as "1600 Amphitheatre Parkway, Mountain View, CA", an airport code such as "SFO", etc..

Static boolean isPresent()Returns true if the Geocoder methods getFromLocation and getFromLocationName are implemented.

Code used to extract Geo Coordinates of any location:

protected Void doInBackground(Void... params) {try{Geocoder coder = new Geocoder(MainActivity.this, Locale.getDefault());

list = coder.getFromLocationName(dest.getText().toString(), 1);}

catch(Exception e){Log.i("MO", "Exception");

}

for (int i = 0; i < list.size(); i++) {Address add = list.get(i); lat = add.getLatitude(); lon =add.getLongitude();}}

3. Retrieving Contact List

The Contacts Provider is the central repository of the user's contacts information, including data from contacts apps and social networking apps. In your apps, you can access Contacts Provider information directly by calling ContentResolvermethods or by sending intents to a contacts app.

This class focuses on retrieving lists of contacts, displaying the details for a particular contact, and modifying contacts using intents. The basic techniques described here can be extended to perform more complex tasks. In addition, this class helps you understand the overall structure and operation of the Contacts Provider.

To extract contact list from the android device, we have to add Read contact permission in the manifest file.

  <uses-permission android:name="android.permission.READ_CONTACTS" />

Steps to retrieve contact list:

1. Define fragment that display list of contacts

To display the list of contacts, start by defining a Fragment that's loaded by an Activity. Using a Fragment is a more flexible technique, because you can use one Fragment to display the list and a second Fragment to display the details for a contact that the user chooses from the list.

To help you write queries against the Contacts Provider, the Android framework provides a contracts class called ContactsContract, which defines useful constants and methods for accessing the provider. When you use this class, you don't have to define your own constants for content URIs, table names, or columns. To use this class, include the following statement:

import android.provider.ContactsContract;

Since the code uses a CursorLoader to retrieve data from the provider, you must specify that it implements the loader interface LoaderManager.LoaderCallbacks. Also, to help detect which contact the user selects from the list of search results, implement the adapter interface AdapterView.OnItemClickListener.

2. Set up the Cursor Adapter for the list view

Set up the SimpleCursorAdapter that binds the results of the search to the ListView. To get the ListViewobject that displays the contacts, you need to call Activity.findViewById() using the parent activity of theFragment. Use the Context of the parent activity when you call setAdapter().

mCursorAdapter = new SimpleCursorAdapter(getActivity(),R.layout.contact_list_item,null,0);    mContactsList.setAdapter(mCursorAdapter);

3. Set the selected contact listener

When you display the results of a search, you usually want to allow the user to select a single contact for further processing. For example, when the user clicks a contact you can display the contact's address on a map. To provide this feature, you first defined the current Fragment as the click listener by specifying that the class implements AdapterView.OnItemClickListener, as shown in the section Define a Fragment that displays the list of contacts.

To continue setting up the listener, bind it to the ListView by calling the method setOnItemClickListener()in onActivityCreated()

public void onActivityCreated(Bundle savedInstanceState)        mContactsList.setOnItemClickListener(this);

4. Initialize the Loader

Since we're using a CursorLoader to retrieve data, you must initialize the background thread and other variables that control asynchronous retrieval. Do the initialization in onActivityCreated(), which is invoked immediately before the Fragment UI appears.

getLoaderManager().initLoader(0, null, this);

after using loader class, we have to retrieve the contact number based on the contact_ID, if we have number of contact numbers of same person then we have to display all number into separate list and then select any one number from list.

5. SMS in Android Development

SMS is an integral part of mobile devices and mobile applications. An overwhelming majority of mobile users use the SMS service on their mobiles; some use it dozens of times per day. Android provides a very good API so that developers can integrate SMS technology into their apps, increasing the utility and appeal of their applications. In this article we are going to examine several apps that use SMS technology via the APIs provided by Android.

Steps to send SMS from Android Application:

1. Create a UI (user interface) with two Edit Text element, one for Contact number and one for message which has to be send and one Button for sending SMS.

UI for the app will look like as follows:

2. Specify the permissions for sending the SMS

In Android, one has to specify all of the permissions needed by the app in the AndroidManifest.xml. By doing so while installing the app, all the permissions required by the app will be shown to the user.

<uses permission

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

3. Sending the SMS

To send the SMS, we get the number and message text that the user entered. e text that Then, we get the SmsManager object as follows:

SmsManager sms = SmsManager.getDefault();

4. Displaying a Toast When the Message is Successfully Sent

A toast provides simple feedback about an operation in a small popup. It only fills the amount of space required for the message and the current activity remains visible and interactive.

 Toast.makeText(getBaseContext(), "SMS sent",Toast.LENGTH_SHORT).show();

5. Get Route by Direction API

The Google Directions API is a service that calculates directions between locations using an HTTP request. You can search for directions for several modes of transportation, include transit,

driving, walking or cycling. Directions may specify origins, destinations and waypoints either as text strings (e.g. "Chicago, IL" or "Darwin, NT, Australia") or as latitude/longitude coordinates. The Directions API can return multi-part directions using a series of waypoints.

This service is generally designed for calculating directions for static (known in advance) addresses for placement of application content on a map; this service is not designed to respond in real time to user input, for example. For dynamic directions calculations (for example, within a user interface element), consult the documentation for the JavaScript API V3 Directions Service.

Calculating directions is a time and resource intensive task. Whenever possible, calculate known addresses ahead of time (using the service described here) and store your results in a temporary cache of your own design.

Directions Requests

A Directions API request takes the following form:

http://maps.googleapis.com/maps/api/directions/output?parameters

where output may be either of the following values:

json (recommended) indicates output in JavaScript Object Notation (JSON)

xml indicates output as XML

To access the Directions API over HTTPS, use:

https://maps.googleapis.com/maps/api/directions/output?parameters

HTTPS is recommended for applications that include sensitive user data, such as a user's

location, in requests.

Request Parameters

Certain parameters are required while others are optional. As is standard in URLs, all parameters

are separated using the ampersand (&) character. The list of parameters and their possible values

are enumerated below.

Required parameters

origin — The address or textual latitude/longitude value from which you wish to calculate

directions. If you pass an address as a string, the Directions service will geocode the string

and convert it to a latitude/longitude coordinate to calculate directions. If you pass

coordinates, ensure that no space exists between the latitude and longitude values.

destination — The address or textual latitude/longitude value from which you wish to

calculate directions. If you pass an address as a string, the Directions service will geocode the

string and convert it to a latitude/longitude coordinate to calculate directions. If you pass

coordinates, ensure that no space exists between the latitude and longitude values.

sensor — Indicates whether or not the directions request comes from a device with a location

sensor. This value must be either true or false.

Maps API for Business users must include valid client and signature parameters with their

Directions requests. Please refer to the Maps API for Business Web Serviceschapter for more

information.

Screen Shots

1. Set destination and contact number

2. Other features

3. Display Route from source to destination

4. Display current location