Skip to content

Integrating Location Services in Your Android App – Day 11 Android 14 Masterclass

Integrating Location Services in Your Android App – Day 11 Android 14 Masterclass
Become a developer with our complete learning paths
Become a developer with our complete learning paths

Integrating Location Services in Your Android App – Day 11 Android 14 Masterclass

Welcome to Day 11 of our Android 14 & Kotlin Masterclass, where we focus on integrating location services into your Android apps. This session guides you through adding location functionality, from managing permissions in the Android Manifest to leveraging the Context for location services. We’ll explore handling user permissions and using Android’s Geocoder class for real-world address translation, enhancing your app’s user experience with dynamic location features.


1. Add Permissions in Android Manifest

To integrate location services into your Android app, you’ll need to request the necessary permissions in your app’s AndroidManifest.xml file.

There are two main permissions related to location:

  1. ACCESS_COARSE_LOCATION: This permission allows an app to access approximate location derived from network location sources such as cell towers and Wi-Fi.
  2. ACCESS_FINE_LOCATION: This permission enables an app to access precise location from sources such as GPS.

Here’s how to add these permissions to the AndroidManifest.xml:

  1. Open the AndroidManifest.xml file in your project.
  2. Add the following <uses-permission> elements as children of the <manifest> root element, not the <application> element:

3. Save the file.


2. Understanding Context

In Android development, “Context” is a fundamental concept that represents the current state of your application and provides access to global information about the application environment.

It’s like a handle to the system; it provides services like resolving resources, obtaining access to databases and preferences, and so on.

In the context of adding location to your app, Context is used to interact with location services and to check permissions.

Here’s a breakdown of what Context means and its relevance to location services:


  • Access to System Services: Context allows your app to access system services such as the LOCATION_SERVICE, which is needed to obtain user location.
  • Permissions: To access location data, you need to check if the user has granted the necessary permissions. Context is used to check these permissions at runtime, which is required for potentially sensitive data, like a user’s location.


To use Context in your app, you typically have various options depending on where you are in the code:

  • this: When you’re in an Activity class, you can use this to refer to the context of the current activity because an Activity is a subclass of Context.
  • getApplicationContext(): If you need application-wide context, not tied to the current activity lifecycle, you can use this method.
  • getContext() or getBaseContext(): These can be used in other cases where you have a View or Service, and you want to get the context associated with them.


Here are some examples of how Context is used in an Android app when working with location:

1. Getting the Location Manager Service:

2. Checking Location Permissions:

3. Requesting Location Permissions:

Here activity represents the current activity context.

4. Using Application Context:

This might be used when you need a context that’s separate from the current activity’s context to avoid memory leaks.

Remember, if you’re in a fragment or a view, you would often call something like requireContext() or getContext() respectively to get the context.

Key Points to Remember:

  • Context is like your app’s passport;
  • it provides evidence of who your app is and grants access to the various services and systems on the device, including those needed to get a user’s location.
  • Whenever you see a method that requires Context as a parameter, it’s essentially asking for details about your app and its permissions to access data or resources.


3. Crafting a Function to Check for Location Access Permissions in Your Android App

In the real world, before you enter certain places or use some services, you need to ask for permission. For example, you wouldn’t just walk into someone’s house without asking; you’d knock on the door and wait to be invited in.

The same goes for mobile apps when they need to access sensitive information like your location.So, when your app needs to know where you are, it has to ask you for permission to use your phone’s GPS.

Now, let’s translate this into the world of coding, specifically for an Android app written in Kotlin.

Step by Step Explanation:

  1. Understand the Permission System: Android has a permission system to protect users’ privacy. Your app must ask the user to grant permissions for certain actions, like accessing the location.
  2. Write the Function: We’re going to write a function called checkLocationPermission to check if we have the permission to access the user’s location.
  3. Understand the Response: The system will give us one of two answers: either we have the permission, or we don’t. If we do, great! We can proceed to get the location. If not, we might need to ask the user for permission.

The Function:

Let’s write the code for our checkLocationPermission function:

Here’s what we’re doing in the code:

  • We define a function named checkLocationPermission that takes a Context as an input. This Context is like a snapshot of our app’s current situation.
  • We then check if we have the “Fine Location” permission using a function called checkSelfPermission.
  • We do the same for the “Coarse Location” permission.
  • If both checks are true, it means we have both permissions, and we return true.
  • If either is false, our function will return false, indicating that we do not have permission to access the location.

How to Use This Function:

You’d call this function from somewhere in your app, like an Activity, whenever you need to check for location permissions. Here’s how you’d do that:

If we don’t have permission, we’d need to take additional steps to request it from the user, which involves another process of showing a dialog and handling their response.


4. Handling Permission Requests

rememberLauncherForActivityResult() is a Jetpack Compose specific API used to handle the result of an activity that’s started for a result, such as permission requests.

When you request permissions, Android will show the user a dialog, and the user will either grant or deny the permissions. The system then returns the result to your app, and you need to handle this in your code.

This method provides a way to launch an activity and receive the result back in a composable function without managing the lifecycle or the request code manually.

How does it work?

  1. contract: This parameter takes an ActivityResultContract, which defines the type of input you need to provide and the type of output you’ll expect. For permissions, you would use ActivityResultContracts.RequestMultiplePermissions().
  2. onResult: This lambda is where you handle what happens after the activity finishes and the result is available. For permissions, it provides a map with the permission names as keys and Boolean values indicating whether each permission was granted.

The Step Explained:

When you want to check and request location permissions within a composable function, you would take the following steps using rememberLauncherForActivityResult():


5. Communicating the Need for Permissions to Users

When building an Android app, it’s good practice to explain to your users why you need certain permissions, especially if they are sensitive like location data.

This is where the shouldShowRequestPermissionRationale() method comes into play.

What is this method?

It is a method that determines whether you should show UI with rationale for requesting a permission. The rationale is essentially a message explaining why your app needs a particular permission.

When to use it?

You should consider calling this method in two situations:

  1. If the user has denied the permission request previously: If the user has previously turned down the permission request, your app can show an explanation of why you need this permission before making another request.
  2. If the user has denied the permission request and checked “Don’t ask again”: Even if the user has chosen “Don’t ask again”, your app can still explain the reason for the permission, which may lead the user to manually enable the permission through the app settings.

Here’s how you might implement it:

In the code example above:

  • activity: Represents your activity context.
  • permission: The permission you’re asking for.
  • MY_PERMISSIONS_REQUEST_LOCATION: An app-defined integer constant that is used as the request code.

The showRationaleDialog function is hypothetical—it represents whatever method you implement to show your rationale to the user, perhaps a dialog box or some custom UI.

Remember that providing a clear and compelling rationale can help improve user trust and the likelihood that they will grant the permission.


6. Silencing the Critics: Understanding the Use of @SuppressLint in Android Development

Imagine you’ve written a beautiful essay, but you’ve used a pen that’s known to smudge a little. When you hand it over to your teacher, you put a little note on top saying, “Please ignore any smudges — I’m aware of them, but it’s the only pen I had!” This note is a heads-up to your teacher to not mark you down for the smudge marks because you’re already aware of them and had a good reason for using that pen.

In Android development, sometimes you might write code that the Android system flags as potentially problematic or not following best practices. These warnings are there to help you write better and more efficient code that works well across different versions of Android and different devices.

However, there might be times when you know exactly why you’re doing what you’re doing, and you have a good reason to go against those warnings.

This is where @SuppressLint comes into play in Android development.

What is @SuppressLint?

@SuppressLint is an annotation in Android that tells the lint tool (which checks your code for potential bugs and improvements) to ignore specific warnings for the annotated part of the code.

How do you use @SuppressLint?

You use @SuppressLint by placing it above a method, class, or any other piece of code you’re writing, followed by the specific warning that you want lint to ignore.

For example:

In this code snippet, "MissingPermission" is the warning that lint would normally give you because your code is doing something that requires a permission check, and lint can’t see that check happening.

By using @SuppressLint, you’re telling lint, “I know what I’m doing, please ignore this specific warning.”

Why should you use it cautiously?

It’s important not to overuse @SuppressLint because while it can be useful, it can also hide real issues in your code. It’s like telling your teacher to ignore smudges when, in reality, you might have made other mistakes.

So, you should only use it when you’re sure that the warning is not indicating a real problem or when you’ve handled the situation in a way that lint doesn’t recognize.


7. Understanding the Key Components for Location Tracking

Adding location to an Android app might seem complex at first, but it’s like putting together a puzzle. Each piece has a specific place and role.

Let’s break down these terms one by one in the context of location services in Android:

  1. LocalContext.current: LocalContext.current is a handy way to access the ‘current’ context right from a composable function. Think of context as a handle to the system; it provides access to resources, databases, and preferences, and more. In our case, we need it to interact with location services.
  2. FusedLocationProviderClient: Imagine you have a friend who’s really good at finding places and can do it in different ways—by looking at the stars, reading maps, or asking locals. The FusedLocationProviderClient is like that friend. It combines various data sources to provide the best location information in an efficient way. It’s a part of Google Play services and provides a simple API for getting location information.
  3. getFusedLocationProviderClient(context): This is like saying, “Hey, I need to use your location-finding skills.” By calling this function and giving it the context, you create an instance of FusedLocationProviderClient that you can use to start asking for location updates.
  4. LocationCallback(): Now, once you’ve asked your friend (the FusedLocationProviderClient) to find a location, you need a way for them to tell you once they’ve found it, or if something has changed. That’s what LocationCallback is for. You provide this callback so that you get notified about location updates or changes.
  5. LocationRequest.Builder: Before you send your friend off to find a location, you need to tell them how you want them to search for it. Do you need a super-accurate location, or is a general idea okay? Do you need updates every second, or is every few minutes fine? LocationRequest.Builder lets you build a set of criteria that tells the FusedLocationProviderClient exactly how you want it to act—how often to check for location, how accurate it should be, etc.
  6. Looper: In Android, a Looper is like a conveyor belt in a factory that ensures tasks are handled one at a time in a sequence. When you get location updates, these can come at you fast, like products on an assembly line. The Looper ensures that each location update is processed in a controlled manner. It keeps a loop running that checks for messages indicating a location update and then handles them.

Putting all these together, here’s a simplistic view of what happens in an Android app when adding location:

  1. Your app (using LocalContext.current) says, “I need to know where we are.”
  2. It uses getFusedLocationProviderClient(context) to access the powerful location services.
  3. It sets up a LocationRequest with LocationRequest.Builder to tell the location services how to search for the location.
  4. It prepares a LocationCallback to handle the updates that will come in.
  5. Finally, it starts receiving location updates, processed one by one with a Looper, and can then do something useful with that location information, like showing the user where they are on a map.


8. Geocoder: Translating Coordinates into Real-World Addresses in Android

What is Geocoder?

A Geocoder is a class in Android that performs geocoding and reverse geocoding.

Geocoding is the process of transforming a street address or other description of a location into a (latitude, longitude) coordinate. Reverse geocoding, on the other hand, converts geographic coordinates into a human-readable address.

Why Use Geocoder?

Let’s say your app has obtained the current location coordinates using the location services. These coordinates are numerical and not particularly user-friendly.

If you want to display the location as an actual address on the screen or you need the address data for some functionality, you will need to convert those coordinates into something more meaningful. This is where Geocoder comes in.

How Does Geocoder Work?

Geocoder uses a backend service that it communicates with to perform its translations. Here’s how you can use it:

  1. Geocoding: You have an address or place name, and you want to find its coordinates.

  1. Reverse Geocoding: You have the latitude and longitude, and you need to find out the address.

In the code above, context is your app or activity context, Locale.getDefault() sets the locale based on your device’s default language/country (you can set a specific locale as well).

Things to Note

  • Geocoder requires a backend service provided by the device’s platform. If this service is not available, geocoding will not work.
  • The getFromLocationName and getFromLocation methods can return multiple results, hence the ‘1’ in the method call specifies that you want just one result.
  • Network connectivity is required for Geocoder to work, as it needs to access the backend service.


Conclusion: Integrating Location Services in Your Android App – Day 11 Android 14 Masterclass

Concluding Day 11 of our Android 14 & Kotlin Masterclass, we’ve covered the essentials of integrating location services in Android apps. From setting up necessary permissions to effectively using Context and handling user consents, these insights prepare you to develop more intuitive and responsive applications. The session also highlighted the significance of the Geocoder class in making location data user-friendly, equipping you to create engaging and innovative mobile experiences.



If you want to skyrocket your Android career, check out our The Complete Android 14 & Kotlin Development Masterclass. Learn Android 14 App Development From Beginner to Advanced Developer.

Master Jetpack Compose to harness the cutting-edge of Android development, gain proficiency in XML — an essential skill for numerous development roles, and acquire practical expertise by constructing real-world applications.


Check out Day 9 of this course here.

Check out Day 10 of this course here.

Check out Day 12 of this course here.

Lost in coding? Discover our Learning Paths!
Lost in coding? Discover our Learning Paths!
Enter your email and we will send you the PDF guide:
Enter your email and we will send you the PDF guide