io.appium.settings 3.3.0 → 4.0.0

package/README.md

@@ -115,11 +115,23 @@ You can set the [Locale](https://developer.android.com/reference/java/util/Local
 You can retrieve the current geo location by executing:
 
 ```shell
-$ adb shell am broadcast -a io.appium.settings.location -n io.appium.settings/.receivers.LocationInfoReceiver
+$ adb shell am broadcast -a io.appium.settings.location -n io.appium.settings/.receivers.LocationInfoReceiver --ez forceUpdate false
 ```
 
 The first value in the returned `data` string is the current latitude, the second is the longitude and the last one is the altitude. An empty string is returned if the data cannot be retrieved (more details on the failure cause can be found in the logcat output).
 
+Since version 3.6.0 it is also possible to provide `forceUpdate` boolean argument. If it is set to
+`true` then GPS cache refresh request is going to be send asynchronously every time when the
+current location is requested. By default the cached location value is returned instead.
+
+_Note_
+
+The forced GPS cache refresh feature only works if the device under test has
+Google Play Services installed. In case the vanilla LocationManager is used the device API level must be at
+version 30 (Android R) or higher. If none of the conditions above is satisfied then enabling of the `forceUpdate`
+option would have no effect.
+
+
 ## Setting Mock Locations
 
 Start sending scheduled updates (every 2s) for mock location with the specified values by executing:
@@ -134,6 +146,12 @@ $ adb shell am startservice --user 0 -n io.appium.settings/.LocationService --es
 Running the command again stops sending the previously specified location and starts sending updates for the
 new mock location.
 
+Additionally the service allows to provide the following optional parameters to the mocked
+location:
+
+- `speed`: the speed, in meters/second over ground. A float value greater than zero is acceptable.
+- `bearing`: the bearing, in degrees. Bearing is the horizontal direction of travel of this device, and is not related to the device orientation. The input will be wrapped into the range (0.0, 360.0]
+
 Stop sending new mocklocations and clean up everything (remove the mock location providers) by executing:
 ```shell
 $ adb shell am stopservice io.appium.settings/.LocationService
@@ -280,6 +298,23 @@ The example of the resulting data:
 ```
 
 
+## Media Scanning
+
+Since version 3.5 Appium Settings supports broadcast messages handling
+that performs media scanning in response to `io.appium.settings.scan_media`
+intent. This was done due to `android.intent.action.MEDIA_SCANNER_SCAN_FILE` deprecation
+since Android API version 30. To scan the given file or folder for media data simply run:
+
+```bash
+$ adb shell am broadcast -a io.appium.settings.scan_media --es path /sdcard/media
+```
+
+This command will _recursively_ scan all files inside of `/sdcard/media` folder
+and add them to the media library if their MIME types are supported. If the
+file/folder in _path_ does not exist/is not readable or is not provided then an
+error will be returned and the corresponding log message would be written into logs.
+
+
 ## Notes:
 
 * You have to specify the receiver class if the app has never been executed before:

package/app/build.gradle

@@ -1,14 +1,13 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 28
-    buildToolsVersion '28.0.3'
+    compileSdkVersion 30
 
     defaultConfig {
         minSdkVersion 18
-        targetSdkVersion 28
-        versionCode 29
-        versionName "3.3.0"
+        targetSdkVersion 30
+        versionCode 33
+        versionName "4.0.0"
         applicationId "io.appium.settings"
     }
 
@@ -28,7 +27,7 @@ android {
 }
 
 dependencies {
-    implementation 'com.google.android.gms:play-services-location:16.0.0'
+    implementation 'com.google.android.gms:play-services-location:19.0.0'
 }
 
 static def renameAPK(variant) {

package/app/src/main/AndroidManifest.xml

@@ -4,6 +4,7 @@
     package="io.appium.settings">
 
     <uses-permission android:name="android.permission.DISABLE_KEYGUARD" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
@@ -15,6 +16,7 @@
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION"
         tools:ignore="MockLocation,ProtectedPermissions" />
     <uses-permission android:name="android.permission.SET_ANIMATION_SCALE"
@@ -132,5 +134,8 @@
         <receiver android:name=".receivers.SmsReader"
                   android:exported="true"
                   tools:ignore="ExportedReceiver" />
+        <receiver android:name=".receivers.MediaScannerReceiver"
+            android:exported="true"
+            tools:ignore="ExportedReceiver" />
     </application>
 </manifest>

package/app/src/main/java/io/appium/settings/ForegroundService.java

@@ -52,9 +52,11 @@ public class ForegroundService extends Service {
     private void startForegroundService() {
         startForeground(NotificationHelpers.APPIUM_NOTIFICATION_IDENTIFIER,
                 NotificationHelpers.getNotification(this));
+        LocationTracker.getInstance().start(this);
     }
 
     private void stopForegroundService() {
+        LocationTracker.getInstance().stop();
         stopForeground(true);
         stopSelf();
     }

package/app/src/main/java/io/appium/settings/LocationService.java

@@ -20,7 +20,6 @@ import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
-import android.location.Criteria;
 import android.location.Location;
 import android.location.LocationManager;
 import android.location.LocationProvider;
@@ -28,7 +27,8 @@ import android.os.Build;
 import android.os.IBinder;
 import android.util.Log;
 
-import com.google.android.gms.common.api.GoogleApiClient;
+import androidx.annotation.Nullable;
+
 import com.google.android.gms.location.FusedLocationProviderClient;
 import com.google.android.gms.location.LocationServices;
 
@@ -40,22 +40,16 @@ import java.util.TimerTask;
 import io.appium.settings.helpers.NotificationHelpers;
 import io.appium.settings.helpers.PlayServicesHelpers;
 import io.appium.settings.location.FusedLocationProvider;
-import io.appium.settings.location.LocationFactory;
+import io.appium.settings.location.LocationBuilder;
 import io.appium.settings.location.LocationManagerProvider;
 import io.appium.settings.location.MockLocationProvider;
 
 public class LocationService extends Service {
     private static final String TAG = "MOCKED LOCATION SERVICE";
 
-    private static final String LONGITUDE_PARAMETER_KEY = "longitude";
-    private static final String LATITUDE_PARAMETER_KEY = "latitude";
-    private static final String ALTITUDE_PARAMETER_KEY = "altitude";
-    private static final String SPEED_PARAMETER_KEY = "speed";
-
     private static final long UPDATE_INTERVAL_MS = 2000L;
 
     private final List<MockLocationProvider> mockLocationProviders = new LinkedList<>();
-    private final LocationFactory locationFactory = new LocationFactory();
     private final Timer locationUpdatesTimer = new Timer();
     private TimerTask locationUpdateTask;
 
@@ -106,9 +100,7 @@ public class LocationService extends Service {
         }
         Log.i(TAG, "INTENT " + intent.getExtras());
 
-        // update the locationFactory also if the service is already running to mock.
-        updateMockLocationFactory(intent);
-        scheduleLocationUpdate();
+        scheduleLocationUpdate(intent);
     }
 
     private void enableLocationProviders() {
@@ -145,7 +137,7 @@ public class LocationService extends Service {
         Log.d(TAG, String.format("Created mock providers: %s", mockLocationProviders.toString()));
     }
 
-    private void scheduleLocationUpdate() {
+    private void scheduleLocationUpdate(final Intent intent) {
         Log.i(TAG, "Scheduling mock location updates");
 
         // If we run 'startservice' again we should schedule an update right away to avoid a delay
@@ -157,7 +149,7 @@ public class LocationService extends Service {
             @Override
             public void run() {
                 for (MockLocationProvider mockLocationProvider : mockLocationProviders) {
-                    Location location = locationFactory.createLocation(mockLocationProvider.getProviderName(), Criteria.ACCURACY_FINE);
+                    Location location = LocationBuilder.buildFromIntent(intent, mockLocationProvider.getProviderName());
                     Log.d(TAG, String.format("Setting location of '%s' to '%s'", mockLocationProvider.getProviderName(), location));
                     try {
                         mockLocationProvider.setLocation(location);
@@ -172,47 +164,6 @@ public class LocationService extends Service {
         locationUpdatesTimer.schedule(locationUpdateTask, 0, UPDATE_INTERVAL_MS);
     }
 
-    private void updateMockLocationFactory(Intent intent) {
-        double longitude;
-        try {
-            longitude = Double.valueOf(intent.getStringExtra("longitude"));
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException(
-                    String.format("longitude should be a valid number. '%s' is given instead",
-                            intent.getStringExtra(LONGITUDE_PARAMETER_KEY)));
-        }
-        double latitude;
-        try {
-            latitude = Double.valueOf(intent.getStringExtra("latitude"));
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException(
-                    String.format("latitude should be a valid number. '%s' is given instead",
-                            intent.getStringExtra(LATITUDE_PARAMETER_KEY)));
-        }
-        double altitude = 0.0;
-        try {
-            if (intent.hasExtra(ALTITUDE_PARAMETER_KEY)) {
-                altitude = Double.valueOf(intent.getStringExtra(ALTITUDE_PARAMETER_KEY));
-            }
-        } catch (NumberFormatException e) {
-            Log.e(TAG, String.format("altitude should be a valid number. '%s' is given instead",
-                    intent.getStringExtra(ALTITUDE_PARAMETER_KEY)));
-        }
-        try {
-            if (intent.hasExtra(SPEED_PARAMETER_KEY)) {
-                float speed = Float.valueOf(intent.getStringExtra(SPEED_PARAMETER_KEY));
-
-                locationFactory.setLocation(latitude, longitude, altitude, speed);
-                return;
-            }
-        } catch (NumberFormatException e) {
-            Log.e(TAG, String.format("speed should be a valid number larger then 0.0. '%s' is given instead",
-                    intent.getStringExtra(SPEED_PARAMETER_KEY)));
-        }
-
-        locationFactory.setLocation(latitude, longitude, altitude);
-    }
-
     private List<MockLocationProvider> createMockProviders(LocationManager locationManager) {
         List<String> providers = locationManager.getAllProviders();
         List<MockLocationProvider> mockProviders = new LinkedList<>();
@@ -231,9 +182,10 @@ public class LocationService extends Service {
         return mockProviders;
     }
 
+    @Nullable
     private MockLocationProvider createLocationManagerMockProvider(LocationManager locationManager, String providerName) {
         LocationProvider provider = locationManager.getProvider(providerName);
-        return createLocationManagerMockProvider(locationManager, provider);
+        return provider == null ? null : createLocationManagerMockProvider(locationManager, provider);
     }
 
     private MockLocationProvider createLocationManagerMockProvider(LocationManager locationManager, LocationProvider locationProvider) {
@@ -251,11 +203,8 @@ public class LocationService extends Service {
     }
 
     private FusedLocationProvider createFusedLocationProvider() {
-        GoogleApiClient googleApiClient = new GoogleApiClient.Builder(this)
-                .addApi(LocationServices.API)
-                .build();
         FusedLocationProviderClient locationProviderClient = LocationServices.getFusedLocationProviderClient(this);
-        return new FusedLocationProvider(googleApiClient, locationProviderClient, this);
+        return new FusedLocationProvider(locationProviderClient, this);
     }
 
     private void finishForegroundSetup() {

package/app/src/main/java/io/appium/settings/LocationTracker.java

@@ -20,32 +20,44 @@ import android.content.Context;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
+import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import android.os.Looper;
 import android.util.Log;
 
-import com.google.android.gms.common.ConnectionResult;
-import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.location.FusedLocationProviderClient;
+import com.google.android.gms.location.LocationCallback;
 import com.google.android.gms.location.LocationRequest;
+import com.google.android.gms.location.LocationResult;
 import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.tasks.CancellationTokenSource;
 
 import io.appium.settings.helpers.PlayServicesHelpers;
 
 import static android.content.Context.LOCATION_SERVICE;
 
-public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
-        GoogleApiClient.OnConnectionFailedListener,
-        com.google.android.gms.location.LocationListener, LocationListener {
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class LocationTracker implements LocationListener {
     private static final String TAG = LocationTracker.class.getSimpleName();
-    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters
-    private static final long LOCATION_UPDATES_INTERVAL = 1000 * 60; // 1 minute
-    private static final long FAST_INTERVAL = 5000; // 5 seconds
+    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 1; // 1 meter
+    private static final long LOCATION_UPDATES_INTERVAL_MS = 1000 * 60; // 1 minute
+    private static final long FAST_INTERVAL_MS = 5000;
 
     private volatile LocationManager mLocationManager;
-    private volatile GoogleApiClient mGoogleApiClient;
+    private volatile FusedLocationProviderClient mFusedLocationProviderClient;
+    private final LocationCallback locationCallback = new LocationCallback() {
+        @Override
+        public void onLocationResult(@NonNull LocationResult locationResult) {
+            Log.d(TAG, "Got a location update from Play Services");
+            mLocation = locationResult.getLastLocation();
+        }
+    };
     private volatile Location mLocation;
-    private volatile boolean isStarted = false;
+    private final AtomicBoolean isStarted = new AtomicBoolean(false);
     private String mLocationProvider;
 
     private static LocationTracker instance = null;
@@ -60,96 +72,84 @@ public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
         return instance;
     }
 
-    @Override
-    public void onLocationChanged(Location location) {
-        if (location != null) {
-            Log.d(TAG, "Got an updated location");
-            mLocation = location;
-        }
+    public boolean isRunning() {
+        return isStarted.get();
     }
 
-    @Override
-    public void onProviderDisabled(String provider) {
+    private void setIsRunning(boolean value) {
+        isStarted.set(value);
     }
 
     @Override
-    public void onProviderEnabled(String provider) {
-    }
+    public void onLocationChanged(@Nullable Location location) {
+        if (location == null) {
+            return;
+        }
 
-    @Override
-    public void onStatusChanged(String provider, int status, Bundle extras) {
+        Log.d(TAG, "Got a location update from Location Manager");
+        mLocation = location;
     }
 
     @Override
-    public void onConnected(@Nullable Bundle bundle) {
-        if (mGoogleApiClient == null) {
-            return;
-        }
-        if (!mGoogleApiClient.isConnected()) {
-            // This should never happen, but it's happening on some phones
-            Log.e(TAG, "Google API is still connecting being inside onConnected callback");
-            mGoogleApiClient = null;
-            return;
-        }
-        LocationRequest locationRequest = new LocationRequest();
-        locationRequest.setPriority(LocationRequest.PRIORITY_LOW_POWER);
-        locationRequest.setInterval(LOCATION_UPDATES_INTERVAL);
-        locationRequest.setFastestInterval(FAST_INTERVAL);
-        try {
-            //noinspection deprecation
-            LocationServices.FusedLocationApi
-                    .requestLocationUpdates(mGoogleApiClient, locationRequest, this);
-            Log.d(TAG, "Google Play Services location provider is connected");
-            return;
-        } catch (SecurityException e) {
-            Log.e(TAG, "Appium Settings has no access to location permission", e);
-        } catch (Exception e) {
-            Log.e(TAG, "Cannot connect to Google location service", e);
-        }
-        stopLocationUpdatesWithPlayServices();
+    public void onProviderDisabled(@NonNull String provider) {
     }
 
     @Override
-    public void onConnectionSuspended(int i) {
+    public void onProviderEnabled(@NonNull String provider) {
     }
 
     @Override
-    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
-        if (mGoogleApiClient == null) {
-            return;
-        }
-
-        Log.e(TAG, String.format("Google Play Services location provider has failed to connect (code %s)",
-                connectionResult.toString()));
-        stopLocationUpdatesWithPlayServices();
+    public void onStatusChanged(String provider, int status, Bundle extras) {
     }
 
     synchronized void start(Context context) {
-        if (isStarted) {
+        if (isRunning()) {
             return;
         }
-        isStarted = true;
+        setIsRunning(true);
 
-        boolean isPlayServicesAvailable = PlayServicesHelpers.isAvailable(context);
-        if (isPlayServicesAvailable) {
+        if (PlayServicesHelpers.isAvailable(context)) {
             initializePlayServices(context);
         } else {
             initializeLocationManager(context);
         }
     }
 
+    synchronized void stop() {
+        if (!isRunning()) {
+            return;
+        }
+
+        try {
+            stopLocationUpdatesWithPlayServices();
+            stopLocationUpdatesWithoutPlayServices();
+        } finally {
+            setIsRunning(false);
+        }
+    }
+
     private void initializePlayServices(Context context) {
-        if (isPlayServicesConnected()) {
+        if (isFusedLocationProviderInitialized()) {
             return;
         }
 
         Log.d(TAG, "Configuring location provider for Google Play Services");
-        mGoogleApiClient = new GoogleApiClient.Builder(context)
-                .addApi(LocationServices.API)
-                .addConnectionCallbacks(this)
-                .addOnConnectionFailedListener(this)
-                .build();
-        mGoogleApiClient.connect();
+        mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(context);
+        LocationRequest locationRequest = LocationRequest.create()
+                .setPriority(LocationRequest.PRIORITY_LOW_POWER)
+                .setInterval(LOCATION_UPDATES_INTERVAL_MS)
+                .setFastestInterval(FAST_INTERVAL_MS);
+        try {
+            mFusedLocationProviderClient.requestLocationUpdates(
+                    locationRequest, locationCallback, Looper.getMainLooper());
+            Log.d(TAG, "Google Play Services location provider is connected");
+            return;
+        } catch (SecurityException e) {
+            Log.e(TAG, "Appium Settings has no access to location permission", e);
+        } catch (Exception e) {
+            Log.e(TAG, "Cannot connect to Google location service", e);
+        }
+        stopLocationUpdatesWithPlayServices();
     }
 
     private void initializeLocationManager(Context context) {
@@ -168,17 +168,16 @@ public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
     }
 
     private void stopLocationUpdatesWithPlayServices() {
-        if (mGoogleApiClient == null) {
+        if (!isFusedLocationProviderInitialized()) {
             return;
         }
 
         Log.d(TAG, "Stopping Google Play Services location provider");
-        if (mGoogleApiClient.isConnected()) {
-            //noinspection deprecation
-            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
-            mGoogleApiClient.disconnect();
+        mFusedLocationProviderClient.removeLocationUpdates(locationCallback);
+        if (mFusedLocationProviderClient.asGoogleApiClient().isConnected()) {
+            mFusedLocationProviderClient.asGoogleApiClient().disconnect();
         }
-        mGoogleApiClient = null;
+        mFusedLocationProviderClient = null;
     }
 
     private void startLocationUpdatesWithoutPlayServices() {
@@ -199,7 +198,7 @@ public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
             try {
                 mLocationManager.requestLocationUpdates(
                         LocationManager.GPS_PROVIDER,
-                        LOCATION_UPDATES_INTERVAL,
+                        LOCATION_UPDATES_INTERVAL_MS,
                         MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                 mLocationProvider = LocationManager.GPS_PROVIDER;
                 Log.d(TAG, "GPS location provider is enabled. Getting FINE location");
@@ -211,7 +210,7 @@ public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
         try {
             mLocationManager.requestLocationUpdates(
                     LocationManager.NETWORK_PROVIDER,
-                    LOCATION_UPDATES_INTERVAL,
+                    LOCATION_UPDATES_INTERVAL_MS,
                     MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
             mLocationProvider = LocationManager.NETWORK_PROVIDER;
             Log.d(TAG, "NETWORK location provider is enabled. Getting COARSE location");
@@ -230,8 +229,8 @@ public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
         mLocationManager = null;
     }
 
-    private boolean isPlayServicesConnected() {
-        return mGoogleApiClient != null && mGoogleApiClient.isConnected();
+    private boolean isFusedLocationProviderInitialized() {
+        return mFusedLocationProviderClient != null;
     }
 
     private boolean isLocationManagerConnected() {
@@ -239,52 +238,76 @@ public class LocationTracker implements GoogleApiClient.ConnectionCallbacks,
     }
 
     @Nullable
-    public synchronized Location getLocation(Context context) {
+    private Location getCachedLocation() {
         if (mLocation != null) {
+            Log.d(TAG, "The cached location has been successfully retrieved");
             return mLocation;
         }
+        Log.d(TAG, "The cached location has not been retrieved");
+        return null;
+    }
 
-        // Make sure the service has been started
-        start(context);
+    public synchronized void forceLocationUpdate(Context context) {
+        if (!isRunning()) {
+            Log.e(TAG, "The location tracker is not running");
+            return;
+        }
 
-        if (isPlayServicesConnected()) {
+        if (isFusedLocationProviderInitialized()) {
             try {
-                mLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
-                if (mLocation == null) {
-                    // If GPS didn't work, try location manager
-                    if (!isLocationManagerConnected()) {
-                        initializeLocationManager(context);
-                    }
-                } else {
-                    // Make sure the fallback is removed after play services connection succeeds
-                    if (isLocationManagerConnected()) {
-                        stopLocationUpdatesWithoutPlayServices();
-                    }
-                    return mLocation;
-                }
+                mFusedLocationProviderClient.getCurrentLocation(
+                        LocationRequest.PRIORITY_HIGH_ACCURACY, new CancellationTokenSource().getToken())
+                        .addOnCompleteListener(t -> {
+                            if (t.isSuccessful()) {
+                                mLocation = t.getResult();
+                                Log.d(TAG, "The current location has been successfully retrieved from " +
+                                        "Play Services");
+                            } else {
+                                Log.w(TAG, "Failed to retrieve the current location from Play Services",
+                                        t.getException());
+                            }
+                        });
             } catch (SecurityException e) {
                 Log.e(TAG, "Appium Settings has no access to location permission", e);
             }
+        } else if (isLocationManagerConnected() && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            try {
+                mLocationManager.getCurrentLocation(mLocationProvider, null,
+                        context.getMainExecutor(), location -> {
+                            mLocation = location;
+                            Log.d(TAG, "The current location has been successfully retrieved " +
+                                    "from Location Manager");
+                        });
+            } catch (SecurityException e) {
+                Log.e(TAG, "Appium Settings has no access to location permission", e);
+            }
+        }
+    }
+
+    @Nullable
+    public synchronized Location getLocation(Context context) {
+        if (!isRunning()) {
+            Log.e(TAG, "The location tracker is not running");
+            return null;
         }
-        if (isLocationManagerConnected() || mGoogleApiClient != null) {
-            // Try fallback to the default provider if Google API is available but is still not connected
-            if (mGoogleApiClient != null && !isLocationManagerConnected()) {
-                Object locationManager = context.getSystemService(LOCATION_SERVICE);
-                if (locationManager != null) {
-                    mLocationManager = (LocationManager) locationManager;
-                    startLocationUpdatesWithoutPlayServices();
-                }
+
+        if (isFusedLocationProviderInitialized()) {
+            Location location = getCachedLocation();
+            if (location != null) {
+                // If Play services worked, make sure location manager is disabled
+                stopLocationUpdatesWithoutPlayServices();
+                return location;
             }
-            if (mLocationManager != null && mLocationProvider != null) {
-                try {
-                    mLocation = mLocationManager.getLastKnownLocation(mLocationProvider);
-                    return mLocation;
-                } catch (SecurityException e) {
-                    Log.e(TAG, String.format("Appium Settings has no access to %s location permission",
-                            mLocationProvider), e);
-                }
+        }
+
+        // If Play services didn't work, try location manager
+        try {
+            if (!isLocationManagerConnected()) {
+                initializeLocationManager(context);
             }
+        } catch (SecurityException e) {
+            Log.e(TAG, "Appium Settings has no access to location permission", e);
         }
-        return null;
+        return isLocationManagerConnected() ? getCachedLocation() : null;
     }
 }

package/app/src/main/java/io/appium/settings/NLService.java

@@ -20,8 +20,10 @@ import android.content.Intent;
 import android.os.IBinder;
 import android.service.notification.NotificationListenerService;
 import android.service.notification.StatusBarNotification;
-import android.support.annotation.Nullable;
 import android.util.Log;
+
+import androidx.annotation.Nullable;
+
 import io.appium.settings.notifications.StoredNotification;
 import io.appium.settings.notifications.StoredNotifications;
 

package/app/src/main/java/io/appium/settings/Settings.java

@@ -24,7 +24,7 @@ import android.os.Bundle;
 import android.os.Handler;
 import android.util.Log;
 
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import io.appium.settings.receivers.AnimationSettingReceiver;
@@ -34,6 +34,7 @@ import io.appium.settings.receivers.DataConnectionSettingReceiver;
 import io.appium.settings.receivers.HasAction;
 import io.appium.settings.receivers.LocaleSettingReceiver;
 import io.appium.settings.receivers.LocationInfoReceiver;
+import io.appium.settings.receivers.MediaScannerReceiver;
 import io.appium.settings.receivers.NotificationsReceiver;
 import io.appium.settings.receivers.SmsReader;
 import io.appium.settings.receivers.UnpairBluetoothDevicesReceiver;
@@ -48,33 +49,30 @@ public class Settings extends Activity {
         setContentView(R.layout.main);
         Log.d(TAG, "Entering the app");
 
-        LocationTracker.getInstance().start(this);
-
-        final List<Class<? extends BroadcastReceiver>> receiverClasses = new ArrayList<>();
-        receiverClasses.add(WiFiConnectionSettingReceiver.class);
-        receiverClasses.add(AnimationSettingReceiver.class);
-        receiverClasses.add(DataConnectionSettingReceiver.class);
-        receiverClasses.add(LocaleSettingReceiver.class);
-        receiverClasses.add(LocationInfoReceiver.class);
-        receiverClasses.add(ClipboardReceiver.class);
-        receiverClasses.add(BluetoothConnectionSettingReceiver.class);
-        receiverClasses.add(UnpairBluetoothDevicesReceiver.class);
-        receiverClasses.add(NotificationsReceiver.class);
-        receiverClasses.add(SmsReader.class);
-        registerSettingsReceivers(receiverClasses);
+        registerSettingsReceivers(Arrays.asList(
+                WiFiConnectionSettingReceiver.class,
+                AnimationSettingReceiver.class,
+                DataConnectionSettingReceiver.class,
+                LocaleSettingReceiver.class,
+                LocationInfoReceiver.class,
+                ClipboardReceiver.class,
+                BluetoothConnectionSettingReceiver.class,
+                UnpairBluetoothDevicesReceiver.class,
+                NotificationsReceiver.class,
+                SmsReader.class,
+                MediaScannerReceiver.class
+        ));
 
         // https://developer.android.com/about/versions/oreo/background-location-limits
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             startForegroundService(ForegroundService.getForegroundServiceIntent(Settings.this));
+        } else {
+            LocationTracker.getInstance().start(this);
         }
 
         Log.d(TAG, "Closing the app");
         Handler handler = new Handler();
-        handler.postDelayed(new Runnable() {
-            public void run() {
-                Settings.this.finish();
-            }
-        }, 1000);
+        handler.postDelayed(Settings.this::finish, 1000);
     }
 
     private void registerSettingsReceivers(List<Class<? extends BroadcastReceiver>> receiverClasses) {

package/app/src/main/java/io/appium/settings/handlers/BluetoothConnectionSettingHandler.java

@@ -16,9 +16,11 @@
 
 package io.appium.settings.handlers;
 
+import android.annotation.SuppressLint;
 import android.bluetooth.BluetoothAdapter;
 import android.content.Context;
 
+@SuppressLint("MissingPermission")
 public class BluetoothConnectionSettingHandler extends AbstractSettingHandler {
 
     private BluetoothAdapter bluetoothAdapter;

package/app/src/main/java/io/appium/settings/helpers/NotificationHelpers.java

@@ -22,13 +22,14 @@ import android.app.NotificationManager;
 import android.content.Context;
 import android.graphics.BitmapFactory;
 import android.os.Build;
-import android.support.annotation.RequiresApi;
-import android.support.v4.app.NotificationCompat;
 
 import io.appium.settings.R;
 
 import static android.content.Context.NOTIFICATION_SERVICE;
 
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationCompat;
+
 public class NotificationHelpers {
     public static final int APPIUM_NOTIFICATION_IDENTIFIER = 1;
     private static final String CHANNEL_ID = "main_channel";

package/app/src/main/java/io/appium/settings/location/FusedLocationProvider.java

@@ -22,11 +22,12 @@ import android.content.Context;
 import android.location.Location;
 import android.util.Log;
 
-import com.google.android.gms.common.api.GoogleApiClient;
 import com.google.android.gms.location.FusedLocationProviderClient;
 
-import static android.content.pm.PackageManager.PERMISSION_GRANTED;
-import static android.support.v4.content.ContextCompat.checkSelfPermission;
+import static androidx.core.content.PermissionChecker.PERMISSION_GRANTED;
+import static androidx.core.content.PermissionChecker.checkSelfPermission;
+
+import androidx.annotation.NonNull;
 
 public class FusedLocationProvider implements MockLocationProvider {
 
@@ -34,12 +35,10 @@ public class FusedLocationProvider implements MockLocationProvider {
 
     private final static String PROVIDER_NAME = "fused";
 
-    private final GoogleApiClient googleApiClient;
     private final FusedLocationProviderClient fusedLocationProviderClient;
     private final Context context;
 
-    public FusedLocationProvider(GoogleApiClient googleApiClient, FusedLocationProviderClient fusedLocationProviderClient, Context context) {
-        this.googleApiClient = googleApiClient;
+    public FusedLocationProvider(FusedLocationProviderClient fusedLocationProviderClient, Context context) {
         this.fusedLocationProviderClient = fusedLocationProviderClient;
         this.context = context;
     }
@@ -55,7 +54,7 @@ public class FusedLocationProvider implements MockLocationProvider {
         if (!hasPermissions()) {
             return;
         }
-        if (!googleApiClient.isConnected()) {
+        if (!fusedLocationProviderClient.asGoogleApiClient().isConnected()) {
             Log.d(TAG, "GoogleApiClient is not connected");
             return;
         }
@@ -68,7 +67,7 @@ public class FusedLocationProvider implements MockLocationProvider {
         if (!hasPermissions()) {
             return;
         }
-        googleApiClient.connect();
+        fusedLocationProviderClient.asGoogleApiClient().connect();
         fusedLocationProviderClient.setMockMode(true);
     }
 
@@ -79,10 +78,11 @@ public class FusedLocationProvider implements MockLocationProvider {
             return;
         }
         fusedLocationProviderClient.setMockMode(false);
-        googleApiClient.disconnect();
+        fusedLocationProviderClient.asGoogleApiClient().disconnect();
     }
 
     @Override
+    @NonNull
     public String toString() {
         return "FusedLocationProvider{" +
                 "name='" + PROVIDER_NAME + '\'' +

package/app/src/main/java/io/appium/settings/location/LocationBuilder.java

@@ -0,0 +1,80 @@
+/*
+  Copyright 2012-present Appium Committers
+  <p>
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  <p>
+  http://www.apache.org/licenses/LICENSE-2.0
+  <p>
+  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 implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+package io.appium.settings.location;
+
+import android.content.Intent;
+import android.location.Criteria;
+import android.location.Location;
+import android.os.SystemClock;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+public class LocationBuilder {
+
+    private static final String TAG = "MOCKED LOCATION BUILDER";
+    private static final String LONGITUDE_PARAMETER_KEY = "longitude";
+    private static final String LATITUDE_PARAMETER_KEY = "latitude";
+    private static final String ALTITUDE_PARAMETER_KEY = "altitude";
+    private static final String SPEED_PARAMETER_KEY = "speed";
+    private static final String BEARING_PARAMETER_KEY = "bearing";
+
+    @Nullable
+    private static Double extractParam(Intent intent, String paramKey) {
+        Double value = null;
+
+        try {
+            if (intent.hasExtra(paramKey)) {
+                value = Double.parseDouble(intent.getStringExtra(paramKey));
+                Log.i(TAG, String.format("Received parameter: %s, value: %s", paramKey, value));
+            }
+        } catch (NumberFormatException e) {
+            Log.e(TAG, String.format("%s should be a valid number. '%s' is given instead",
+                    paramKey, intent.getStringExtra(paramKey)));
+        }
+        return value;
+    }
+
+    public static Location buildFromIntent(Intent intent, String providerName) {
+        Double longitude = extractParam(intent, LONGITUDE_PARAMETER_KEY);
+        Double latitude = extractParam(intent, LATITUDE_PARAMETER_KEY);
+        Double altitude = extractParam(intent, ALTITUDE_PARAMETER_KEY);
+        Double speed = extractParam(intent, SPEED_PARAMETER_KEY);
+        Double bearing = extractParam(intent, BEARING_PARAMETER_KEY);
+        Location location = new Location(providerName);
+        location.setAccuracy(Criteria.ACCURACY_FINE);
+        if (longitude != null) {
+            location.setLongitude(longitude);
+        }
+        if (latitude != null) {
+            location.setLatitude(latitude);
+        }
+        if (altitude != null) {
+            location.setAltitude(altitude);
+        }
+        if (speed != null) {
+            location.setSpeed(speed.floatValue());
+        }
+        if (bearing != null) {
+            location.setBearing(bearing.floatValue());
+        }
+
+        location.setTime(System.currentTimeMillis());
+        location.setElapsedRealtimeNanos(SystemClock.elapsedRealtimeNanos());
+        return location;
+    }
+}

package/app/src/main/java/io/appium/settings/receivers/LocationInfoReceiver.java

@@ -28,8 +28,9 @@ import java.util.Locale;
 import io.appium.settings.LocationTracker;
 
 public class LocationInfoReceiver extends BroadcastReceiver
-    implements HasAction {
+        implements HasAction {
     private static final String TAG = LocationInfoReceiver.class.getSimpleName();
+    private static final String FORCE_UPDATE = "forceUpdate";
 
     private static final String ACTION = "io.appium.settings.location";
 
@@ -41,7 +42,13 @@ public class LocationInfoReceiver extends BroadcastReceiver
     @Override
     public void onReceive(Context context, Intent intent) {
         Log.d(TAG, "Getting current location");
-        final Location location = LocationTracker.getInstance().getLocation(context);
+        LocationTracker tracker = LocationTracker.getInstance();
+        if (intent.hasExtra(FORCE_UPDATE)
+                && intent.getBooleanExtra(FORCE_UPDATE, false)) {
+            Log.d(TAG, "Initiating forced location update");
+            tracker.forceLocationUpdate(context);
+        }
+        final Location location = tracker.getLocation(context);
         if (location != null) {
             setResultCode(Activity.RESULT_OK);
             // Decimal separator is a dot

package/app/src/main/java/io/appium/settings/receivers/MediaScannerReceiver.java

@@ -0,0 +1,91 @@
+/*
+  Copyright 2012-present Appium Committers
+  <p>
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  <p>
+  http://www.apache.org/licenses/LICENSE-2.0
+  <p>
+  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 implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+package io.appium.settings.receivers;
+
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.media.MediaScannerConnection;
+import android.util.Log;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class MediaScannerReceiver extends BroadcastReceiver
+        implements HasAction {
+    private static final String TAG = MediaScannerReceiver.class.getSimpleName();
+    private static final String ACTION = "io.appium.settings.scan_media";
+    private static final String PATH = "path";
+
+    private List<String> fetchFiles(File root) {
+        if (root.isFile()) {
+            return root.canRead()
+                    ? Collections.singletonList(root.toString())
+                    : Collections.emptyList();
+        }
+        File[] items = root.listFiles();
+        if (items == null) {
+            return Collections.emptyList();
+        }
+        List<String> filePaths = new ArrayList<>();
+        for (File item : items) {
+            filePaths.addAll(fetchFiles(item));
+        }
+        return filePaths;
+    }
+
+    /**
+     * Responds to broadcast requests like
+     * am broadcast -a io.appium.settings.scan_media -e path /sdcard/yolo
+     * by scanning all files/folders under the given path
+     */
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Log.d(TAG, "Scanning the requested media");
+        if (!intent.hasExtra(PATH)) {
+            Log.e(TAG, "No path has been provided");
+            setResultCode(Activity.RESULT_CANCELED);
+            setResultData("");
+            return;
+        }
+        File item = new File(intent.getStringExtra(PATH));
+        if (!item.exists()) {
+            Log.e(TAG, String.format("The item at '%s' does not exist", item.toString()));
+            setResultCode(Activity.RESULT_CANCELED);
+            setResultData("");
+            return;
+        }
+        List<String> filePaths = fetchFiles(item);
+        if (filePaths.isEmpty()) {
+            Log.i(TAG, String.format("Found no files to scan at '%s'", item.toString()));
+        } else {
+            MediaScannerConnection.scanFile(context, filePaths.toArray(new String[0]), null, null);
+            Log.i(TAG, String.format("Successfully scanned %s file(s) at '%s'",
+                    filePaths.size(), item.toString()));
+        }
+        setResultCode(Activity.RESULT_OK);
+        setResultData("");
+    }
+
+    @Override
+    public String getAction() {
+        return ACTION;
+    }
+}

package/app/src/main/java/io/appium/settings/receivers/NotificationsReceiver.java

@@ -22,9 +22,11 @@ import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.provider.Settings;
-import android.support.annotation.Nullable;
 import android.text.TextUtils;
 import android.util.Log;
+
+import androidx.annotation.Nullable;
+
 import io.appium.settings.notifications.StoredNotifications;
 import org.json.JSONArray;
 import org.json.JSONException;

package/app/src/main/java/io/appium/settings/receivers/UnpairBluetoothDevicesReceiver.java

@@ -16,6 +16,7 @@
 
 package io.appium.settings.receivers;
 
+import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
@@ -27,6 +28,7 @@ import android.util.Log;
 import java.lang.reflect.InvocationTargetException;
 import java.util.Set;
 
+@SuppressLint("MissingPermission")
 public class UnpairBluetoothDevicesReceiver extends BroadcastReceiver implements HasAction {
     private static final String TAG = UnpairBluetoothDevicesReceiver.class.getSimpleName();
 

package/build.gradle

@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.2'
+        classpath 'com.android.tools.build:gradle:7.0.3'
     }
 }
 

package/gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-all.zip

package/gradle.properties

@@ -0,0 +1,15 @@
+## For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+#
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx1024m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+#
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+#Fri Dec 17 09:25:55 CET 2021
+android.useAndroidX=true
+android.enableJetifier=true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "io.appium.settings",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "description": "App for dealing with Android settings",
   "main": "index.js",
   "scripts": {
@@ -39,7 +39,7 @@
   },
   "homepage": "https://github.com/appium/io.appium.settings",
   "devDependencies": {
-    "appium-gulp-plugins": "^5.0.0",
+    "@appium/gulp-plugins": "^6.0.0",
     "gulp": "^4.0.0"
   }
 }

package/app/src/main/java/io/appium/settings/location/LocationFactory.java

@@ -1,63 +0,0 @@
-/*
-  Copyright 2012-present Appium Committers
-  <p>
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-  <p>
-  http://www.apache.org/licenses/LICENSE-2.0
-  <p>
-  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 implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
- */
-
-package io.appium.settings.location;
-
-import android.location.Location;
-import android.os.Build;
-import android.os.SystemClock;
-
-public class LocationFactory {
-
-    private double latitude;
-    private double longitude;
-    private double altitude;
-    private float speed;
-    private boolean hasSpeed = false;
-
-
-    public synchronized Location createLocation(String providerName, float accuracy) {
-        Location l = new Location(providerName);
-        l.setAccuracy(accuracy);
-
-        l.setLatitude(latitude);
-        l.setLongitude(longitude);
-        l.setAltitude(altitude);
-        if (hasSpeed) {
-            l.setSpeed(speed);
-        }
-        l.setBearing(0);
-
-        l.setTime(System.currentTimeMillis());
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-            l.setElapsedRealtimeNanos(SystemClock.elapsedRealtimeNanos());
-        }
-        return l;
-    }
-
-    public synchronized void setLocation(double latitude, double longitude, double altitude, float speed) {
-        this.setLocation(latitude, longitude, altitude);
-        this.speed = speed;
-        this.hasSpeed = true;
-    }
-
-    public synchronized void setLocation(double latitude, double longitude, double altitude) {
-        this.latitude = latitude;
-        this.longitude = longitude;
-        this.altitude = altitude;
-        this.hasSpeed = false;
-    }
-}