Chapter 6

Package is android.provider.Telephony.Sms
Contains all text-based SMS messages.
Nested Class

Telephony.Sms.Draft
Contains all draft text-based SMS messages in the SMS app.

Telephony.Sms.Inbox
Contains all text-based SMS messages in the SMS app inbox.

Telephony.Sms.Intents
Contains constants for SMS related Intents that are broadcast.

Telephony.Sms.Outbox
Contains all pending outgoing text-based SMS messages.

Telephony.Sms.Sent
Contains all sent text-based SMS messages in the SMS app.
Telephony.Sms.Conversations
Contains a view of SMS conversations (also referred to as threads).
• send SMS from our android application in two
ways either by using SMSManager API or
Intents .
• If we use SMSManager API, it will directly
send SMS from our application. In case if we
use Intent with proper action (ACTION_VIEW),
it will invoke a built-in SMS app to send SMS
from our application.
 1.Android Send SMS using SMSManager API

• SmsManager smgr = SmsManager.getDefault();

smgr.sendTextMessage(MobileNumber,null,Message,null,null);

• SMSManager API required SEND_SMS permission in our

android manifest to send SMS. Following is the code snippet to
set SEND_SMS permissions in manifest file.

• <uses-
permission android:name="android.permission.SEND_SMS"/>
 activity_main.xml
• <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/fstTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:layout_marginTop="150dp"
android:text="Mobile No" />
<EditText
android:id="@+id/mblTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:ems="10"/>
• <TextView
android:id="@+id/secTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Message"
android:layout_marginLeft="100dp" />
<EditText
android:id="@+id/msgTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:ems="10" />
<Button
android:id="@+id/btnSend"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
 MainActivity.java

import android.content.Intent;
import android.net.Uri;
import android.provider.Telephony;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.telephony.SmsManager;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

private EditText txtMobile;

private EditText txtMessage;
private Button btnSms;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txtMobile = (EditText)findViewById(R.id.mblTxt);
• txtMessage = (EditText)findViewById(R.id.msgTxt);
btnSms = (Button)findViewById(R.id.btnSend);
btnSms.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try{
SmsManager smgr = SmsManager.getDefault();

smgr.sendTextMessage(txtMobile.getText().toString(),null,txtMessage.getText().toString(),null,null);
Toast.makeText(MainActivity.this, "SMS Sent Successfully",
Toast.LENGTH_SHORT).show();
}
catch (Exception e){
Toast.makeText(MainActivity.this, "SMS Failed to Send, Please try again",
Toast.LENGTH_SHORT).show();
}
}
});
}
}
 AndroidManifest.xml
• <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.tutlane.sendsmsexample">
<uses-permission android:name="android.permission.SEND_SMS"/>
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
 2.Android Send SMS using Intent
• In android, Intent is a messaging object which is used to request
an action from another app component such as activities,
services, broadcast receivers, and content providers.
• To send SMS using the Intent object
Intent sInt = new Intent(Intent.ACTION_VIEW);
sInt.putExtra("address", new String[]{txtMobile.getText().toString()});
sInt.putExtra("sms_body",txtMessage.getText().toString());
sInt.setType("vnd.android-dir/mms-sms");

• Even for Intent, it required a SEND_SMS permission in our

android manifest to send SMS. Following is the code snippet to
set SEND_SMS permissions in manifest file.

• <uses-
permission android:name="android.permission.SEND_SMS"/>
btnSms.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try{
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse("smsto:"));
i.setType("vnd.android-dir/mms-sms");

i.putExtra("address", new String(txtMobile.getText().toString()));

i.putExtra("sms_body",txtMessage.getText().toString());
startActivity(Intent.createChooser(i, "Send sms via:"));
}
catch(Exception e){
Toast.makeText(MainActivity.this, "SMS Failed to Send,
Please try again", Toast.LENGTH_SHORT).show();
}
 Receive SMS
• Receive SMS Permissions
– We only need receive
permission android.permission.RECEIVE_SMS. In
case you also want to read SMS messages from the
Inbox then you need android.permission.READ_SMS.
 Intent Filter to receive SMS
• We also need to tell Android that we want to handle incoming
SMS messages. In order to do this, we will add a <receiver> to
register a broadcast receiver to the manifest XML. We will also
add an <intent-filter> to let Android know that we want to
launch a specific class when an SMS comes in.

<receiver android:name="com.javarticles.android.SMSReceiver">
<intent-filter>
<action
android:name="android.provider.Telephony.SMS_RECEIVED" /
>
</intent-filter>
</receiver>
 Broadcast Receiver

• SMSReceiver is a BroadcastReceiver. When

SMS is received, onReceive will be called. Here
we will look into the interested numbers
based on a setting. If the message has
originated from one of those numbers, we will
launch a new Activity, and pass the phone
number and the SMS message to the activity.
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

import android.os.Bundle;
import android.preference.PreferenceManager;
import android.telephony.SmsMessage;

public class SMSReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {

String phoneNumbers = PreferenceManager.getDefaultSharedPreferences(

context).getString("phone_entries", "");
StringTokenizer tokenizer = new StringTokenizer(phoneNumbers, ",");
Set<String> phoneEnrties = new HashSet<String>();
while (tokenizer.hasMoreTokens()) {
phoneEnrties.add(tokenizer.nextToken().trim());
 Bundle bundle = intent.getExtras();
Object[] pdus = (Object[]) bundle.get("pdus");
SmsMessage[] messages = new SmsMessage[pdus.length];
for (int i = 0; i < messages.length; i++) {
messages[i]= SmsMessage.createFromPdu((byte[]) pdus[i]);
String address = messages[i].getOriginatingAddress();
if (phoneEnrties.contains(address)) {
Intent newintent = new Intent(context, MainActivity.class);
newintent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
newintent.putExtra("address", address);
newintent.putExtra("message",
messages[i].getDisplayMessageBody());
context.startActivity(newintent);
}
}
}
}
 Main Activity
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class MainActivity extends Activity {

public void onCreate(final Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Bundle extras = getIntent().getExtras();
if (extras != null) {
String address = extras.getString("address");
String message = extras.getString("message");
TextView addressField = (TextView) findViewById(R.id.address);
TextView messageField = (TextView) findViewById(R.id.message);
addressField.setText(address);
messageField.setText(message);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu, menu);
return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
switch (id) {
case R.id.settings:
startActivity(new Intent(this, SettingsActivity.class));
}
return super.onOptionsItemSelected(item);
}
}
 Activity_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.javarticles.android.DatePickerExample" >

<TextView
android:id="@+id/welcome"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="40dp"
android:layout_marginTop="18dp"
android:text="@string/welcome"
android:textColor="@color/welcome_text_color"
android:textSize="20sp" />

<TextView
android:id="@+id/address"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />

<TextView
android:id="@+id/message"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<?xml version="1.0" encoding="utf-8"?>

package="com.javarticles.android"
android:versionCode="1"
AndroidManifest.xml:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"

android:versionName="1.0" >
<uses-sdk
android:maxSdkVersion="22"
android:minSdkVersion="14"
android:targetSdkVersion="22" />

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

<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher_sandbox"
android:label="@string/app_name" >
<activity android:name="com.javarticles.android.MainActivity" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<receiver android:name="com.javarticles.android.SMSReceiver">
<intent-filter>
<action android:name="android.provider.Telephony.SMS_RECEIVED" />
</intent-filter>
</receiver>
 Email
• To compose an email, use one of the below actions based on whether you'll
include attachments, and include email details such as the recipient and subject
using the extra keys listed below.
• ActionACTION_SENDTO (for no attachment) or
• ACTION_SEND (for one attachment) or
• ACTION_SEND_MULTIPLE (for multiple attachments)
• MIME Type
– "text/plain"“
– */*“
• Extras
– Intent.EXTRA_EMAIL A string array of all "To" recipient email addresses.
– Intent.EXTRA_CC A string array of all "CC" recipient email addresses.
– Intent.EXTRA_BCC A string array of all "BCC" recipient email addresses
– Intent.EXTRA_SUBJECT A string with the email subject.
– Intent.EXTRA_TEXT A string with the body of the email.
– Intent.EXTRA_STREAM A Uri pointing to the attachment. If using the
ACTION_SEND_MULTIPLE action, this should instead be an ArrayList containing
multiple Uri objects.
• public void composeEmail(String[] addresses, String
subject, Uri attachment) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("*/*");
intent.putExtra(Intent.EXTRA_EMAIL, addresses);
intent.putExtra(Intent.EXTRA_SUBJECT, subject);
intent.putExtra(Intent.EXTRA_STREAM, attachment);
if (intent.resolveActivity(getPackageManager()) != null) {
startActivity(intent);
}
}
• If you want to ensure that your intent is handled only by an email app
(and not other text messaging or social apps), then use the
ACTION_SENDTO action and include the "mailto:" data scheme.

• For example:
public void composeEmail(String[] addresses, String subject)
{
Intent intent = new Intent(Intent.ACTION_SENDTO);
intent.setData(Uri.parse("mailto:")); // only email apps should handle
this
intent.putExtra(Intent.EXTRA_EMAIL, addresses);
intent.putExtra(Intent.EXTRA_SUBJECT, subject);
if (intent.resolveActivity(getPackageManager()) != null)
{
startActivity(intent);
}
}
• <activity ...>
<intent-filter>
<action android:name="android.intent.action.SEND" />
<data android:type="*/*" />
<category
android:name="android.intent.category.DEFAULT" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SENDTO" />
<data android:scheme="mailto" />
<category
android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
 activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:androclass="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<EditText
android:id="@+id/editText1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentRight="true"
android:layout_alignParentTop="true"
android:layout_marginRight="22dp"
android:layout_marginTop="18dp"/>
<EditText
android:id="@+id/editText2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/editText1"
android:layout_alignLeft="@+id/editText1"
android:layout_marginTop="20dp"
/>
<EditText
android:id="@+id/editText3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
<TextView
android:id="@+id/textView1"
android:textColor="#0F9D58"
android:text="Send To:"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignBaseline="@+id/editText1"
android:layout_alignBottom="@+id/editText1"
android:layout_alignParentLeft="true"/> <TextView
android:id="@+id/textView2"
android:textColor="#0F9D58"
android:text="Email Subject:"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignBaseline="@+id/editText2"
android:layout_alignBottom="@+id/editText2"
android:layout_alignParentLeft="true"/>
<TextView
android:id="@+id/textView3"
android:textColor="#0F9D58"
android:text="Email Body:"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignBaseline="@+id/editText3"
android:layout_alignBottom="@+id/editText3"/>
<Button
android:id="@+id/button"
android:text="Send email!!"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.content.Intent;
import android.widget.EditText;
import android.view.View;
import android.view.View.OnClickListener;
import android.net.Uri;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {

// define objects for edit text and button

Button button;
EditText sendto, subject, body;

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

// Getting instance of edittext and button

sendto = findViewById(R.id.editText1);
subject = findViewById(R.id.editText2);
body = findViewById(R.id.editText3);
button = findViewById(R.id.button);
// attach setOnClickListener to button
// with Intent object define in it
button.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View view)
{
String emailsend = sendto.getText().toString();
String emailsubject = subject.getText().toString();
String emailbody = body.getText().toString();

// define Intent object

// with action attribute as ACTION_SEND
Intent intent = new Intent(Intent.ACTION_SEND);

// add three fiels to intent using putExtra function

intent.putExtra(Intent.EXTRA_EMAIL,
new String[] { emailsend });
intent.putExtra(Intent.EXTRA_SUBJECT, emailsubject);
intent.putExtra(Intent.EXTRA_TEXT, emailbody);

// set type of intent

intent.setType("message/rfc822");

// startActivity with intent with chooser

// as Email client using createChooser function
startActivity(
Intent
.createChooser(intent,
"Choose an Email client :"));
}
});
 Phone call
phone call from our android applications by invoking built-in phone calls app
using Intents action (ACTION_CALL).

Generally, the Intent object in android with proper action (ACTION_CALL) and data will help
us to launch a built-in phone calls app to make a phone calls in our application.

In android, Intent is a messaging object which is used to request an action from another app
component such as activities, services, broadcast receivers, and content providers. To
know more about an Intent object in android check this Android Intents with Examples.

To make a phone call using Intent object in android application, we need to write the code
like as shown below.

Intent callIntent = new Intent(Intent.ACTION_CALL);

callIntent.setData(Uri.parse("tel:" + txtPhone.getText().toString()));
startActivity(callIntent);
 activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/fstTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:layout_marginTop="150dp"
android:text="Mobile No"
/>
<EditText
android:id="@+id/mblTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:ems="10">
</EditText>
<Button
android:id="@+id/btnCall"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:text="Call" />
import android.net.Uri;
import android.os.Bundle; MainActivity.java
import android.app.Activity;
import android.content.Intent;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity {

EditText edittext1;
Button button1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

//Getting the edittext and button instance

edittext1=(EditText)findViewById(R.id.editText1);
button1=(Button)findViewById(R.id.button1);

//Performing action on button click

@Override
public void onClick(View arg0) {
String number=edittext1.getText().toString();
Intent callIntent = new Intent(Intent.ACTION_CALL);
callIntent.setData(Uri.parse("tel:"+number));
startActivity(callIntent);
}

});
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}

}
 Android Manifest file
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:androclass="http://schemas.android.com/apk/res/android"
package="com.example.phonecall"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="16" />

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

<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.example.phonecall.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
 Location Based Services

• Location Based Services are provided by

Android through its location framework. The
framework provides a location API which
consists of certain classes and interface. These
classes and interface are the key components
which allow us to develop Location Based
Application in Android.
 Classes and Interfaces of Location Based
Services:
• LocationManager – This class helps to get
access to the location service of the system.
• LocationListener – This interface acts as the
listener which receives notification from the
location manager when the location changes
or the location provider is disabled or enabled.
• Location – This is the class which represents
the geographic location returned at a
particular time.
 Location class
• A data class representing a geographic location.
• A location can consist of a latitude, longitude,
timestamp, and other information such as
bearing, altitude and velocity.
• All locations generated by the LocationManager
are guaranteed to have a valid latitude,
longitude, and timestamp (both UTC time and
elapsed real-time since boot), all other
parameters are optional.
 methods
static void distanceBetween(double startLatitude, double startLongitude, double
endLatitude, double endLongitude, float[] results)Computes the
approximate distance in meters between two locations, and optionally
the initial and final bearings of the shortest path between them.
float distanceTo(Location dest)Returns the approximate distance in meters
between this location and the given location.
void dump(Printer pw, String prefix)
float getAccuracy()Get the estimated horizontal accuracy of this location,
radial, in meters.
double getAltitude()Get the altitude if available, in meters above the WGS 84
reference ellipsoid.
double getLatitude()Get the latitude, in degrees.
double getLongitude()Get the longitude, in degrees.
float getSpeed()Get the speed if it is available, in meters/second over ground.
 To get API Key
• Visit the Google Cloud Platform Console.
• Click the project drop-down and select or create the project for
which you want to add an API key.
• Click the menu button and select APIs & Services > Credentials.
• On the Credentials page, click Create credentials > API key.
The API key created dialog displays your newly created API key.
• Click Close.
The new API key is listed on the Credentials page under API keys.
(Remember to restrict the API key before using it in production.)
 Add the API key to your app
Follow the steps below to include the API key in your application's
manifest, contained in the file AndroidManifest.xml.

1.In AndroidManifest.xml, add the following element as a child of

the <application> element, by inserting it just before the closing
</application> tag:
<meta-data
android:name="com.google.android.geo.API_KEY"
android:value="YOUR_API_KEY"/>

2. In the value attribute, replace YOUR_API_KEY with your API key

(the encrypted string). This element sets the
key com.google.android.geo.API_KEY to the value of your API key.

Save AndroidManifest.xml and re-build your application.

 Google Map Types

• A MapType is an interface that defines the

display and usage of map tiles and the
translation of coordinate systems from screen
coordinates to world coordinates (on the
map). Each MapType must contain a few
methods to handle retrieval and release of
tiles, and properties that define its visual
behavior.
 Basic Google Map Types
There are four types of maps available within the Maps
JavaScript API. In addition to the familiar "painted" road map
tiles, the Maps JavaScript API also supports other maps
types.
The following map types are available in the Maps JavaScript
API:
• roadmap
– displays the default road map view. This is the default map type.
• satellite
– displays Google Earth satellite images.
• hybrid
– displays a mixture of normal and satellite views.
• Terrain
– displays a physical map based on terrain information.
 Syntax of different types of map

• googleMap.setMapType(GoogleMap.MAP_TY
PE_NORMAL);
• googleMap.setMapType(GoogleMap.MAP_TY
PE_HYBRID);
• googleMap.setMapType(GoogleMap.MAP_TY
PE_SATELLITE);
• googleMap.setMapType(GoogleMap.MAP_TY
PE_TERRAIN);
 Methods of Google map
Methods Description
addCircle(CircleOptions options) This method add circle to map.
addPolygon(PolygonOptions options) This method add polygon to map.
addTileOverlay(TileOverlayOptions This method add tile overlay to the map.
options)
animateCamera(CameraUpdate This method moves the map according to the
update) update with an animation.
clear() This method removes everything from the
map.
getMyLocation() This method returns the currently displayed
user location.
moveCamera(CameraUpdate update) This method reposition the camera according
to the instructions defined in the update.
setTrafficEnabled(boolean enabled) This method set the traffic layer on or off.
snapshot(GoogleMap.SnapshotReadyC This method takes a snapshot of the map.
allback callback)
stopAnimation() This method stops the camera animation if
there is any progress.
Example of Google Map
Copy the URL from google_map_api.xml file
to generate Google map key.
Paste the copied URL at the browser. It will
open the following page.
Click on Create API key to generate API key.
After clicking on Create API key, it will generate
our API key displaying the following screen.
Copy this generated API key in
our google_map_api.xml file
 activity_maps.xml

<fragment xmlns:android="http://schemas.android.com/apk/
res/android"
xmlns:map="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/map"
android:name="com.google.android.gms.maps.SupportMap
Fragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="example.com.mapexample.MapsActivity" />
 MapsActivity.java
import android.support.v4.app.FragmentActivity;
import android.os.Bundle;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;

public class MapsActivity extends FragmentActivity implements OnMapReadyCallback{

private GoogleMap mMap;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_maps);
// Obtain the SupportMapFragment and get notified when the map is ready to be used.
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()

.findFragmentById(R.id.map);
@Override
public void onMapReady(GoogleMap googleMap) {
mMap = googleMap;

// Add a marker in Sydney and move the camera

LatLng sydney = new LatLng(-34, 151);
mMap.addMarker(new MarkerOptions().position(sydney).title("Ma
rker in Sydney"));
mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));

}
}
 AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="example.com.mapexample">
<!--
The ACCESS_COARSE/FINE_LOCATION permissions are not required to use
Google Maps Android API v2, but you must specify either coarse or fine
location permissions for the 'MyLocation' functionality.
-->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<meta-data
android:name="com.google.android.geo.API_KEY"
android:value="@string/google_maps_key" />

<activity
android:name=".MapsActivity"
android:label="@string/title_activity_maps">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
</application>

</manifest>
 build.gradel

dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'com.android.support:appcompat-v7:26.1.0'
implementation 'com.google.android.gms:play-services-
maps:11.8.0'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'com.android.support.test:runner
:1.0.1'
androidTestImplementation 'com.android.support.test.espres
so:espresso-core:3.0.1'
}
Android Google Map Displaying Current Location
• Callback methods in Google Map
• OnMapRreadyCallback: This callback interface invokes when it instance
is set on MapFragment object. The onMapReady(GoogleMap) method of
OnMapReadyCallback interface is called when the map is ready to used.
In the onMapReady(GoogleMap) method we can add markers, listeners
and other attributes.
• LocationListener: This interface is used to receive notification when the
device location has changed. The abstract method of LocationListener
onLocationChanged(Location) is called when the location has changed.
• GoogleApiClient.ConnectionCallbacks: This interface provide callbacks
methods onConnected(Bundle) and onConnectionSuspended(int) which
are called when the device is to connected and disconnected.
• GoogleApiClient.OnConnectionFailedListener: This interface provide
callbacks method onConnectionFailed(ConnectionResult) which is called
when there was an error in connecting the device to the service.
• The setMyLocationEnabled() method of GoogleMap is used to enable
 activity_maps.xml

<fragment xmlns:android="http://schemas.android.com/apk/
res/android"
xmlns:map="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/map"
android:name="com.google.android.gms.maps.SupportMap
Fragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="example.com.mapexample.MapsActivity" />
 build.gradel

dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'com.android.support:appcompat-v7:26.1.0'
implementation 'com.google.android.gms:play-services-maps:11.8.0'
compile 'com.google.android.gms:play-services-location:11.8.0'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'com.android.support.test:runner:1.0.1'
androidTestImplementation 'com.android.support.test.espresso:espre
sso-core:3.0.1'

}
 MapsActivity.java

import android.os.Build;
import android.support.v4.app.FragmentActivity;
import android.os.Bundle;

import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.Marker;
import com.google.android.gms.maps.model.MarkerOptions;
import com.google.android.gms.location.LocationServices;

import android.location.Location;
import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.content.ContextCompat;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
public class MapsActivity extends FragmentActivity implements OnMapReadyCallb
ack,
LocationListener,GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener{

private GoogleMap mMap;

Location mLastLocation;
Marker mCurrLocationMarker;
GoogleApiClient mGoogleApiClient;
LocationRequest mLocationRequest;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_maps);
// Obtain the SupportMapFragment and get notified when the map is ready to
be used.
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFrag
mentManager()
.findFragmentById(R.id.map);
@Override
public void onMapReady(GoogleMap googleMap) {
mMap = googleMap;

if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION)
== PackageManager.PERMISSION_GRANTED) {
buildGoogleApiClient();
mMap.setMyLocationEnabled(true);
}
}
else {
buildGoogleApiClient();
mMap.setMyLocationEnabled(true);
}

}
protected synchronized void buildGoogleApiClient() {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API).build();
mGoogleApiClient.connect();
}
@Override
public void onConnected(Bundle bundle) {

mLocationRequest = new LocationRequest();

mLocationRequest.setInterval(1000);
mLocationRequest.setFastestInterval(1000);
mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION)
== PackageManager.PERMISSION_GRANTED) {
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
}

@Override
public void onConnectionSuspended(int i) {

@Override
public void onLocationChanged(Location location) {

mLastLocation = location;
if (mCurrLocationMarker != null) {
mCurrLocationMarker.remove();
}
//Place current location marker
LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude());
MarkerOptions markerOptions = new MarkerOptions();
markerOptions.position(latLng);
markerOptions.title("Current Position");
markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN));
mCurrLocationMarker = mMap.addMarker(markerOptions);

//move map camera

mMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
mMap.animateCamera(CameraUpdateFactory.zoomTo(11));
//stop location updates
if (mGoogleApiClient != null) {
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
}

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {

}
<?xml version="1.0" encoding="utf-8"?>
AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="example.com.mapexample">
<!--
The ACCESS_COARSE/FINE_LOCATION permissions are not required to use
Google Maps Android API v2, but you must specify either coarse or fine
location permissions for the 'MyLocation' functionality.
-->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<!--
The API key for Google Maps-based APIs is defined as a string resource.
(See the file "res/values/google_maps_api.xml").
Note that the API key is linked to the encryption key used to sign the APK.
You need a different API key for each encryption key, including the release key that is used to
sign the APK for publishing.
You can define the keys for the debug and release targets in src/debug/ and src/release/.
-->
<meta-data
android:name="com.google.android.geo.API_KEY"
android:value="@string/google_maps_key" />

<activity
android:name=".MapsActivity"
android:label="@string/title_activity_maps">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

 Zoom Controls
• The Zoom Controls class displays a simple set of
controls used for zooming and provides callbacks to
register for events.
• Xml code
<ZoomControls android:id="@+id/zoomControls1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_centerHorizontal="true"
android:layout_marginBottom="40dp" />
public class MainActivity extends Activity
{
ZoomControls zoom;
Button hide,show;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
zoom = (ZoomControls) findViewById(R.id.zoomControls1);
hide = (Button) findViewById(R.id.button1);
show = (Button) findViewById(R.id.button2);
show.setOnZoomInClickListener(new OnClickListener() { @Override public void onClick(View v) {
zoom.show();
}};

hide.setOnZoomInClickListener(new OnClickListener() { @Override public void onClick(View v) {

zoom.hide();
}};
Show marker on location
 Step 1
• An instance of the LocationManager needs to be
created as the first step in this process. This is the
main class through which the application gets
access to the location services in Android. A
reference to this system service can be obtained
by calling getSystemService() method.

LocationManager locationManager =
(LocationManager)getSystemService(Context.LOCA
TION_SERVICE);
 Step 2
• identify the location provider you would like to use for retrieving location details.
The location providers actually provide the location data in Android. Android exposes
two main location providers:

1. GPS Location Provider:

This location provider provides location data with the highest accuracy (~2 m – 20m).
Location updates are provided through satellites. However there are some drawbacks
with this provider which are explained as below:

– A. It is significantly slower than the network provider to get the initial connection setup with
the satellites. This initial connection, also called Time to First Fix (TTFF) can be extremely
slow but once the connection is established, location updates are quite fast
– B. GPS provider also drains out the battery very first. So, it is very important to judiciously
use this provider. Special care should be taken to ensure that this is turned off when you are
not using it.
– C. The third draw back comes from the fact that GPS uses radio signal which is obstructed by
solid objects. So, GPS provider will not work if you are inside a building or in a basement.

2. Network Provider:
This provider uses Wi-Fi hotspots and cell tower to approximate a location. The
provider retrieves an approximate location by querying the Google location server
using the IDs of the Wi-Fi hotspots and cell towers. Location accuracy is between 100
– 1000 m. The location accuracy is directly proportional to the number of Wi-Fi
You can check the availability of the providers
using the below piece of code:

isGpsEnabled = mLocManager.isProviderEnab
led(LocationManager.GPS_PROVIDER);
isNetworkEnabled =
mLocManager.isProviderEnabled(LocationMa
nager.NETWORK_PROVIDER);
 Step 3
To register a location listener with the location manager.
The registration can be done by calling the
method requestLocationUpdates((String provider, long minTime, float
minDistance, LocationListener listener).
Following are the parameters passed to this method:
– provider:
the name of the provider with which to register. This can be either GPS or Network
provider.
– minTime:
minimum time interval between location updates, in milliseconds.
– minDistance:
minimum distance between location updates, in meters.
– listener:
a LocationListener whose onLocationChanged(Location) method will be called for each
location update.

• The Location Manager calls the onLocationChanged() of the listener when the
mobile has moved a distance greater than the minDistance or the time since last
location update is more than minTime.
 Permissions required for Location Based
Services in Android
• <uses-
permissionandroid:name=”android.permission.ACCESS_COARSE_LOCATI
ON”/>
<uses-
permissionandroid:name=”android.permission.ACCESS_FINE_LOCATION”
/>
<uses-permissionandroid:name=”android.permission.INTERNET”/>

For GPS based location, you need only the

“android.permission.ACCESS_FINE_LOCATION”

For Network based location, you need only the

“android.permission.ACCESS_FINE_LOCATION”
If you are using both the providers, you need to request only for
the ACCESS_FINE_LOCATION permission, it includes permission for both
the providers.
 Geocode and reverse geocoding
• Android Geocoder class is used for Geocoding
as well as Reverse Geocoding. Geocoding
refers to transforming street address or any
address into latitude and longitude. Reverse
Geocoding refers to transforming latitude and
longitude into its corresponding street address.
• Address class helps in fetching the street
address, locality, sub-locality, city, country,
landmark etc. features of the location.
• We’ve set the attributes setEllipize() and set setMarqueeRepeatLimit() on the
TextView programmatically since setting the same attributes in xml doesn’t scroll the
text on all devices anymore. The above methods make the content of TextView scroll
horizontally IF the content length is greater than the TextView width.
• Passing -1 in setMarqueeRepeatLimit() makes it scroll forever.
• The Google Map is displayed using the SupportMapFragment. getMapAsync() callback
is assigned to the fragment. This callback gets triggered when the Google Play Services
exists.
• The onMapReady() method is the one that displays the Google Map and returns a
non-null instance of the GoogleMap class. We assign it to our instance variable map.
map.getUiSettings().setZoomControlsEnabled(true) is used to set the zoom controls
on the screen.
• map.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng, 16)) moves the map
to the location specified in the latLng(Some location in India!). The camera zooms to
the location in the center of the screen where the marker is placed.
• setOnCameraIdleListener would listen for the movements/dragging on the map.
When the movement ends the method onCameraIdle() gets triggered. This is where
we retrieve the latitude and longitude of the center of map(because that is where the
marker resides) and pass it into the method getAddressFromLocation() which will
eventually do the reverse geocoding.
• The method getFromLocation(double latitude, double longitude, int
maxResults) returns a List of Addresses for the current location.
• Within the Address object, the method getAddressLine(int index) returns a line of the
address numbered by the given index or null if no address exists.
• getMaxAddressLineIndex() returns the largest index currently in use to specify an address line.
• There are several other important details of an address that can retrieved too. Some of them
are listed below:
– getThoroughfare() : This is the street, which contains the delivery point. If it doesn’t exist null would
be returned.
– getSubThoroughfare() : When a thoroughfare name exists more than once within a town,
subThoroughfare name is used for additional information.
– getLocality() and getSublocality() : Returns the locality of the address, for example “Mountain View”
and sub locality respectively if available or null.
– getFeatureName() : Returns the nearest landmark name if available or null.
– getCountryName() getCountryCode() : Returns the country name and country code respectively.
• Clicking the CardView would launch the PlaceAutoComplete service from the Google Places
API.
• We use the PlaceAutocomplete.IntentBuilder to create Intent and pass the Mode as full
screen.
• The selected place is returned in the onActivityResult() which is eventually displayed in the
TextView. The latitude and longitude of the Place are returned as place.getLatLng() which is
eventually zoomed into the center of the screen.
 Location data
• The location data available to an Android device includes the
current location of the device — pinpointed using a combination
of technologies — the direction and method of movement, and
whether the device has moved across a predefined geographical
boundary, or geofence. Depending upon the needs of your
application, you can choose between several ways of working with
location data:
• The My Location layer provides a simple way to display a device's
location on the map. It does not provide data.
• The Google Play services Location API is recommended for all
programmatic requests for location data.
• The LocationSource interface allows you to provide a custom
location provider.
 LocationSource

• public interface LocationSource

• Defines an interface for providing location data, typically to a GoogleMap
object.
• A GoogleMap object has a built-in location provider for its my-location
layer, but it can be replaced with another one that implements this
interface.
• A GoogleMap object activates its location provider
using activate(OnLocationChangedListener). While active
(between activate(OnLocationChangedListener) and deactivate()), a
location provider should push periodic location updates to the listener
registered in activate(OnLocationChangedListener). It is the provider's
responsibility to use location services wisely according to the map's
lifecycle state. For example, it should only using battery-intensive services
(like GPS) occasionally, or only while an activity is in the foreground.
• Nested Class Summary
interface LocationSource.OnLocationCh Handles a
angedListener location
update.

• Public Method Summary

abstract void activate(LocationSource.OnLo
cationChangedListener listene
r)Activates this provider.
abstract void deactivate()Deactivates this
provider.

• Public Methods
– public abstract void activate (
LocationSource.OnLocationChangedListener listener)
listener that's called when a new location is available
Throws IllegalStateException,IllegalArgumentException
• public abstract void deactivate ()
– Deactivates this provider. The previously-
registered callback is not notified of any further
updates. Throws IllegalStateException
 Android security model

Android is a multi-process system, in which 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.
The Android security model is primarily based
on a sandbox and permission mechanism.
Each application is running in a specific Dalvik
virtual machine with a unique user ID assigned
to it, which means the application code runs in
isolation from the code of all others
applications. As a consequence, one
application has not granted access to other
applications’ files.
 Permissions are divided into several
protection levels
• The protection level affects whether runtime permission requests are
required. There are three protection levels that affect third-party apps:
normal,
Signature
dangerous permissions.

• Normal permissions cover areas where your app needs to access data or
resources outside the app’s sandbox, but where there’s very little risk to
the user’s privacy or the operation of other apps. For example,
permission to set the time zone is a normal permission. If an app declares
in its manifest that it needs a normal permission, the system
automatically grants the app that permission at install time. The system
doesn’t prompt the user to grant normal permissions, and users cannot
revoke these permissions.
• Signature permissions: The system grants
these app permissions at install time, but only
when the app that attempts to use a
permission is signed by the same certificate as
the app that defines the permission.
• Dangerous permissions cover areas where the app wants data
or resources that involve the user’s private information, or
could potentially affect the user’s stored data or the operation
of other apps. For example, the ability to read the user’s
contacts is a dangerous permission. If an app declares that it
needs a dangerous permission, the user has to explicitly grant
the permission to the app. Until the user approves the
permission, your app cannot provide functionality that
depends on that permission. To use a dangerous permission,
your app must prompt the user to grant permission at
runtime. For more details about how the user is prompted,
see Request prompt for dangerous permission.
 Android threat
• However, the Android operating system also revealed some of its faults for the user may be
attacked and stolen personal information.
Some security vulnerabilities on Android:

– Leaking Information to Logs: Android provides centralized logging via the Log API, which can
displayed with the “logcat” command. While logcat is a debugging tool, applications with the
READ_LOGS permission can read these log messages. The Android documentation for this
permission indicates that “the logs can contain slightly private information about what is
happening on the device, but should never contain the user’s private information.”

– SDcard Use: Any application that has access to read or write data on the SDcard can read or
write any other application’s data on the SDcard.

– Unprotected Broadcast Receivers: Applications use broadcast receiver components to

receive intent messages. Broadcast receivers define “intent filters” to subscribe to specific
event types are public. If the receiver is not protected by a permission, a malicious application
can forge messages.

– Intent Injection Attacks: Intent messages are also used to start activity and service
components. An intent injection attack occurs if the in-tent address is derived from untrusted
input.

– Wifi Sniffing: This may disrupt the data being transmitted from A device like many web sites
and applications does not have security measures strict security. The application does not
 Requesting permissions

• To request a permission an app must include a <uses-

permission> tag in its AndroidManifest.xml file.
• <manifest …> <uses-permission
android:name="com.example.myamazingapp.SOME_PERMISSION">
… </manifest>
• This example requests the permission SOME_PERMISSION in order
to access some capability provided by myamazingapp.
• Android has many built-in permissions that an app can request. For
example, an app can request access to the internet as follows:
• <manifest …> <uses-permission
android:name="android.permission.INTERNET"> … </manifest>
• If the requested permission is a dangerous permission the user will
have to agree to grant the app that permission.
 Enforcing permissions

• To use a permission to control access to a component an app can add

an android:permission attribute to the component’s declaration in the
app’s AndroidManifest.xml file.
• <manifest …> <application …> <activity
android:name="com.example.myamazingapp.SomeActivity"
android:permission="com.example.myamazingapp.SOME_PERMISSION">
</activity> </application> </manifest>
• In the above example, for an app to start SomeActivity (a component
of myamazingapp) it must have requested, and been granted, the
permission SOME_PERMISSION.
• The android:permission attribute can also be set for
the <application> element in the app’s AndroidManifest.xml file. This
becomes the overall default permission for all the app’s components that
do not have their own attribute:permission set.
Permissions and the Principle of Least Privilege

• The tag <uses-permission> is used to request a

permission, and the
attribute android:permission is used to enforce a
permission.
• If a component enforces a particular permission,
then your app must request that permission if it
wants to access that component.
• Following the Principle of Least Privilege, only
request those permissions that your app really
needs to perform its function.
 Generate Signed Apk for Android App
• Step 1: Go to build and click on Generate
Signed Apk…
Step 2: Android Studio will now open a
dialog box. Click on Next.
Step 3: Now you will need to create Keystore path. Click on Create new…
 Step 4: Now locate key store path in your system where you
want to save jks file of your project. Click on … to locate the path.
Step 5: After locating the path from your system. Give any name to the jks file that will
be created and click ok.
Step 6: Fill the other details and click ok. For
example you can refer to the image below:
Step 7: Click next.
Step 8: Now edit the destination folder of signed apk file, choose
build type and select signature versions. Finally click Finish:

Important Note: Regarding signature versions, you can

consider V2 because it offers faster app install times and more
protection against unauthorized alterations to APK files. If you
face any problem then you can consider the traditional V1
signing scheme, which uses JAR signing.
 Step 9: Now you can use this signed apk for publishing
app on Playstore via your developer console.

• Important Note 1: After you generate signed apk, it

is very important to keep jks file safe and secure. If
you lost it then you won’t be able to send future
updates to your App.
• Important Note 2: Make sure to keep Keystore and
key password saved somewhere with you. If you lost
or forget it then also you won’t be able to send new
updates for your App.
 How To Publish Android App On PlayStore

• Step 1: First generate signed apk of your

Android App to publish it on Play Store.
• Step 2: Now you will need to sign up for
Google Play Console to publish and manage
your Android App.
• Important Note: You can signup with this link
https://play.google.com/apps/publish/
• Step 3: Login with your Gmail account that
you want to use for publishing App on Play
Store.
• Step 4: Now there are 4 steps to complete the
registration for Google play store console. You
have already completed two.
• Step 5: After reading the Google play store
developer distribution agreement agree to
their terms by clicking on check box
• Step 6: Now you will need to pay one time
‘Developer Registration Fee’ of $25 to Google.
Please fill your credit card details to make the
payment.
• Important Note: You can upload unlimited number of Android
App on Play store from single account with a limit of
uploading 15 apk/day.
• Step 7: Complete your account details for
Google developer account. For example see the
below image:

• Step 8: Now click on Create Application

Step 9: Enter the name of your App.
Step 10: Now fill store listing details of your App which include Title, Short description,
and Full description.
 Step 11: After this you need to put some App screenshots here.
The minimum required are 2 screenshots and maximum limit is 8.
• Step 12: After screenshot now you need to
put a high Resolution icon or logo with a size
of 512 * 512 pixel. This will be displayed on
Play Store.
• After that another mandatory thing is you
need to put a feature graphic of 1024 * 500
pixel dimension. See below image for more
detail.
• Step 13: Now scroll down and fill other details which include
application type, category, website, email and phone no.
• After this check privacy policy because now we are not
submitting and then click on save draft. If your App require
user permission then it is mandatory to put privacy url.
• Click on Save Draft to save your work so far.
Step 14: After saving data on draft now go to app release and click on manage production.

Step 15: Now you will see create release now click on it.
• Step 16: After click on create release you will
see browse files click on it and upload your
signed APK.

• Step 17: Once the upload is successful then

scroll down and click on review to check.
Step 18: Now go to Content Rating and click
on continue.
Step 19: Fill details which include email
address and select your categories
• Step 20: Now select Violence, Sexuality,
Language, Controlled Substance and
Miscellaneous based on your App. First click
on save questionnaire for save and then click
on calculate rating.
Step 21: Now click on apply rating.
• Step 22: Click on pricing and distribution and
select free/paid based on how you want user
to access your App.
• Step 23: Now scroll down and see mandatory
things with * you need to select After this click
on save draft .

• Step 24: Now Click on ready on publish along

with save draft and click on Manage release.
• Step 25: Click on Manage Production.
• Step 26: After Manage production click on edit
release.

• Step 27: Now click on review.

• Step 28: After review click on Start Rollout to
production. Now you need to confirm. After
confirm you will need to wait for one or six
hour for approval.
 Publish your app

• Publishing is the general process that makes your

Android applications available to users. When you
publish an Android application you perform two
main tasks:
– You prepare the application for release.During the
preparation step you build a release version of your
application, which users can download and install on
their Android-powered devices.
– You release the application to users.During the release
step you publicize, sell, and distribute the release
version of your application to users.
 Preparing your app for release

• Preparing your application for release is a multi-

step process that involves the following tasks:
– Configuring your application for release
– Building and signing a release version of your
application
– Testing the release version of your application
– Updating application resources for release.
– Preparing remote servers and services that your
application depends on.
 Releasing your app to users

• You can release your Android applications several

ways. Usually, you release applications through an
application marketplace such as Google Play, but
you can also release applications on your own
website or by sending an application directly to a
user.
– Releasing through an app marketplace
– Releasing your apps on Google Play
• Preparing promotional materials
• Configuring options and uploading assets
• Publishing the release version of your application.
 Google Play Developer Console
• The Google Play Developer Console is your home
for publishing operations and tools.
• Upload apps, build your product pages, configure
prices and distribution, and publish. You can
manage all phases of publishing on Google Play
through the Developer Console, from any web
browser.
• Once you've registered and received verification by
email, you can sign in to your Google Play
Developer Console.
• All Applications
– Start in All Applications, which gives you a quick
overview of your apps, lets you jump to stats,
reviews, and product details, or upload a new app.
• Your Account Details
– Specify basic developer profile information about
yourself or your company on the accounts detail
page. This identifies you to Google Play and your
customers. You can go back at any time to edit the
information and change your settings.
• Your developer profile contains:
– Developer name — displayed on your store listing
page and elsewhere on Google Play.
– Contact information — used by Google only, it isn't
seen by your customers.
– Web site URL — displayed on your store listing page.
– On the account details page you can also add
restricted access for marketers and other teams,
register for a merchant account, or set up test
accounts for Google Play licensing.
• Linking Your Merchant Account
– If you want to sell apps or in-app products, link
your Google Wallet Merchant Account to your
developer profile. Google Play uses the linked
merchant account for financial and tax
identification, as well as for monthly payouts from
sales.
• Multiple User Accounts
– Set up user accounts for other team members to
access different parts of your Developer Console.
• Store Listing Details
– Use the Developer Console to set up a Store Listing
page. This is the home for your app in Google Play.
It's the page users see on their mobile phones or on
the web to learn about your app and download it.
– Upload custom brand assets, screenshots, and
videos to highlight what's great about your app.
Provide a localized description, add notes about the
latest version, and more. You can update your store
listing at any time.
• Upload and Instantly Publish
– From the Developer Console you can quickly upload and
publish a release-ready Android application package file. The
app is a draft until you publish it, at which time Google Play
makes your store listing page and app available to users—your
app appears in the store listings within hours, not weeks.
– Once your app is published, you can update it as often as you
want: Change prices, configuration, and distribution options at
any time, without needing to update your app binary.
– As you add features or address code issues, you can publish an
updated binary at any time. The new version is available almost
immediately and existing customers are notified that an update
is ready for download. Users can also accept automatic updates
to your app, so that your updates are delivered and installed as
soon as you publish them. You can unpublish your apps app at
any time.
• Alpha and Beta Testing
– It's always valuable to get real-world feedback from users, especially
before launch. Google Play makes it easy to distribute pre-release
versions of your app to alpha and beta test groups anywhere in the
world.
– In the APK section of your Google Play Developer Console you’ll find
the Alpha Testing and Beta Testing tabs. Here you can upload
versions of your apps’ APK files
• Staged Rollouts
– You can also stage the rollout of your apps using the Production tab in
the APK section of your Google Play Developer Console. Here you can
define the percentage of user who’ll be able to download your app.
• Multiple APK Support
– In most cases, a single app package (APK) is all you need,
and it’s usually the easiest way to manage and maintain the
app. However, if you need to deliver a different APK to
different devices, Google Play provides a way to do that.
– Multiple APK support lets you create multiple app packages
that use the same package name but differ in their OpenGL
texture compression formats, screen-size support, or
Android platform versions supported. You can simply
upload all the APKs under a single product listing and
Google Play selects the best ones to deliver to users, based
on the characteristics of their devices.
• Selling and Pricing Your Products
– You have tools to set prices for your apps and in-app
products. Your app can be free to download or priced,
requiring payment before download.
– If you publish your app as free, it must remain free for
the life of the app. Free apps can be downloaded by all
users in Google Play.
– If you publish it as priced, you can later change it to
free. Priced apps can be purchased and downloaded
only by users who have registered a form of payment
in Google Play.
• In-app Products
– You can sell in-app products and subscriptions
using Google Play In-app Billing as a way to monetize your
apps. In-app products are one-time purchases, while
subscriptions are recurring charges on a monthly or annual
basis.
– In the In-app Products section for a specific published or
draft APK you:
• Create product lists for in-app products and subscriptions.
• Set prices.
• Publish the products with the app or withdraw obsolete
products.
• Distribution Controls
– Manage which countries and territories your apps will
distribute to. For some countries, you can choose which
carriers you want to target. You can also see the list of devices
your app is available for, based on any distribution rules
declared in its manifest file.
• Geographic targeting
– You can use controls in the Google Play Developer Console to
easily manage the geographic distribution of your apps,
without any changes in your application binary. You can
specify which countries and territories you want to distribute
to, and even which carriers (for some countries).
• Capabilities targeting
– Google Play also lets you control distribution according to device
features or capabilities that your app depends on. There are several
types of dependencies that the app can define in its manifest, such as
hardware features, OpenGL texture compression formats, libraries,
Android platform versions, and others.
• User Reviews and Crash Reports
– The User reviews section gives you access to user reviews for a specific
app. You can filter reviews in a number of ways to locate issues more
easily and support your customers more effectively.
– Google Play makes it easy for users to submit reviews of your app for
the benefit of other users. The reviews give you usability feedback,
support requests, and details of important functionality issues direct
from your customers.
• App Statistics
– You get detailed statistics on the install performance of
your app.
– See installation metrics measured by unique users as
well as by unique devices. View active installs, total
installs, upgrades, daily installs and uninstalls, and
metrics about ratings.
– Zoom into the installation numbers by metric, including
Android platform version, device, country, language,
app version, and carrier. View the installation data for
each dimension on timeline charts.