Explore

Android Location Services and Maps Integration

Location Services

· Get current location of device using FusedLocationProvider

· Track device’s location as it moves using FusedLocationProvider

Maps Integration

· Add a map to display a location

· Display user location on the map (blinking blue icon)

Add markers to the map // Annotations

How we simulate location and moving around when using an Android Virtual Device

Simulating location and movement in an Android Virtual Device (AVD) is an essential skill for testing location-based applications like our geofencing demo.

NMEA stands for National Marine Electronics Association. It's a standard format for GPS data that is widely used in marine navigation and other applications. NMEA messages contain information about location, speed, time, and other data related to GPS positioning.

In the context of Android emulators, you can use NMEA data to simulate the GPS location of the device. This is done by sending NMEA sentences to the emulator through tools like the Android Debug Bridge (ADB). The emulator interprets this data as if it were coming from a real GPS receiver, allowing you to test your location-based applications without the need for a physical device or actual GPS signals.

Here's a step-by-step guide on how to simulate location and movement in an Android emulator:

Using the Extended Controls in Android Studio:

a. Start your Android Virtual Device (AVD) in Android Studio.

b. Once the emulator is running, click on the "More" (...) button in the emulator's sidebar.

c. In the Extended Controls window, select the "Location" option from the left sidebar.

Setting a Single Location:

a. In the Location extended control, you'll see a map.

b. You can set a location by:

Clicking anywhere on the map

Entering coordinates in the "Latitude" and "Longitude" fields

Searching for a location using the search bar at the top

c. Once you've selected a location, click "Set Location" to update the emulator's location.

Simulating Movement:

a. In the same Location extended control, you'll see a "Routes" tab next to the "Single points" tab.

b. Click on the "Routes" tab.

c. You can create a route by:

Clicking multiple points on the map to create waypoints

Importing a GPX or KML file with a predefined route

d. Once you've created a route, you can:

Click "Play Route" to start the simulated movement

Adjust the playback speed using the speed multiplier dropdown

Pause, resume, or reset the route playback

Using GPS data in NMEA format:

a. If you have GPS data in NMEA format, you can use the Android Debug Bridge (adb) to send it to the emulator.

b. Open a terminal and use a command like this:

adb emu geo fix <longitude> <latitude>

Replace <longitude> and <latitude> with the desired coordinates.

Using the Geolocation API in Chrome DevTools: If your app uses a WebView or you're testing a web application: a. In the emulator, open Chrome and navigate to your web app. b. In Android Studio, go to Tools > Chrome DevTools. c. In the DevTools window, click on the three-dot menu and select More tools > Sensors. d. In the Sensors tab, you can set geolocation coordinates or choose from preset locations.

Showcasing this in your lab:

Set up the geofence:

In your GeofencingDemo app, set up a geofence for a specific location (e.g., 40.7128, -74.0060 for New York City).

Demonstrate entering the geofence:

Use the emulator's Location control to set the device location outside the geofence.

Then, either set a new location inside the geofence or create a route that enters the geofence.

Show students how the GeofenceBroadcastReceiver logs the "Entered the geofence" message.

Demonstrate exiting the geofence:

Start with the emulator's location inside the geofence.

Create a route or set a new location that moves outside the geofence.

Show how the "Exited the geofence" message is logged.

Simulate real-world scenarios:

Create more complex routes that enter and exit the geofence multiple times.

Adjust the speed of the simulated movement to show how it affects geofence triggering.

Test edge cases:

Simulate movement that just barely enters or exits the geofence.

Test what happens when you set the location exactly on the geofence boundary.

By showcasing these simulation techniques, you can help students understand:

How to effectively test location-based features without physically moving.

The importance of testing various scenarios and edge cases in geofencing applications.

How the Android system handles location updates and geofence transitions.

The relationship between location accuracy, update frequency, and geofence responsiveness.

While emulator testing is crucial, it's also important to test on real devices when possible, as they may behave slightly differently due to real-world factors like GPS accuracy and network conditions.

Lab 1: Introduction: A simple Android Kotlin app that demonstrates the use of FusedLocationProvider to get the current location of the device.

⁠

This will serve as a good starting point for Location Services.

Here's the complete code and instructions for each file:

MainActivity.kt

package com.example.locationdemo

import android.Manifest

import android.content.pm.PackageManager

import android.location.Location

import android.os.Bundle

import android.widget.Toast

import androidx.appcompat.app.AppCompatActivity

import androidx.core.app.ActivityCompat

import androidx.core.content.ContextCompat

import com.example.locationdemo.databinding.ActivityMainBinding

import com.google.android.gms.location.FusedLocationProviderClient

import com.google.android.gms.location.LocationServices

class MainActivity : AppCompatActivity() {

private lateinit var binding: ActivityMainBinding

private lateinit var fusedLocationClient: FusedLocationProviderClient

private val LOCATION_PERMISSION_REQUEST_CODE = 1

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

binding = ActivityMainBinding.inflate(layoutInflater)

setContentView(binding.root)

fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)

binding.btnGetLocation.setOnClickListener {

getLastKnownLocation()

}

private fun getLastKnownLocation() {

if (ContextCompat.checkSelfPermission(

this,

Manifest.permission.ACCESS_FINE_LOCATION

) != PackageManager.PERMISSION_GRANTED

) {

ActivityCompat.requestPermissions(

this,

arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),

LOCATION_PERMISSION_REQUEST_CODE

)

} else {

fusedLocationClient.lastLocation

.addOnSuccessListener { location: Location? ->

if (location != null) {

val latitude = location.latitude

val longitude = location.longitude

binding.tvLocation.text = "Latitude: $latitude\nLongitude: $longitude"

} else {

binding.tvLocation.text = "Location not available"

}

.addOnFailureListener { e ->

binding.tvLocation.text = "Error getting location: ${e.message}"

}

override fun onRequestPermissionsResult(

requestCode: Int,

permissions: Array<String>,

grantResults: IntArray

) {

super.onRequestPermissionsResult(requestCode, permissions, grantResults)

when (requestCode) {

LOCATION_PERMISSION_REQUEST_CODE -> {

if ((grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED)) {

getLastKnownLocation()

} else {

Toast.makeText(this, "Permission denied", Toast.LENGTH_SHORT).show()

}

return

}

build.gradle.kts (Project level)

plugins {

id("com.android.application") version "8.1.0" apply false

id("org.jetbrains.kotlin.android") version "1.8.10" apply false

}

build.gradle.kts (Module level)

plugins {

id("com.android.application")

id("org.jetbrains.kotlin.android")

}

android {

namespace = "com.example.locationdemo"

compileSdk = 33

defaultConfig {

applicationId = "com.example.locationdemo"

minSdk = 24

targetSdk = 33

versionCode = 1

versionName = "1.0"

testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

}

buildTypes {

release {

isMinifyEnabled = false

proguardFiles(

getDefaultProguardFile("proguard-android-optimize.txt"),

"proguard-rules.pro"

)

}

compileOptions {

sourceCompatibility = JavaVersion.VERSION_1_8

targetCompatibility = JavaVersion.VERSION_1_8

}

kotlinOptions {

jvmTarget = "1.8"

}

buildFeatures {

viewBinding = true

}

dependencies {

implementation("androidx.core:core-ktx:1.10.1")

implementation("androidx.appcompat:appcompat:1.6.1")

implementation("com.google.android.material:material:1.9.0")

implementation("androidx.constraintlayout:constraintlayout:2.1.4")

implementation("com.google.android.gms:play-services-location:21.0.1")

testImplementation("junit:junit:4.13.2")

androidTestImplementation("androidx.test.ext:junit:1.1.5")

androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")

}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

tools:context=".MainActivity">

<Button

android:id="@+id/btnGetLocation"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Get Location"

app:layout_constraintBottom_toBottomOf="parent"

app:layout_constraintEnd_toEndOf="parent"

app:layout_constraintStart_toStartOf="parent"

app:layout_constraintTop_toTopOf="parent" />

<TextView

android:id="@+id/tvLocation"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_marginTop="16dp"

android:text="Location will appear here"

app:layout_constraintEnd_toEndOf="parent"

app:layout_constraintStart_toStartOf="parent"

app:layout_constraintTop_toBottomOf="@+id/btnGetLocation" />

</androidx.constraintlayout.widget.ConstraintLayout>

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools">

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

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

<application

android:allowBackup="true"

android:dataExtractionRules="@xml/data_extraction_rules"

android:fullBackupContent="@xml/backup_rules"

android:icon="@mipmap/ic_launcher"

android:label="@string/app_name"

android:roundIcon="@mipmap/ic_launcher_round"

android:supportsRtl="true"

android:theme="@style/Theme.LocationDemo"

tools:targetApi="31">

<activity

android:name=".MainActivity"

android:exported="true">

<intent-filter>

</intent-filter>

</activity>

</application>

</manifest>

Instructions to create and run the app:

Open Android Studio and create a new project named "LocationDemo" with the package name "com.example.locationdemo".

Replace the contents of MainActivity.kt, build.gradle.kts (Project level), build.gradle.kts (Module level), activity_main.xml, and AndroidManifest.xml with the provided code.

Sync the project with Gradle files.

Run the app on an emulator or physical device.

This simple app demonstrates the use of FusedLocationProvider by:

Requesting location permissions if not already granted.

Using FusedLocationProviderClient to get the last known location.

Displaying the latitude and longitude when the "Get Location" button is pressed.

The app uses viewBinding for safe and efficient view access, and it follows modern Android development practices. It serves as a good starting point for students to learn about Location Services in Android.

OODA (Observe, Orient, Decide, Act) analysis for this Android app code that demonstrates the use of FusedLocationProvider:

Observe:

The app observes the user's interaction with the UI, specifically when the user taps the "Get Location" button.

It observes the device's current location using the FusedLocationProviderClient.

The app observes the status of location permissions (granted or not granted).

Orient:

The app orients itself to the current state of location permissions when the user requests the location.

It orients to the availability of the last known location from the FusedLocationProviderClient.

The app adapts to different scenarios: location available, location not available, or error in getting location.

Decide:

The app decides whether to request location permissions or proceed with getting the location based on the current permission status.

It decides how to handle the location data:

display it if available, show a message if not available, or display an error message if there's a failure.

The app decides how to respond to the user's permission grant or denial.

Act:

The app acts by requesting location permissions if they're not granted.

It acts by calling the FusedLocationProviderClient to get the last known location.

The app acts by updating the UI to display the location information or appropriate messages.

It acts by showing a toast message if the user denies the location permission.

Key OODA Loop elements in the code:

Permission Check (Observe & Orient):

Want to print your doc?
This is not the way.

Try clicking the ··· in the right corner or using a keyboard shortcut (

CtrlP

) instead.