How To Write Code To Show System Message Of Turn On Locaiton Service In Ios?

1 of the unique features of mobile applications is location awareness. Mobile users bring their devices with them everywhere, and adding location awareness to your app offers users a more contextual experience.

Code samples

The ApiDemos repository on GitHub includes samples that demonstrate the apply of location on a map:

Java

MyLocationDemoActivity: Using the My Location layer, including runtime permissions
LocationSourceDemoActivity: Using a custom LocationSource
CurrentPlaceDetailsOnMap: Finding the current location of an Android device and displaying details of the place (business or other betoken of interest) at that location. Run into the tutorial on showing current place details on a map.

Kotlin

MyLocationDemoActivity: Using the My Location layer, including runtime permissions
LocationSourceDemoActivity: Using a custom LocationSource
CurrentPlaceDetailsOnMap: Finding the current location of an Android device and displaying details of the identify (business or other point of interest) at that location. Run across the tutorial on showing electric current identify details on a map.

Working with location data

The location information available to an Android device includes the electric 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, yous tin cull between several ways of working with location data:

The My Location layer provides a elementary way to display a device'southward 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 y'all to provide a custom location provider.

Location permissions

If your app needs to access the user's location, y'all must request permission by adding the relevant Android location permissions to your app.

Android offers 2 location permissions: ACCESS_COARSE_LOCATION and ACCESS_FINE_LOCATION. The permission you choose determines the accuracy of the location returned by the API.

android.permission.ACCESS_COARSE_LOCATION – Allows the API to return the device's estimate location. The permission provides a device location estimate from location services, as described in the documentation most estimate location accuracy.
android.permission.ACCESS_FINE_LOCATION – Allows the API to decide as precise a location as possible from the available location providers, including the Global Positioning System (GPS) as well as WiFi and mobile cell data.

Add the permissions to the app manifest

If estimate location is only needed for your app to role, and so add the ACCESS_COARSE_LOCATION permission to your app'southward manifest file:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"     package="com.example.myapp" >   ...   <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>   ... </manifest>

However, if precise location is needed, then add both ACCESS_COARSE_LOCATION and ACCESS_FINE_LOCATION permissions to your app's manifest file:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"     package="com.instance.myapp" >   ...   <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>   ... </manifest>

Request runtime permissions

Android vi.0 (Marshmallow) introduces a new model for handling permissions, which streamlines the process for users when they install and upgrade apps. If your app targets API level 23 or later on, yous can utilise the new permissions model.

If your app supports the new permissions model and the device is running Android 6.0 (Marshmallow) or later, the user does not have to grant whatever permissions when they install or upgrade the app. The app must cheque to see if it has the necessary permission at runtime, and request the permission if it does not have it. The system displays a dialog to the user asking for the permission.

For best user experience, it'south of import to request the permission in context. If location is essential to the functioning of your app, and so y'all should request the location permission at app startup. A skilful manner to practice this is with a warm welcome screen or wizard that educates users most why the permission is required.

If the app requires the permission for but part of its functionality, and so you should request the location permission at the fourth dimension when the app performs the action that requires the permission.

The app must gracefully handle the case where the user does not grant permission. For example, if the permission is needed for a specific feature, the app can disable that feature. If the permission is essential for the app to function, the app tin disable all its functionality and inform the user that they demand to grant the permission.

The following code sample checks for permission using the AndroidX library earlier enabling the My Location layer. It then handles the result of the permission request by implementing the ActivityCompat.OnRequestPermissionsResultCallback from the Back up library:

Coffee

// Copyright 2020 Google LLC // // Licensed nether the Apache License, Version 2.0 (the "License"); // you may not apply this file except in compliance with the License. // Y'all may obtain a re-create of the License at // //      http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable police or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or unsaid. // Come across the License for the specific language governing permissions and // limitations under the License.   package com.case.mapdemo;  import android.Manifest.permission; import android.annotation.SuppressLint; import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener; import com.google.android.gms.maps.GoogleMap.OnMyLocationClickListener; import com.google.android.gms.maps.OnMapReadyCallback; import com.google.android.gms.maps.SupportMapFragment;  import android.Manifest; import android.content.pm.PackageManager; import android.location.Location; import android.os.Bundle;  import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; import android.widget.Toast;  /**  * This demo shows how GMS Location tin exist used to check for changes to the users location.  The "My  * Location" button uses GMS Location to set up the blue dot representing the users location.  * Permission for {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and {@link  * android.Manifest.permission#ACCESS_COARSE_LOCATION} are requested at run fourth dimension. If either  * permission is not granted, the Activity is finished with an error bulletin.  */ public class MyLocationDemoActivity extends AppCompatActivity     implements     OnMyLocationButtonClickListener,     OnMyLocationClickListener,     OnMapReadyCallback,     ActivityCompat.OnRequestPermissionsResultCallback {      /**      * Request code for location permission asking.      *      * @see #onRequestPermissionsResult(int, String[], int[])      */     private static final int LOCATION_PERMISSION_REQUEST_CODE = 1;      /**      * Flag indicating whether a requested permission has been denied later returning in {@link      * #onRequestPermissionsResult(int, String[], int[])}.      */     individual boolean permissionDenied = false;      private GoogleMap map;      @Override     protected void onCreate(Parcel savedInstanceState) {         super.onCreate(savedInstanceState);         setContentView(R.layout.my_location_demo);          SupportMapFragment mapFragment =             (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);         mapFragment.getMapAsync(this);     }      @Override     public void onMapReady(@NonNull GoogleMap googleMap) {         map = googleMap;         map.setOnMyLocationButtonClickListener(this);         map.setOnMyLocationClickListener(this);         enableMyLocation();     }      /**      * Enables the My Location layer if the fine location permission has been granted.      */     @SuppressLint("MissingPermission")     private void enableMyLocation() {         // i. Bank check if permissions are granted, if and then, enable the my location layer         if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)             == PackageManager.PERMISSION_GRANTED             || ContextCompat.checkSelfPermission(this, permission.ACCESS_COARSE_LOCATION)             == PackageManager.PERMISSION_GRANTED) {             map.setMyLocationEnabled(truthful);             return;         }          // 2. Otherwise, request location permissions from the user.         PermissionUtils.requestLocationPermissions(this, LOCATION_PERMISSION_REQUEST_CODE, true);     }      @Override     public boolean onMyLocationButtonClick() {         Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT).show();         // Return false so that we don't consume the event and the default beliefs still occurs         // (the photographic camera animates to the user's current position).         render false;     }      @Override     public void onMyLocationClick(@NonNull Location location) {         Toast.makeText(this, "Electric current location:\north" + location, Toast.LENGTH_LONG).evidence();     }      @Override     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,         @NonNull int[] grantResults) {         if (requestCode != LOCATION_PERMISSION_REQUEST_CODE) {             super.onRequestPermissionsResult(requestCode, permissions, grantResults);             render;         }          if (PermissionUtils.isPermissionGranted(permissions, grantResults,             Manifest.permission.ACCESS_FINE_LOCATION) || PermissionUtils             .isPermissionGranted(permissions, grantResults,                 Manifest.permission.ACCESS_COARSE_LOCATION)) {             // Enable the my location layer if the permission has been granted.             enableMyLocation();         } else {             // Permission was denied. Display an fault bulletin             // Display the missing permission fault dialog when the fragments resume.             permissionDenied = true;         }     }      @Override     protected void onResumeFragments() {         super.onResumeFragments();         if (permissionDenied) {             // Permission was not granted, display error dialog.             showMissingPermissionError();             permissionDenied = faux;         }     }      /**      * Displays a dialog with error message explaining that the location permission is missing.      */     private void showMissingPermissionError() {         PermissionUtils.PermissionDeniedDialog             .newInstance(true).show(getSupportFragmentManager(), "dialog");     }  }

Kotlin

// Copyright 2020 Google LLC // // Licensed under the Apache License, Version two.0 (the "License"); // you lot may not use this file except in compliance with the License. // You may obtain a copy of the License at // //      http://world wide web.apache.org/licenses/LICENSE-ii.0 // // Unless required past applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF Whatever KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.example.kotlindemos  import android.Manifest import android.note.SuppressLint import android.content.pm.PackageManager import android.location.Location import android.os.Parcel import android.widget.Toast import androidx.appcompat.app.AppCompatActivity import androidx.cadre.app.ActivityCompat import androidx.core.app.ActivityCompat.OnRequestPermissionsResultCallback import androidx.core.content.ContextCompat import com.example.kotlindemos.PermissionUtils.PermissionDeniedDialog.Companion.newInstance import com.instance.kotlindemos.PermissionUtils.isPermissionGranted import com.google.android.gms.maps.GoogleMap import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener import com.google.android.gms.maps.GoogleMap.OnMyLocationClickListener import com.google.android.gms.maps.OnMapReadyCallback import com.google.android.gms.maps.SupportMapFragment  /**  * This demo shows how GMS Location tin can be used to check for changes to the users location.  The  * "My Location" push uses GMS Location to set the blue dot representing the users location.  * Permission for [Manifest.permission.ACCESS_FINE_LOCATION] and [Manifest.permission.ACCESS_COARSE_LOCATION]  * are requested at run time. If either permission is non granted, the Activity is finished with an error message.  */ class MyLocationDemoActivity : AppCompatActivity(),     OnMyLocationButtonClickListener,     OnMyLocationClickListener, OnMapReadyCallback,     OnRequestPermissionsResultCallback {     /**      * Flag indicating whether a requested permission has been denied after returning in      * [.onRequestPermissionsResult].      */     private var permissionDenied = fake     private lateinit var map: GoogleMap     override fun onCreate(savedInstanceState: Parcel?) {         super.onCreate(savedInstanceState)         setContentView(R.layout.my_location_demo)         val mapFragment =             supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment?         mapFragment?.getMapAsync(this)     }      override fun onMapReady(googleMap: GoogleMap) {         map = googleMap         googleMap.setOnMyLocationButtonClickListener(this)         googleMap.setOnMyLocationClickListener(this)         enableMyLocation()     }      /**      * Enables the My Location layer if the fine location permission has been granted.      */     @SuppressLint("MissingPermission")     private fun enableMyLocation() {          // i. Check if permissions are granted, if so, enable the my location layer         if (ContextCompat.checkSelfPermission(                 this,                 Manifest.permission.ACCESS_FINE_LOCATION             ) == PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(                 this,                 Manifest.permission.ACCESS_COARSE_LOCATION             ) == PackageManager.PERMISSION_GRANTED         ) {             map.isMyLocationEnabled = true             render         }          // two. If if a permission rationale dialog should be shown         if (ActivityCompat.shouldShowRequestPermissionRationale(                 this,                 Manifest.permission.ACCESS_FINE_LOCATION             ) || ActivityCompat.shouldShowRequestPermissionRationale(                 this,                 Manifest.permission.ACCESS_COARSE_LOCATION             )         ) {             PermissionUtils.RationaleDialog.newInstance(                 LOCATION_PERMISSION_REQUEST_CODE, truthful             ).show(supportFragmentManager, "dialog")             render         }          // iii. Otherwise, asking permission         ActivityCompat.requestPermissions(             this,             arrayOf(                 Manifest.permission.ACCESS_FINE_LOCATION,                 Manifest.permission.ACCESS_COARSE_LOCATION             ),             LOCATION_PERMISSION_REQUEST_CODE         )     }      override fun onMyLocationButtonClick(): Boolean {         Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT)             .prove()         // Return false so that we don't consume the event and the default behavior still occurs         // (the photographic camera animates to the user's current position).         return faux     }      override fun onMyLocationClick(location: Location) {         Toast.makeText(this, "Current location:\n$location", Toast.LENGTH_LONG)             .evidence()     }      override fun onRequestPermissionsResult(         requestCode: Int,         permissions: Array<String>,         grantResults: IntArray     ) {         if (requestCode != LOCATION_PERMISSION_REQUEST_CODE) {             super.onRequestPermissionsResult(                 requestCode,                 permissions,                 grantResults             )             return         }          if (isPermissionGranted(                 permissions,                 grantResults,                 Manifest.permission.ACCESS_FINE_LOCATION             ) || isPermissionGranted(                 permissions,                 grantResults,                 Manifest.permission.ACCESS_COARSE_LOCATION             )         ) {             // Enable the my location layer if the permission has been granted.             enableMyLocation()         } else {             // Permission was denied. Display an error message             // Brandish the missing permission error dialog when the fragments resume.             permissionDenied = true         }     }      override fun onResumeFragments() {         super.onResumeFragments()         if (permissionDenied) {             // Permission was not granted, display error dialog.             showMissingPermissionError()             permissionDenied = imitation         }     }      /**      * Displays a dialog with fault message explaining that the location permission is missing.      */     private fun showMissingPermissionError() {         newInstance(true).testify(supportFragmentManager, "dialog")     }      companion object {         /**          * Request code for location permission request.          *          * @meet .onRequestPermissionsResult          */         individual const val LOCATION_PERMISSION_REQUEST_CODE = 1     } }

The My Location layer

You can use the My Location layer and the My Location button to show your user their current position on the map. Telephone call mMap.setMyLocationEnabled() to enable the My Location layer on the map.

The following sample shows a simple usage of the My Location layer:

Java

                // Copyright 2020 Google LLC // // Licensed under the Apache License, Version two.0 (the "License"); // yous may not employ this file except in compliance with the License. // You may obtain a copy of the License at // //      http://www.apache.org/licenses/LICENSE-two.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or unsaid. // Meet the License for the specific language governing permissions and // limitations under the License.  packet com.google.maps.instance;  import android.annotation.SuppressLint; import android.location.Location; import android.os.Bundle; import android.widget.Toast;  import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity;  import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.maps.OnMapReadyCallback; import com.google.android.gms.maps.SupportMapFragment;  class MyLocationLayerActivity extends AppCompatActivity     implements GoogleMap.OnMyLocationButtonClickListener,     GoogleMap.OnMyLocationClickListener,     OnMapReadyCallback {      @Override     protected void onCreate(Bundle savedInstanceState) {         super.onCreate(savedInstanceState);         setContentView(R.layout.activity_my_location);          SupportMapFragment mapFragment =             (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);         mapFragment.getMapAsync(this);     }      @SuppressLint("MissingPermission")     @Override     public void onMapReady(GoogleMap map) {         // TODO: Before enabling the My Location layer, y'all must request         // location permission from the user. This sample does not include         // a request for location permission.         map.setMyLocationEnabled(true);         map.setOnMyLocationButtonClickListener(this);         map.setOnMyLocationClickListener(this);     }      @Override     public void onMyLocationClick(@NonNull Location location) {         Toast.makeText(this, "Current location:\n" + location, Toast.LENGTH_LONG)             .evidence();     }      @Override     public boolean onMyLocationButtonClick() {         Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT)             .testify();         // Return false so that we don't consume the effect and the default behavior nonetheless occurs         // (the camera animates to the user's current position).         return false;     } }

Kotlin

                // Copyright 2020 Google LLC // // Licensed under the Apache License, Version ii.0 (the "License"); // y'all may not use this file except in compliance with the License. // Yous may obtain a copy of the License at // //      http://www.apache.org/licenses/LICENSE-two.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF Whatsoever KIND, either express or implied. // See the License for the specific language governing permissions and // limitations nether the License.  package com.google.maps.example.kotlin  import android.notation.SuppressLint import android.location.Location import android.bone.Bundle import android.widget.Toast import androidx.appcompat.app.AppCompatActivity import com.google.android.gms.maps.GoogleMap import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener import com.google.android.gms.maps.GoogleMap.OnMyLocationClickListener import com.google.android.gms.maps.OnMapReadyCallback import com.google.android.gms.maps.SupportMapFragment import com.google.maps.instance.R  internal course MyLocationLayerActivity : AppCompatActivity(),     OnMyLocationButtonClickListener,     OnMyLocationClickListener,     OnMapReadyCallback {      override fun onCreate(savedInstanceState: Bundle?) {         super.onCreate(savedInstanceState)         setContentView(R.layout.activity_my_location)         val mapFragment =             supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment         mapFragment.getMapAsync(this)     }      @SuppressLint("MissingPermission")     override fun onMapReady(map: GoogleMap) {         // TODO: Before enabling the My Location layer, you must request         // location permission from the user. This sample does not include         // a request for location permission.         map.isMyLocationEnabled = truthful         map.setOnMyLocationButtonClickListener(this)         map.setOnMyLocationClickListener(this)     }      override fun onMyLocationClick(location: Location) {         Toast.makeText(this, "Current location:\north$location", Toast.LENGTH_LONG)             .prove()     }      override fun onMyLocationButtonClick(): Boolean {         Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT)             .show()         // Return simulated so that we don't consume the event and the default behavior withal occurs         // (the camera animates to the user'south current position).         return imitation     } }

When the My Location layer is enabled, the My Location button appears in the top right corner of the map. When a user clicks the button, the camera centers the map on the current location of the device, if it is known. The location is indicated on the map past a modest blue dot if the device is stationary, or as a chevron if the device is moving.

The following screenshot shows the My Location push at peak correct and the My Location blue dot in the center of the map:

You can forestall the My Location push from appearing by calling UiSettings.setMyLocationButtonEnabled(false).

Your app can reply to the post-obit events:

If the user clicks the My Location button, your app receives an onMyLocationButtonClick() callback from the GoogleMap.OnMyLocationButtonClickListener.
If the user clicks the My Location blueish dot, your app receives an onMyLocationClick() callback from the GoogleMap.OnMyLocationClickListener.

From our Terms of Service

Protect user privacy,
keep them informed

Always inform users of how you will utilise their information, and don't brand it possible to place private users. Go user consent earlier using their location, and allow them revoke consent at any time.

Learn More

The Google Play services Location API

The Google Play services Location API is the preferred method for adding location awareness to your Android application. It includes functionality that lets you:

Determine the device location.
Listen for location changes.
Determine the manner of transportation, if the device is moving.
Create and monitor predefined geographical regions, known as geofences.

The location APIs make it easy for yous to build power efficient, location-aware applications. Like the Maps SDK for Android, the Location API is distributed as part of the Google Play services SDK. For more than information on the Location API, please refer to the Android preparation course Making Your App Location Aware or the Location API Reference. Lawmaking examples are included as role of the Google Play services SDK.