io.appium.settings 3.5.0 → 3.6.0

package/README.md

@@ -120,6 +120,10 @@ $ adb shell am broadcast -a io.appium.settings.location -n io.appium.settings/.r
 
 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 location update request is going to be send asynchronously every time when the
+current location is requested. By default the cached location value is returned instead.
+
 ## Setting Mock Locations
 
 Start sending scheduled updates (every 2s) for mock location with the specified values by executing:

package/app/build.gradle

@@ -1,13 +1,13 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 29
+    compileSdkVersion 30
 
     defaultConfig {
         minSdkVersion 18
-        targetSdkVersion 29
-        versionCode 31
-        versionName "3.5.0"
+        targetSdkVersion 30
+        versionCode 32
+        versionName "3.6.0"
         applicationId "io.appium.settings"
     }
 
@@ -27,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

@@ -16,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"

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

@@ -27,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;
 
@@ -181,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) {
@@ -201,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

@@ -49,8 +49,6 @@ public class Settings extends Activity {
         setContentView(R.layout.main);
         Log.d(TAG, "Entering the app");
 
-        LocationTracker.getInstance().start(this);
-
         registerSettingsReceivers(Arrays.asList(
                 WiFiConnectionSettingReceiver.class,
                 AnimationSettingReceiver.class,
@@ -68,15 +66,13 @@ public class Settings extends Activity {
         // 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/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

@@ -19,11 +19,10 @@ package io.appium.settings.location;
 import android.content.Intent;
 import android.location.Criteria;
 import android.location.Location;
-import android.os.Build;
 import android.os.SystemClock;
-import android.support.annotation.Nullable;
 import android.util.Log;
 
+import androidx.annotation.Nullable;
 
 public class LocationBuilder {
 
@@ -75,9 +74,7 @@ public class LocationBuilder {
         }
 
         location.setTime(System.currentTimeMillis());
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-            location.setElapsedRealtimeNanos(SystemClock.elapsedRealtimeNanos());
-        }
+        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/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/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.5.0",
+  "version": "3.6.0",
   "description": "App for dealing with Android settings",
   "main": "index.js",
   "scripts": {