If location services are turned off, have the BT chooser prompt the user to turn them on.

chrome/android/java/src/org/chromium/chrome/browser/BluetoothChooserDialog.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser;
 
 import android.Manifest;
 import android.app.Activity;
+import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
-import android.content.pm.PackageManager;
+import android.content.IntentFilter;
+import android.location.LocationManager;
+import android.provider.Settings;
 import android.text.SpannableString;
 import android.text.TextUtils;
 import android.view.View;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.omnibox.OmniboxUrlEmphasizer;
+import org.chromium.chrome.browser.preferences.LocationSettings;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.text.NoUnderlineClickableSpan;
 import org.chromium.ui.text.SpanApplier;
 import org.chromium.ui.text.SpanApplier.SpanInfo;
 
 /**
  * A dialog for picking available Bluetooth devices. This dialog is shown when a website requests to
  * pair with a certain class of Bluetooth devices (e.g. through a bluetooth.requestDevice Javascript
  * call).
+ *
+ * The dialog is shown by create() or show(), and always runs finishDialog() as it's closing.
  */
 public class BluetoothChooserDialog
         implements ItemChooserDialog.ItemSelectedCallback, WindowAndroid.PermissionCallback {
     // These constants match BluetoothChooserAndroid::ShowDiscoveryState, and are used in
     // notifyDiscoveryState().
     static final int DISCOVERY_FAILED_TO_START = 0;
     static final int DISCOVERING = 1;
     static final int DISCOVERY_IDLE = 2;
 
     // Values passed to nativeOnDialogFinished:eventType, and only used in the native function.
@@ skipping 20 matching lines @@
 
     // A pointer back to the native part of the implementation for this dialog.
     long mNativeBluetoothChooserDialogPtr;
 
     // The type of link that is shown within the dialog.
     private enum LinkType {
         EXPLAIN_BLUETOOTH,
         ADAPTER_OFF,
         ADAPTER_OFF_HELP,
         REQUEST_LOCATION_PERMISSION,
+        REQUEST_LOCATION_SERVICES,
         NEED_LOCATION_PERMISSION_HELP,
         RESTART_SEARCH,
     }
 
     /**
      * Creates the BluetoothChooserDialog.
      */
     @VisibleForTesting
     BluetoothChooserDialog(WindowAndroid windowAndroid, String origin, int securityLevel,
             long nativeBluetoothChooserDialogPtr) {
@@ skipping 42 matching lines @@
                 mActivity.getString(R.string.bluetooth_not_seeing_it_idle_some_found),
                 new SpanInfo("<link1>", "</link1>",
                         new BluetoothClickableSpan(LinkType.EXPLAIN_BLUETOOTH, mActivity)),
                 new SpanInfo("<link2>", "</link2>",
                         new BluetoothClickableSpan(LinkType.RESTART_SEARCH, mActivity)));
 
         ItemChooserDialog.ItemChooserLabels labels =
                 new ItemChooserDialog.ItemChooserLabels(title, searching, noneFound,
                         statusIdleNoneFound, statusIdleSomeFound, positiveButton);
         mItemChooserDialog = new ItemChooserDialog(mActivity, this, labels);
+
+        mActivity.registerReceiver(mLocationModeBroadcastReceiver,
+                new IntentFilter(LocationManager.MODE_CHANGED_ACTION));
+    }
+
+    // Called to report the dialog's results back to native code.
+    private void finishDialog(int resultCode, String id) {
+        mActivity.unregisterReceiver(mLocationModeBroadcastReceiver);
+        if (mNativeBluetoothChooserDialogPtr != 0) {
+            nativeOnDialogFinished(mNativeBluetoothChooserDialogPtr, resultCode, id);
+        }
     }
 
     @Override
     public void onItemSelected(String id) {
-        if (mNativeBluetoothChooserDialogPtr != 0) {
-            if (id.isEmpty()) {
-                nativeOnDialogFinished(
-                        mNativeBluetoothChooserDialogPtr, DIALOG_FINISHED_CANCELLED, "");
-            } else {
-                nativeOnDialogFinished(
-                        mNativeBluetoothChooserDialogPtr, DIALOG_FINISHED_SELECTED, id);
-            }
+        if (id.isEmpty()) {
+            finishDialog(DIALOG_FINISHED_CANCELLED, "");
+        } else {
+            finishDialog(DIALOG_FINISHED_SELECTED, id);
         }
     }
 
     @Override
     public void onRequestPermissionsResult(String[] permissions, int[] grantResults) {
-        for (int i = 0; i < grantResults.length; i++) {
+        for (int i = 0; i < permissions.length; i++) {
             if (permissions[i].equals(Manifest.permission.ACCESS_COARSE_LOCATION)) {
-                if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
+                if (checkLocationServicesAndPermission()) {
                     mItemChooserDialog.clear();
                     nativeRestartSearch(mNativeBluetoothChooserDialogPtr);
-                } else {
-                    checkLocationPermission();
                 }
                 return;
             }
         }
         // If the location permission is not present, leave the currently-shown message in place.
     }
 
-    private void checkLocationPermission() {
-        if (mWindowAndroid.hasPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
-                || mWindowAndroid.hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
-            return;
+    @VisibleForTesting
+    final BroadcastReceiver mLocationModeBroadcastReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (LocationManager.MODE_CHANGED_ACTION.equals(intent.getAction())) {
+                if (checkLocationServicesAndPermission()) {
+                    mItemChooserDialog.clear();
+                    nativeRestartSearch(mNativeBluetoothChooserDialogPtr);
+                }
+            }
+        }
+    };
+
+    // Returns true if Location Services is on and Chrome has permission to see the user's location.
+    private boolean checkLocationServicesAndPermission() {
+        final boolean havePermission =
+                mWindowAndroid.hasPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
+                || mWindowAndroid.hasPermission(Manifest.permission.ACCESS_FINE_LOCATION);
+        final boolean locationServicesOn =
+                LocationSettings.getInstance().isSystemLocationSettingEnabled();

[Jeffrey Yasskin, 2016/06/03 01:52:48]

It's a little odd for this chooser to call into preferences.LocationSettings.
Would folks be happy to see me refactor that class into a more general location,
since the concept is used ~6 places in the codebase after this change? If so,
where would you like it? Is it a base/ kind of utility?

[Finnur, 2016/06/03 02:25:04]

These questions are probably more appropriate for Ted. I don't have a strong
opinion, but don't mind seeing this be made more general.

[Ted C, 2016/06/07 00:30:14]

It seems to only be used in preferences right now.  I think it's fine to move it
up somewhere out of preferences, but I'm not sure how much we need to move it to
base.

In particular, we have an internal version of the class and moving it to base
will make that more difficult.

The internal one is under org.chromium.chrome.browser.location so we could
conceivably move it there easier.

+
+        if (!havePermission
+                && !mWindowAndroid.canRequestPermission(
+                           Manifest.permission.ACCESS_COARSE_LOCATION)) {
+            // Immediately close the dialog because the user has asked Chrome not to request the
+            // location permission.
+            finishDialog(DIALOG_FINISHED_DENIED_PERMISSION, "");
+            return false;
         }
 
-        if (!mWindowAndroid.canRequestPermission(Manifest.permission.ACCESS_COARSE_LOCATION)) {
-            if (mNativeBluetoothChooserDialogPtr != 0) {
-                nativeOnDialogFinished(
-                        mNativeBluetoothChooserDialogPtr, DIALOG_FINISHED_DENIED_PERMISSION, "");
-                return;
+        // Compute the message to show the user.
+        final SpanInfo permissionSpan = new SpanInfo("<permission_link>", "</permission_link>",
+                new BluetoothClickableSpan(LinkType.REQUEST_LOCATION_PERMISSION, mActivity));
+        final SpanInfo servicesSpan = new SpanInfo("<services_link>", "</services_link>",
+                new BluetoothClickableSpan(LinkType.REQUEST_LOCATION_SERVICES, mActivity));
+        final SpannableString needLocationMessage;
+        if (havePermission) {
+            if (locationServicesOn) {
+                // We don't need to request anything.
+                return true;
+            } else {
+                needLocationMessage = SpanApplier.applySpans(
+                        mActivity.getString(R.string.bluetooth_need_location_services_on),
+                        servicesSpan);
+            }
+        } else {
+            if (locationServicesOn) {
+                needLocationMessage = SpanApplier.applySpans(
+                        mActivity.getString(R.string.bluetooth_need_location_permission),
+                        permissionSpan);
+            } else {
+                needLocationMessage = SpanApplier.applySpans(
+                        mActivity.getString(
+                                R.string.bluetooth_need_location_permission_and_services_on),
+                        permissionSpan, servicesSpan);
             }
         }
 
-        SpannableString needLocationMessage = SpanApplier.applySpans(
-                mActivity.getString(R.string.bluetooth_need_location_permission),
-                new SpanInfo("<link>", "</link>",
-                        new BluetoothClickableSpan(
-                                     LinkType.REQUEST_LOCATION_PERMISSION, mActivity)));
-
         SpannableString needLocationStatus = SpanApplier.applySpans(
                 mActivity.getString(R.string.bluetooth_need_location_permission_help),
                 new SpanInfo("<link>", "</link>",
                         new BluetoothClickableSpan(
                                      LinkType.NEED_LOCATION_PERMISSION_HELP, mActivity)));
 
         mItemChooserDialog.setErrorState(needLocationMessage, needLocationStatus);
+        return false;
     }
 
     private class BluetoothClickableSpan extends NoUnderlineClickableSpan {
         // The type of link this span represents.
         private LinkType mLinkType;
 
         private Context mContext;
 
         BluetoothClickableSpan(LinkType linkType, Context context) {
             mLinkType = linkType;
@@ skipping 10 matching lines @@
                 case EXPLAIN_BLUETOOTH: {
                     // No need to close the dialog here because
                     // ShowBluetoothOverviewLink will close it.
                     // TODO(ortuno): The BluetoothChooserDialog should dismiss
                     // itself when a new tab is opened or the current tab navigates.
                     // https://crbug.com/588127
                     nativeShowBluetoothOverviewLink(mNativeBluetoothChooserDialogPtr);
                     break;
                 }
                 case ADAPTER_OFF: {
-                    Intent intent = new Intent();
-                    intent.setAction(android.provider.Settings.ACTION_BLUETOOTH_SETTINGS);
-                    mContext.startActivity(intent);
+                    mContext.startActivity(
+                            new Intent(android.provider.Settings.ACTION_BLUETOOTH_SETTINGS));
                     break;
                 }
                 case ADAPTER_OFF_HELP: {
                     nativeShowBluetoothAdapterOffLink(mNativeBluetoothChooserDialogPtr);
                     closeDialog();
                     break;
                 }
                 case REQUEST_LOCATION_PERMISSION: {
                     mWindowAndroid.requestPermissions(
                             new String[] {Manifest.permission.ACCESS_COARSE_LOCATION},
                             BluetoothChooserDialog.this);
                     break;
                 }
+                case REQUEST_LOCATION_SERVICES: {
+                    mContext.startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
+                    break;
+                }
                 case NEED_LOCATION_PERMISSION_HELP: {
                     nativeShowNeedLocationPermissionLink(mNativeBluetoothChooserDialogPtr);
                     closeDialog();
                     break;
                 }
                 case RESTART_SEARCH: {
                     mItemChooserDialog.clear();
                     nativeRestartSearch(mNativeBluetoothChooserDialogPtr);
                     break;
                 }
@@ skipping 64 matching lines @@
         if (mNativeBluetoothChooserDialogPtr != 0) {
             nativeRestartSearch(mNativeBluetoothChooserDialogPtr);
         }
     }
 
     @VisibleForTesting
     @CalledByNative
     void notifyDiscoveryState(int discoveryState) {
         switch (discoveryState) {
             case DISCOVERY_FAILED_TO_START: {
-                // FAILED_TO_START might be caused by a missing Location permission.
+                // FAILED_TO_START might be caused by a missing Location
+                // permission or by the Location service being turned off.
                 // Check, and show a request if so.
-                checkLocationPermission();
+                checkLocationServicesAndPermission();
                 break;
             }
             case DISCOVERY_IDLE: {
                 mItemChooserDialog.setIdleState();
                 break;
             }
             default: {
                 // TODO(jyasskin): Report the new state to the user.
                 break;
             }
         }
     }
 
     @VisibleForTesting
     native void nativeOnDialogFinished(
             long nativeBluetoothChooserAndroid, int eventType, String deviceId);
     @VisibleForTesting
     native void nativeRestartSearch(long nativeBluetoothChooserAndroid);
     // Help links.
     @VisibleForTesting
     native void nativeShowBluetoothOverviewLink(long nativeBluetoothChooserAndroid);
     @VisibleForTesting
     native void nativeShowBluetoothAdapterOffLink(long nativeBluetoothChooserAndroid);
     @VisibleForTesting
     native void nativeShowNeedLocationPermissionLink(long nativeBluetoothChooserAndroid);
 }