DEV Community: Chitranshi Srivastava

W1 D2: Fetching & Saving User's Current Location 👤📍

Chitranshi Srivastava — Wed, 15 Sep 2021 14:42:38 +0000

So in the last article, we added a Google Map to an Android app. This is a continuation of that article. Now let's fetch the user's current location & save the map state along with the camera position.

Week 1 🗺️

This week we'll be doing all things maps in Android. Being able to pull off stunts like adding markers to the map, style the map, add geofences, get the user's last known location, etc. are indispensable to your knowledge in this area (pun intended). These things are extremely useful & are super important if you want to know how to add functionalities like sharing your location, sending notifications according to the user's location, etc.

You can check out the other posts from this week 📍 👍.

Adding a Google Map
Extracting & Saving the User's Current Location
Incremental Location Permissions
Incremental Location Permissions with EasyPermissions Library
Sharing Location Data using Firebase
Live Location Tracking/Sharing
Adding a Marker to the Map on Long-click & Storing the Marked Location/POI

Day 2: Fetching & Saving User's Current Location

This stunt is divided into 3 parts -

Preparing to get the user's device location (getting the permissions, setting up the UI, etc.)
Getting the user's current device location
Saving the map state & camera position

Okay so shut all the distractions, get hydrated, we'll now get these parts done.

Prepare to get the user's device location

Enable the Places SDK in the Google Cloud project you just created.
- Google Cloud console -> select your project -> APIs -> Places SDK -> Enable
Add Places dependency (app: build.gradle)
- implementation 'com.google.android.libraries.places:places:2.4.0'

Instantiate the Places API client

Create a PlacesClient object & a FusedLocationProviderClient object.

    // MapsActivity.kt

    private lateinit var placesClient: PlacesClient
    private lateinit var fusedLocationProviderClient: FusedLocationProviderClient

    override fun onCreate(savedInstanceState: Bundle?) {
            ...

            // Create PlacesClient
        Places.initialize(applicationContext, getString(R.string.maps_api_key))
        placesClient = Places.createClient(this)

        // Create FusedLocationProviderClient
        fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)
    }

Request location permission

Add fine location permission in your app for FINE_LOCATION

    // AndroidManifest.xml

    <!--
         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-permissionandroid:name="android.permission.ACCESS_FINE_LOCATION" />

Request run-time permission for FINE_LOCATION

            // MapsActivity.kt

                private var locationPermissionGranted = false

                private fun getLocationPermission() {
                /*
                 * Request location permission, so that we can get the location of the
                 * device. The result of the permission request is handled by a callback,
                 * onRequestPermissionsResult.
                 */
                if (ContextCompat.checkSelfPermission(this.applicationContext, 
                        android.Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
                    locationPermissionGranted = true
                } else {
                    ActivityCompat.requestPermissions(this, 
                        arrayOf(android.Manifest.permission.ACCESS_FINE_LOCATION), 
                        PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION
                    )
                }
            }

                companion object {
                    private const val PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 111
                }

Handle the result of the request permission

                // MapsActivity.kt      

                override fun onRequestPermissionsResult(requestCode: Int,
                                                    permissions: Array<String>,
                                                    grantResults: IntArray) {
                super.onRequestPermissionsResult(requestCode, permissions, grantResults)
                locationPermissionGranted = false
                when (requestCode) {
                    PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION -> {

                        // If request is cancelled, the result arrays are empty. But if the user has now
                        // granted the permission (after we requested), the result array contains that permission.
                        if (grantResults.isNotEmpty() &&
                            grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                            locationPermissionGranted = true
                        }
                    }
                }
            }

Update the UI

Update the UI if the user has granted permission

    // mAPSaCTIVITY.KT
    private var lastKnownLocation = null

    override fun onMapReady(googleMap: GoogleMap) {
        ...
        // Turn on the My Location layer and the related control on the map.
        updateLocationUI()
    }

    override fun onRequestPermissionsResult(...) {
        ...
        updateLocationUI()
    }       

    private fun updateLocationUI() {
        /**
         * If the user has granted the FINE_LOCATION permission, update the UI else don't
         */
        if (mMap == null) {
            return
        }
        try {
            if (locationPermissionGranted) {
                mMap.isMyLocationEnabled = true
                mMap.uiSettings.isMyLocationButtonEnabled = true
            } else {
                mMap.isMyLocationEnabled = false
                mMap.uiSettings.isMyLocationButtonEnabled = false
                lastKnownLocation = null
                getLocationPermission()
            }
        } catch (e: SecurityException) {
            Log.e("Exception: %s", e.message, e)
        }
    }

Get the location of the Android device and position the map

get the device location

        // MapsActivity.kt

            private var lastKnownLocation: Location? = null
            private val defaultLocation = LatLng(-34.0, 151.0)      // Sydney       

            override fun onMapReady(googleMap: GoogleMap) {
                    ...
                // Get the current location of the device and set the position of the map.
                getDeviceLocation()
            }

            private fun getDeviceLocation() {
            /*
             * Get the best and most recent location of the device, which may be null in rare
             * cases when a location is not available.
             */
            try {
                if (locationPermissionGranted) {
                    val locationResult = fusedLocationProviderClient.lastLocation
                    locationResult.addOnCompleteListener(this) { task ->
                        if (task.isSuccessful) {
                            // Set the map's camera position to the current location of the device.
                            lastKnownLocation = task.result
                            if (lastKnownLocation != null) {
                                mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(
                                    LatLng(lastKnownLocation!!.latitude,
                                        lastKnownLocation!!.longitude), DEFAULT_ZOOM))
                            }
                        } else {
                            Log.d(TAG, "Current location is null. Using defaults.")
                            Log.e(TAG, "Exception: %s", task.exception)
                            mMap.moveCamera(CameraUpdateFactory
                                .newLatLngZoom(defaultLocation, DEFAULT_ZOOM))
                            mMap.uiSettings.isMyLocationButtonEnabled = false
                        }
                    }
                }
            } catch (e: SecurityException) {
                Log.e("Exception: %s", e.message, e)
            }
        }

        companion object {
             private const val DEFAULT_ZOOM = 50F
         }

    ```
{% endraw %}

Now run the app. After allowing the app to get your location, you'll see that the map zooms in to your current location, displaying a blue circle at your precise latitude & longitude. Great! 🍻
![55.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1631373417221/GE0fvfGUg.png)
![44.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1631373423561/r2MR9A-Ry.png)

Save the map's state

Save map's state & camera position

Set up the values that you want to save
Save the state

Retrieve the saved state on onCreate()
{% raw %}

// MapsActivity.kt      

private var cameraPosition: CameraPosition? = CameraPosition(defaultLocation, DEFAULT_ZOOM, 0.0F, 0.0F)

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // Retrieve the user's saved map state & camera position
        if (savedInstanceState != null) {
            lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION)
            cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        /**
         * Save the map's state & camera position when the activity is destroyed
         * (like in a configuration change)
         */
        mMap.let { map ->
            outState.putParcelable(KEY_CAMERA_POSITION, map.cameraPosition)
            outState.putParcelable(KEY_LOCATION, lastKnownLocation)
        }
        super.onSaveInstanceState(outState)
    }

    companion object {
        ...
        private const val KEY_CAMERA_POSITION = "camera_position"
        private const val KEY_LOCATION = "location"
    }

This is it. Now run the app & rotate it. You'll see the marker persists. You've now successfully fetched & saved your app's user's current location! 🎊

W1 D1: Adding a Google Map 🗺️💗

Chitranshi Srivastava — Wed, 15 Sep 2021 14:26:51 +0000

Hi reader! I'm an Android apps developer. I'm starting this new series called #100DaysOfAndroid in which I'll be covering a cool concept in Android every day for 100 days 🔥. This series will basically have posts about something that I implement during the day & think is an important topic to explain here for your as well as my future reference. Expect a mixture of easy, medium & advanced topics to be covered in these posts. Hopefully, this series helps & motivates you in your journey as an Android developer! 👉👈

Week 1 🗺️

You can check out the other posts from this week 📍 👍.

Adding a Google Map
Extracting & Saving the User's Current Location
Incremental Location Permissions
Incremental Location Permissions with EasyPermissions Library
Sharing Location Data using Firebase
Live Location Tracking/Sharing
Adding a Marker to the Map on Long-click & Storing the Marked Location/POI

Day 1: Add a Google Map to Your App

Create a Google Maps project

Add Google Maps to your Project
- New project → Google Maps Activity -> ... -> Create
- This will add all the code necessary for adding a map to your app. It mainly adds 3 files automatically to your project: a MapsActivity, an activity_maps.xml layout file in the res folder & an activity_maps_api.xml resource file in the values folder.

You don't need to add the code below. As soon as you create the project, Android Studio will add these for you.

// MapsActivity.kt

import androidx.appcompat.app.AppCompatActivity
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
import com.gmail.apigeoneer.sharemylocation.databinding.ActivityMapsBinding

/**
 * Once an instance of this interface is set on a MapFragment or MapView object, onMapReady(GoogleMap) method is triggered
 * when the map is ready to be used and provides a non-null instance of GoogleMap.
 */
class MapsActivity : AppCompatActivity(), OnMapReadyCallback {

    // Declare a map object
    private lateinit var mMap: GoogleMap
    private lateinit var binding: ActivityMapsBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding=ActivityMapsBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // Obtain the SupportMapFragment and get notified when the map is ready to be used.
        val mapFragment=supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    /**
     * Manipulates the map once available.
     * This callback is triggered when the map is ready to be used.
     * This is where we can add markers or lines, add listeners or move the camera. In this case,
     * we just add a marker near Sydney, Australia.
     * If Google Play services are not installed on the device, the user will be prompted to install
     * it inside the SupportMapFragment. This method will only be triggered once the user has
     * installed Google Play services and returned to the app.
     */
    override fun onMapReady(googleMap: GoogleMap) {
        mMap=googleMap

        // Add a marker in Sydney and move the camera
        val sydney=LatLng(-34.0, 151.0)
        mMap.addMarker(MarkerOptions().position(sydney).title("Marker in Sydney"))
        mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney))
    }
}

// activity_maps.xml

<?xml version="1.0" encoding="utf-8"?>
<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.SupportMapFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MapsActivity" />

// google_maps_api.xml (debug)

<resources>
    <!--
    TODO: Before you run your application, you need a Google Maps API key.

    To get one, follow this link, follow the directions, and press "Create" at the end:

    https://console.developers.google.com/flows/enableapi?apiid=maps_android_backend&keyType=CLIENT_SIDE_ANDROID&r=...

    You can also add your credentials to an existing key, using these values:

    Package name:
    ...

    SHA-1 certificate fingerprint:
    ...
    Alternatively, follow the directions here:
    https://developers.google.com/maps/documentation/android/start#get-key

    Once you have your key (it starts with "AIza"), replace the "google_maps_key"
    string in this file.
    -->
    <string name="google_maps_key" templateMergeStrategy="preserve" translatable="false">YOUR_API_KEY</string>
</resources>

If you're wondering if you need to add any dependencies for this code to run successfully, the answer is no you don't.

Now, you just need to provide the API key.

Create a new project on Google Cloud

Go over to the Google Cloud page → Create a new project
Enable the Maps SDK for Android
Credentials → Create Credentials → API key → Restrict key → Android apps, Restrict key, Maps SDK for Android (Select APIs) → save → copy key
Save.

Add the API key to your app

Paste the key in place of YOUR_KEY_HERE

      // google_maps_api.xml


<stringname="google_maps_key"templateMergeStrategy="preserve"translatable="false">YOUR_KEY_HERE</string>

Now run the app & a beautiful map with a marker in Sydney should appear once the app installs on your device/emulator.

Read this if you aren't yet creating Custom Text widgets!

Chitranshi Srivastava — Thu, 09 Sep 2021 13:07:15 +0000

Have you ever added Text Views to any of your Android projects? Of course you have. Have you added attributes to those Text Views...? Style, Color, Size, Font... blah blah blah? Well Of course you have. Now the real question -
Do you add these attributes individually for every Text View in your app? Even if half of them have the exact same size? Almost all of them have the exact same font & color? Do you think defining those attributes for each time was necessary? Do you think there should be a way you could just specify once a few categories of Text Views & what they should look like & then just tell all the Text Views what category they belong?
Turns out, there's is a way to do just that! & it has existed from even before you were born (Joking). & it's so simple, it'll make you smile.

Add font to project
Add your font to the font folder.
Create a new Kotlin class. Call it something that conveys what the custom Text View is for. Like if you're using this one for all the headlines in your app, let's call it HeadlineTextView.
```
// HeadlineTextView

class HeadlineTextView{
}
```
Extend this class to AppCompatTextView. Specify the context & attributeSet constructor parameters.
AppCompatTextView is basically a class that's already used when you create TextViews. You only need to care about it when you're customizing a TextView in code like we're doing here. It has its siblings too, like for custom Edit Texts there's this class called AppCompatEditText. Similarly, we have AppCompatButton, AppCompatImageView... (you get my point).
```
// HeadlineTextView

class HeadlineTextView(context: Context, attrs: AttributeSet)
    : AppCompatTextView(context, attrs) {
}
```

Create a function to apply parameters to the Text View & call it in the init block.

// HeadlineTextView

class HeadlineTextView(context: Context, attrs: AttributeSet)
    : AppCompatTextView(context, attrs) {

    init {
        applyFont()
    }

    private fun applyFont() {
    }
}

Inside this method, initialize a typeface & set the Typeface to this.
Typeface has everything to do with how a font appears on the screen... is it regular, or italic, or bold? You can select a font from the assets or from the fonts folder, like here & create the Typeface you want.
```
// HeadlineTextView

    private fun applyFont() {
        val headlineTypeface: Typeface = Typeface.create("Montserrat Bold", Typeface.BOLD)
        typeface = headlineTypeface
    }
```

Use the custom widget we just created by changing the TextView in the XML to HeadlineTextView.

// activity_main.xml

// Replace this-

<TextView
    android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:textStyle="bold"
  android:fontFamily="montserrat"
  android:text="This is a Headline!" />

// With this -

<com.gmail.something.utils.HeadlineTextView
    android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:text="This is a Headline!" />

You can now use custom widgets. That won't stop Global warming of course but it can come in handy!
Feel free to drop a comment or contact me for clarifications/suggestions.

How to 'Properly' Choose & Change the App Icon of Your Android App

Chitranshi Srivastava — Thu, 17 Jun 2021 15:36:27 +0000

After you've built your app, you might want to change your app's icon from that old Android default icon to a new more customized one. Your app's icon isn't just the face of your app, it is also the face of the brand of your app. Doesn't matter if you're not a startup, any good app idea can be scaled later when it works & having a great icon is undoubtedly an important & necessary marketing strategy.

Choose your App Icon

Here are some Tips on picking or designing your new app icon image.

IS RELATED to your App Idea

Try to pick an image that conveys what your app is about. It would definitely not tell "everything" about the app, but it should be related. So, if you made a brainy game app of building houses, you won't put an image of a sandwich on the icon, right? You get my point.
Pick a SIMPLE & UNIQUE Design.

The simpler the app icon, the more sense it'd make on one glance. App icons containing too much details are really difficult to comprehend & don't look neat & well-designed.
You'll want the design to be unique so that your users remember it & are intrigued when they see it on the Play Store.
Think of the most legendary & remembered app icons & notice how simple, yet catchy they are.
Keep it BRIGHT & HIGHLIGHTED

Your app icon should shine (both literally & metaphorically). The way you can make it shine is by picking bright colors.
Refer to the icons in the image above. Do they use dull faded shades or bright ones? Most legendary app icons use primary colors. Or a color very near to these colors. This is because as humans, we're designed to notice the primary colors more.
Who better to give an example of than Google's own apps. Google had sort of branded these primary colors as their own.
A/B Testing

So, you've picked up a handsome app icon. You think it's the best for your app. Or maybe you're stuck on half a dozen different images & you can't decide which one to pick. I either case, don't just rest on your own intuition & the suggestions of friends , family & your dog. Go test your design!
A/B Testing not only helps you pick a design that looks good, it also decides which of your designs would get you the most downloads on the Play store. Cool, isn't it? Make sure the next time you change your app's icon, you first test the new one.
Here's a link to an article I found on the internet on the best mobile A/B testing tools.

Change your App Icon

Here are the steps you need to follow to change your app's icon properly. I say "properly" because you need to keep certain things in mind like the size of the image, its name etc., so that you don't run into any problems both, while making the change & after making it.
Also, your project size may differ. You might be working on a big project with lots of apps, & making a wrong move might break down the entire project & take hours to fix.

Open your app in Android Studio. Go to the Project directory from the top-left drop-down.

Resize the new image

More often than not, you'll find that the image you've decided to use as the app icon is too large. It is definitely a good idea to resize your image to the standard size before using it in your app.
Use this Online Image Resizer to resize the new app icon that you've decide to use. Set the width
& height to a value between 300-400 pixels. Also, make sure the width & height are equal since you'll be using this image as an app icon, which appears as a circle or square.
Change the app logo in the drawable

If you're working on a big project with many apps, first go to the src folder, & select the app you're working on (say, Xyz folder).
After you've selected the app, the steps are the same for both small & large projects. Move to the res folder. Inside it, right click on the drawable folder. Now choose Open in Explorer. This would open a new window.
Inside the new window, open the drawable folder. Delete the old image & paste the new (resized) image here.
Make sure to rename the image you're pasting to the name of the old image (app_logo.png works best).
Delete all the mipmap folders (6, most probably).

Now, go to the Android directory from the top-left drop-down.
Add a new Image Asset

Go to the mipmap folder, right clicking on it, selecting New & then selecting Image Asset.
Make sure to check that the right path (of the image you just added app_logo.png) is selected in the path label. Click Next.
Now, make sure the res label has your current app folder name (Xyz, in our case). Click Finish.

That's it. You've now changed your old app icon to a new (hopefully) better one!

Any feedbacks/suggestions are welcome. :D

Creating Notifications in Android with Kotlin

Chitranshi Srivastava — Sat, 12 Jun 2021 08:14:55 +0000

STEPS

Create a Notification

NotificationUtils, EggTimerViewModel, EggTimerFragment

A Basic Notification

Implement an extension fun sendN in NotificationManager - to send Ns w/o rewriting the code

Create an extension fun to send messages
Create the content intent for the notification to launch this activity
Create PendingIntent
Set content intent
Cancel all notifications

Get an instance of NotificationCompat.Builder to build the notification
Set title, text and icon to the Builder
Call notify
Use the new notification channel

Add style
Add style to the Builder
Add snooze action

Set priority

// NotificationUtils.kt

package com.example.android.eggtimernotifications.util

import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.BitmapFactory
import androidx.core.app.NotificationCompat
import com.example.android.eggtimernotifications.MainActivity
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.receiver.SnoozeReceiver

// Notification ID.
private val NOTIFICATION_ID = 0
private val REQUEST_CODE = 0
private val FLAGS = 0

// Step 1.1 extension function to send messages (GIVEN)
/**
 * Builds and delivers the notification.
 *
 * @param context, activity context.
 */
fun NotificationManager.sendNotification(messageBody: String, applicationContext: Context) {
    // Create the content intent for the notification, which launches
    // this activity
    // TODO: Step 1.11 create intent

    // TODO: Step 1.12 create PendingIntent

    // TODO: Step 2.0 add style

    // TODO: Step 2.2 add snooze action

    // TODO: Step 1.2 get an instance of NotificationCompat.Builder
    // Build the notification
    val builder = NotificationCompat.Builder(
        applicationContext,
        applicationContext.getString(R.string.egg_notification_channel_id)
    )

    // TODO: Step 1.8 use the new 'breakfast' notification channel

    // TODO: Step 1.3 set title, text and icon to builder
        .setSmallIcon(R.drawable.cooked_egg)
        .setContentTitle(applicationContext
            .getString(R.string.notification_title))
        .setContentText(messageBody)

    // TODO: Step 1.13 set content intent

        // TODO: Step 2.1 add style to builder

        // TODO: Step 2.3 add snooze action

        // TODO: Step 2.5 set priority

    // TODO: Step 1.4 call notify
    notify(NOTIFICATION_ID, builder.build())
}

// TODO: Step 1.14 Cancel all notifications

Get an instance of NotificationManager and call sendNotification

EggTimerViewModel

package com.example.android.eggtimernotifications.ui

import android.app.*
import android.content.Context
import android.content.Intent
import android.os.CountDownTimer
import android.os.SystemClock
import androidx.core.app.AlarmManagerCompat
import androidx.core.content.ContextCompat
import androidx.lifecycle.*
import com.example.android.eggtimernotifications.receiver.AlarmReceiver
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.util.sendNotification
import kotlinx.coroutines.*

class EggTimerViewModel(private val app: Application) : AndroidViewModel(app) {

    private val REQUEST_CODE = 0
    private val TRIGGER_TIME = "TRIGGER_AT"

    private val minute: Long = 60_000L
    private val second: Long = 1_000L

    private val timerLengthOptions: IntArray
    private val notifyPendingIntent: PendingIntent

    private val alarmManager = app.getSystemService(Context.ALARM_SERVICE) as AlarmManager
    private var prefs = app.getSharedPreferences(
                        "com.example.android.eggtimernotifications",
                        Context.MODE_PRIVATE
        )
    private val notifyIntent = Intent(app, AlarmReceiver::class.java)

    private val _timeSelection = MutableLiveData<Int>()
    val timeSelection: LiveData<Int>
        get() = _timeSelection

    private val _elapsedTime = MutableLiveData<Long>()
    val elapsedTime: LiveData<Long>
        get() = _elapsedTime

    private var _alarmOn = MutableLiveData<Boolean>()
    val isAlarmOn: LiveData<Boolean>
        get() = _alarmOn

    private lateinit var timer: CountDownTimer

    init {
        _alarmOn.value = PendingIntent.getBroadcast(
            getApplication(),
            REQUEST_CODE,
            notifyIntent,
            PendingIntent.FLAG_NO_CREATE
        ) != null

        notifyPendingIntent = PendingIntent.getBroadcast(
            getApplication(),
            REQUEST_CODE,
            notifyIntent,
            PendingIntent.FLAG_UPDATE_CURRENT
        )

        timerLengthOptions = app.resources.getIntArray(R.array.minutes_array)

        //If alarm is not null, resume the timer back for this alarm
        if (_alarmOn.value!!) {
            createTimer()
        }

    }

    /**
     * Turns on or off the alarm
     *
     * @param isChecked, alarm status to be set.
     */
    fun setAlarm(isChecked: Boolean) {
        when (isChecked) {
            true -> timeSelection.value?.let { startTimer(it) }
            false -> cancelNotification()
        }
    }

    /**
     * Sets the desired interval for the alarm
     *
     * @param timerLengthSelection, interval timerLengthSelection value.
     */
    fun setTimeSelected(timerLengthSelection: Int) {
        _timeSelection.value = timerLengthSelection
    }

    /**
     * Creates a new alarm, notification and timer
     */
    private fun startTimer(timerLengthSelection: Int) {
        _alarmOn.value?.let {
            if (!it) {
                _alarmOn.value = true
                val selectedInterval = when (timerLengthSelection) {
                    0 -> second * 10 //For testing only
                    else ->timerLengthOptions[timerLengthSelection] * minute
                }
                val triggerTime = SystemClock.elapsedRealtime() + selectedInterval

                // Step 1.5 get an instance of NotificationManager and call sendNotification
                val notificationManager = ContextCompat.getSystemService(                       
                    app,                                                                        
                    NotificationManager::class.java                                             
                ) as NotificationManager                                                        
                notificationManager.sendNotification(app.getString(R.string.timer_running), app)

                              // Step 1.15 call cancel notification

                AlarmManagerCompat.setExactAndAllowWhileIdle(
                    alarmManager,
                    AlarmManager.ELAPSED_REALTIME_WAKEUP,
                    triggerTime,
                    notifyPendingIntent
                )

                viewModelScope.launch {
                    saveTime(triggerTime)
                }
            }
        }
        createTimer()
    }

    /**
     * Creates a new timer
     */
    private fun createTimer() {
        viewModelScope.launch {
            val triggerTime = loadTime()
            timer = object : CountDownTimer(triggerTime, second) {
                override fun onTick(millisUntilFinished: Long) {
                    _elapsedTime.value = triggerTime - SystemClock.elapsedRealtime()
                    if (_elapsedTime.value!! <= 0) {
                        resetTimer()
                    }
                }

                override fun onFinish() {
                    resetTimer()
                }
            }
            timer.start()
        }
    }

    /**
     * Cancels the alarm, notification and resets the timer
     */
    private fun cancelNotification() {
        resetTimer()
        alarmManager.cancel(notifyPendingIntent)
    }

    /**
     * Resets the timer on screen and sets alarm value false
     */
    private fun resetTimer() {
        timer.cancel()
        _elapsedTime.value = 0
        _alarmOn.value = false
    }

    private suspend fun saveTime(triggerTime: Long) =
        withContext(Dispatchers.IO) {
            prefs.edit().putLong(TRIGGER_TIME, triggerTime).apply()
        }

    private suspend fun loadTime(): Long =
        withContext(Dispatchers.IO) {
            prefs.getLong(TRIGGER_TIME, 0)
        }
}

Notification Channels

Create an extension fun createChannel (& call it in onCreate)

Create a NotificationChannel instance - pass id, name & importance
On the NotificationChannel obj, set the props - enableLights, lightColor, enableVibration, channel description
Get an instance of NotificationManager by calling getSystemService
Call createNotificationChannel on NotificationManager and pass the NotificationChannel obj.
To create the channel, call this createChannel ext. fun in the onCreate fun.
NotificationUtils → build: verify the channel id you previously set is correct

Pull the status bar and observe the notification title, content and icon are just like you set in the previous steps.
To verify the newly created channel, close the app and find the app icon. Perform a long click on the app icon and select app info.

// EggTimerFragment.kt

package com.example.android.eggtimernotifications.ui

import android.app.NotificationChannel
import android.app.NotificationManager
import android.graphics.Color
import android.os.Build
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.databinding.DataBindingUtil
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.databinding.FragmentEggTimerBinding
import com.google.firebase.messaging.FirebaseMessaging

class EggTimerFragment : Fragment() {

    private val TOPIC = "breakfast"

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {

        val binding: FragmentEggTimerBinding = DataBindingUtil.inflate(
            inflater, R.layout.fragment_egg_timer, container, false
        )

        val viewModel = ViewModelProvider(this).get(EggTimerViewModel::class.java)

        binding.eggTimerViewModel = viewModel
        binding.lifecycleOwner = this.viewLifecycleOwner

        // Step 1.7 call create channel
        createChannel(
            getString(R.string.egg_notification_channel_id),
            getString(R.string.egg_notification_channel_name)
        )

        return binding.root
    }

    private fun createChannel(channelId: String, channelName: String) {
        // Step 1.6 START create a channel
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val notificationChannel = NotificationChannel(
                channelId,
                channelName,
                // Change importance
                NotificationManager.IMPORTANCE_LOW
            )

            notificationChannel.enableLights(true)
            notificationChannel.lightColor = Color.RED
            notificationChannel.enableVibration(true)
            notificationChannel.description = "Time for breakfast!"

            val notificationManager = requireActivity().getSystemService(
                NotificationManager::class.java
            )
            notificationManager.createNotificationChannel(notificationChannel)

        } else {
            Log.d(TAG, "VERSION.SDK_INT < O")
            Toast.makeText(context, "VERSION.SDK_INT < O", Toast.LENGTH_SHORT).show()
        }

        // Step 1.6 END create a channel

    }

    companion object {
        private const val TAG = "EggTimerFragment"
        fun newInstance() = EggTimerFragment()
    }
}

Add a New Notification

AlarmReceiver

Add Notifications to Your App

Create another notification using AlarmReceiver

Create an AlarmReceiver class that inherits BroadcastReceiver
Get an instance of NotificationManager by calling getSystemService & call sendNotification on it

package com.example.android.eggtimernotifications.receiver

import android.app.NotificationManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.widget.Toast
import androidx.core.content.ContextCompat
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.util.sendNotification

class AlarmReceiver: BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        // Step 1.10 remove toast (since we're now sending a notification for the same)
        // Toast.makeText(context, context.getText(R.string.eggs_ready), Toast.LENGTH_SHORT).show()

        // TODO: Step 1.9 add call to sendNotification
        val notificationManager = ContextCompat.getSystemService(
            context,
            NotificationManager::class.java
        ) as NotificationManager

                notificationManager.sendNotification(
            context.getText(R.string.eggs_ready).toString(),
            context
        )

    }

}

Go Back to the App from the Notification using PendingIntent

NotificationUtils

Add a Content Intent

Navigate back to the app on tapping the notification

Create an intent
Create a pending intent
Pass the pending intent to the notification by calling setContentIntent on the NotificationBuilder
For the notification to dismiss itself as it takes you to the app when you tap on the it, set setAutoCancel to true

package com.example.android.eggtimernotifications.util

import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.BitmapFactory
import androidx.core.app.NotificationCompat
import com.example.android.eggtimernotifications.MainActivity
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.receiver.SnoozeReceiver

// Notification ID.
private val NOTIFICATION_ID = 0
private val REQUEST_CODE = 0
private val FLAGS = 0

// Step 1.1 extension function to send messages (GIVEN)
/**
 * Builds and delivers the notification.
 *
 * @param context, activity context.
 */
fun NotificationManager.sendNotification(messageBody: String, applicationContext: Context) {
    // Create the content intent for the notification, which launches
    // this activity
    // Step 1.11 create intent
    val contentIntent = Intent(applicationContext, MainActivity::class.java)

    // Step 1.12 create PendingIntent
    val contentPendingIntent = PendingIntent.getActivity(
        applicationContext,
        NOTIFICATION_ID,
        contentIntent,
        PendingIntent.FLAG_UPDATE_CURRENT
    )

    // TODO: Step 2.0 add style

    // TODO: Step 2.2 add snooze action

    // Step 1.2 get an instance of NotificationCompat.Builder
    // Build the notification
    val builder = NotificationCompat.Builder(
        applicationContext,
        applicationContext.getString(R.string.egg_notification_channel_id)
    )

    // TODO: Step 1.8 use the new 'breakfast' notification channel

    // Step 1.3 set title, text and icon to builder
        .setSmallIcon(R.drawable.cooked_egg)
        .setContentTitle(applicationContext
            .getString(R.string.notification_title))
        .setContentText(messageBody)

    // Step 1.13 set content intent
        .setContentIntent(contentPendingIntent)
        .setAutoCancel(true)

        // TODO: Step 2.1 add style to builder

        // TODO: Step 2.3 add snooze action

        // TODO: Step 2.5 set priority

    // Step 1.4 call notify
    notify(NOTIFICATION_ID, builder.build())
}

// TODO: Step 1.14 Cancel all notifications

Clear the Previous Notifications using cancelAll

NotificationUtils, EggTimerViewModel

Cancel the Notification

Create an extension fun cancelNotifications
- Add an extension fun on NotificationManager that calls cancelAll
NotificationUtils
```
funNotificationManager.cancelNotifications() {
    cancelAll()
}
```
Call the extension fun cancelNotifications in startTimer fun

EggTimerViewModel
```
notificationManager.cancelNotifications()
```

Styling Your Notification

NotificationUtils

Style your Notification in BigPictureStyle

Load the image from resources using the BitmapFactory
Create a new BigPictureStyle bigPicStyle & set your image
For the large icon to go away when the notification is expanded, set the bigLargeIcon to null
Set the new style bigPicStyle to the NotificationBuilder
For the image to be displayed as a smaller icon when the notification is collapsed, set your image as setLargeIcon on the builder

package com.example.android.eggtimernotifications.util

import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.BitmapFactory
import androidx.core.app.NotificationCompat
import com.example.android.eggtimernotifications.MainActivity
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.receiver.SnoozeReceiver

// Notification ID.
private const val NOTIFICATION_ID = 0
private const val REQUEST_CODE = 0
private const val FLAGS = 0

// Step 1.1 extension function to send messages (GIVEN)
/**
 * Builds and delivers the notification.
 *
 * @param context, activity context.
 */
fun NotificationManager.sendNotification(messageBody: String, applicationContext: Context) {
    // Create the content intent for the notification, which launches
    // this activity
    // Step 1.11 create intent
    val contentIntent = Intent(applicationContext, MainActivity::class.java)

    // Step 1.12 create PendingIntent
    val contentPendingIntent = PendingIntent.getActivity(
        applicationContext,
        NOTIFICATION_ID,
        contentIntent,
        PendingIntent.FLAG_UPDATE_CURRENT
    )

    // Step 2.0 add style
    val eggImage =  BitmapFactory.decodeResource(
            applicationContext.resources,
            R.drawable.cooked_egg
    )

    val bigPicStyle = NotificationCompat.BigPictureStyle()
            .bigPicture(eggImage)
            .bigLargeIcon(null)

    // TODO: Step 2.2 add snooze action

    // Step 1.2 get an instance of NotificationCompat.Builder
    // Build the notification
    val builder = NotificationCompat.Builder(
        applicationContext,
        applicationContext.getString(R.string.egg_notification_channel_id)
    )

    // TODO: Step 1.8 use the new 'breakfast' notification channel

    // Step 1.3 set title, text and icon to builder
        .setSmallIcon(R.drawable.cooked_egg)
        .setContentTitle(applicationContext
            .getString(R.string.notification_title))
        .setContentText(messageBody)

    // Step 1.13 set content intent
        .setContentIntent(contentPendingIntent)
        .setAutoCancel(true)

    // Step 2.1 add style to builder
            .setStyle(bigPicStyle)
            .setLargeIcon(eggImage)

    // TODO: Step 2.3 add snooze action

    // TODO: Step 2.5 set priority

    // TODO: Step 1.4 call notify
    notify(NOTIFICATION_ID, builder.build())
}

// Step 1.14 Cancel all notifications
fun NotificationManager.cancelNotifications() {
    cancelAll()
}

Add Snooze Action

SnoozeReceiver, NotificationUtils

Schedule a new notification & remove the snoozed one

Get an instance of NotificationManager

package com.example.android.eggtimernotifications.receiver

import android.app.AlarmManager
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.os.SystemClock
import android.text.format.DateUtils
import androidx.core.app.AlarmManagerCompat
import androidx.core.content.ContextCompat

class SnoozeReceiver: BroadcastReceiver() {
    private val REQUEST_CODE = 0

    override fun onReceive(context: Context, intent: Intent) {
        val triggerTime = SystemClock.elapsedRealtime() + DateUtils.MINUTE_IN_MILLIS

        val notifyIntent = Intent(context, AlarmReceiver::class.java)
        val notifyPendingIntent = PendingIntent.getBroadcast(
            context,
            REQUEST_CODE,
            notifyIntent,
            PendingIntent.FLAG_UPDATE_CURRENT
        )

        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
        AlarmManagerCompat.setExactAndAllowWhileIdle(
            alarmManager,
            AlarmManager.ELAPSED_REALTIME_WAKEUP,
            triggerTime,
            notifyPendingIntent
        )

        val notificationManager = ContextCompat.getSystemService(
                context,
                NotificationManager::class.java
        ) as NotificationManager
        notificationManager.cancelAll()
    }

}

Set up a new alarm to post a new notification after 60 secs when the snooze button is tapped by the user by using a PendingIntent

Create intent
Create a PendingIntent
Call the addAction fun on the NotificationBuilder

package com.example.android.eggtimernotifications.util

import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.BitmapFactory
import androidx.core.app.NotificationCompat
import com.example.android.eggtimernotifications.MainActivity
import com.example.android.eggtimernotifications.R
import com.example.android.eggtimernotifications.receiver.SnoozeReceiver

// Notification ID.
private const val NOTIFICATION_ID = 0
private const val REQUEST_CODE = 0
private const val FLAGS = 0

// Step 1.1 extension function to send messages (GIVEN)
/**
 * Builds and delivers the notification.
 *
 * @param context, activity context.
 */
fun NotificationManager.sendNotification(messageBody: String, applicationContext: Context) {
    // Create the content intent for the notification, which launches
    // this activity
    // Step 1.11 create intent
    val contentIntent = Intent(applicationContext, MainActivity::class.java)

    // Step 1.12 create PendingIntent
    val contentPendingIntent = PendingIntent.getActivity(
        applicationContext,
        NOTIFICATION_ID,
        contentIntent,
        PendingIntent.FLAG_UPDATE_CURRENT
    )

    // Step 2.0 add style
    val eggImage =  BitmapFactory.decodeResource(
            applicationContext.resources,
            R.drawable.cooked_egg
    )

    val bigPicStyle = NotificationCompat.BigPictureStyle()
            .bigPicture(eggImage)
            .bigLargeIcon(null)

    // Step 2.2 add snooze action
    val snoozeIntent = Intent(applicationContext, SnoozeReceiver::class.java)
    val snoozePendingIntent = PendingIntent.getBroadcast(
            applicationContext,
            REQUEST_CODE,
            snoozeIntent,
            FLAGS
    )

    // Step 1.2 get an instance of NotificationCompat.Builder
    // Build the notification
    val builder = NotificationCompat.Builder(
        applicationContext,
        applicationContext.getString(R.string.egg_notification_channel_id)
    )

    // TODO: Step 1.8 use the new 'breakfast' notification channel

    // Step 1.3 set title, text and icon to builder
        .setSmallIcon(R.drawable.cooked_egg)
        .setContentTitle(applicationContext
            .getString(R.string.notification_title))
        .setContentText(messageBody)

    // Step 1.13 set content intent
        .setContentIntent(contentPendingIntent)
        .setAutoCancel(true)

    // Step 2.1 add style to builder
            .setStyle(bigPicStyle)
            .setLargeIcon(eggImage)

    // Step 2.3 add snooze action
            .addAction(
                    R.drawable.egg_icon,
                    applicationContext.getString(R.string.snooze),
                    snoozePendingIntent
            )

    // TODO: Step 2.5 set priority

    // Step 1.4 call notify
    notify(NOTIFICATION_ID, builder.build())
}

// Step 1.14 Cancel all notifications
fun NotificationManager.cancelNotifications() {
    cancelAll()
}

Change Importance

EggTimerFragment, NotificationUtils

Set the picture

// NotificationUtils()

    // Step 2.0 add style
    val eggImage =  BitmapFactory.decodeResource(
            applicationContext.resources,
            R.drawable.cooked_egg
    )

    val bigPicStyle = NotificationCompat.BigPictureStyle()
            .bigPicture(eggImage)
            .bigLargeIcon(null)

**********************************************************************************

    val builder = NotificationCompat.Builder(
        applicationContext,
        applicationContext.getString(R.string.egg_notification_channel_id)
    )
                        ...
    // Step 2.1 add style to builder
            .setStyle(bigPicStyle)
            .setLargeIcon(eggImage)

Change importance from low to high

NotificationManager → IMPORTANCE

...

class EggTimerFragment : Fragment() {

    ...

    private fun createChannel(channelId: String, channelName: String) {
        // Step 1.6 START create a channel
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val notificationChannel = NotificationChannel(
                channelId,
                channelName,
                // Change importance
                NotificationManager.IMPORTANCE_HIGH
            )

            notificationChannel.enableLights(true)
            notificationChannel.lightColor = Color.RED
            notificationChannel.enableVibration(true)
            notificationChannel.description = "Time for breakfast!"

            val notificationManager = requireActivity().getSystemService(
                NotificationManager::class.java
            )
            notificationManager.createNotificationChannel(notificationChannel)

        } else {
            Log.d(TAG, "VERSION.SDK_INT < O")
            Toast.makeText(context, "VERSION.SDK_INT < O", Toast.LENGTH_SHORT).show()
        }

        // Step 1.6 END create a channel

    }

    ...
}

Add PRIORITY_HIGH to notification builder object

To support devices running API level 25 or lower, you must call setPriority for each notification, using a constant from the NotificationCompat class. To fix this, we're doing the above.

// *NotificationUtils.kt*

fun NotificationManager.sendNotification(messageBody: String, applicationContext: Context) {
    ...

    // Step 1.2 get an instance of NotificationCompat.Builder
    // Build the notification
    val builder = NotificationCompat.Builder(
        applicationContext,
        applicationContext.getString(R.string.egg_notification_channel_id)
    )

    ...

    // Step 2.5 set priority
            .setPriority(NotificationCompat.PRIORITY_HIGH)

      ...
}

...

Notification Badges

EggTimerFragment

Disable badge

Set setShowBadge to false on the NotificationChannel obj.

// *EggTimerFragment.kt*

private fun createChannel(channelId: String, channelName: String) {
        // Step 1.6 START create a channel
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val notificationChannel = NotificationChannel(
                channelId,
                channelName,
                // Change importance
                NotificationManager.IMPORTANCE_HIGH
            )
            // Step 2.6 Disable badges for this channel
                    .apply {
                        setShowBadge(false)
                    }
                        ...
                }
}

DEV Community: Chitranshi Srivastava

W1 D2: Fetching & Saving User's Current Location 👤📍

Week 1 🗺️

Day 2: Fetching & Saving User's Current Location

Prepare to get the user's device location

Get the location of the Android device and position the map

Save the map's state

W1 D1: Adding a Google Map 🗺️💗

Week 1 🗺️

Day 1: Add a Google Map to Your App

Create a Google Maps project

Create a new project on Google Cloud

Add the API key to your app

Read this if you aren't yet creating Custom Text widgets!

How to 'Properly' Choose & Change the App Icon of Your Android App

Choose your App Icon

IS RELATED to your App Idea

Pick a SIMPLE & UNIQUE Design.

Keep it BRIGHT & HIGHLIGHTED

A/B Testing

Change your App Icon

Resize the new image

Change the app logo in the drawable

Delete all the mipmap folders (6, most probably).

Add a new Image Asset

Creating Notifications in Android with Kotlin

STEPS

Create a Notification

Add a New Notification

Go Back to the App from the Notification using PendingIntent

Clear the Previous Notifications using cancelAll

Styling Your Notification

Add Snooze Action

Change Importance

Notification Badges