Added extra functionality

Author: JDDV

CHANGELOG.md

@@ -1,3 +1,13 @@
+## 4.0.0
+
+* Changed the structure of the native code;
+* Updated the example app;
+* Added `makeGooglePlayServicesAvailable` ;
+* Added `getErrorString`;
+* Added `isUserResolvable`;
+* Added `showErrorNotification`;
+* Added extra tests for the newly added methods.
+
 ## 3.0.2
 
 * Updated `pubspec.yaml` to newer versions of `SDK` and `flutter` and adding `flutter_lints` as a dependency;

android/src/main/java/com/baseflow/googleapiavailability/GoogleApiAvailabilityManager.java

@@ -1,11 +1,16 @@
 package com.baseflow.googleapiavailability;
 
 import android.app.Activity;
+import android.app.Dialog;
+import android.app.PendingIntent;
 import android.content.Context;
 import android.util.Log;
 
+import com.google.android.gms.common.ConnectionResult;
 import com.google.android.gms.common.GoogleApiAvailability;
 
+import java.util.List;
+
 public class GoogleApiAvailabilityManager {
 
     GoogleApiAvailability googleApiAvailability = GoogleApiAvailability.getInstance();
@@ -16,19 +21,34 @@ interface SuccessCallback {
     }
 
     @FunctionalInterface
-    interface MakeGooglePlayServicesAvailable {
+    interface MakeGooglePlayServicesAvailableCallback {
         void onSuccess(boolean makeGooglePlayServicesAvailable);
     }
 
+    @FunctionalInterface
+    interface getErrorStringCallback {
+        void onSuccess(String errorString);
+    }
+
+    @FunctionalInterface
+    interface isUserResolvableCallback {
+        void onSuccess(boolean isUserResolvable);
+    }
+
+    @FunctionalInterface
+    interface showErrorNotificationCallback {
+        void onSuccess(boolean showErrorNotificationCallback);
+    }
+
     @FunctionalInterface
     interface ErrorCallback {
         void onError(String errorCode, String errorDescription);
     }
 
-    void checkPlayServicesAvailability(Boolean showDialog, Context applicationContext, SuccessCallback successCallback, ErrorCallback errorCallback) {
-        if (applicationContext == null) {
-            Log.d(GoogleApiAvailabilityConstants.LOG_TAG, "Context cannot be null.");
-            errorCallback.onError("GoogleApiAvailability.GoogleApiAvailabilityManager", "Android context cannot be null.");
+    void checkPlayServicesAvailability(Boolean showDialog, Activity activity, Context applicationContext, SuccessCallback successCallback, ErrorCallback errorCallback) {
+        if (applicationContext == null || activity == null) {
+            Log.d(GoogleApiAvailabilityConstants.LOG_TAG, "Context and/or activity cannot be null.");
+            errorCallback.onError("GoogleApiAvailability.GoogleApiAvailabilityManager", "Android context and/or activity cannot be null.");
             return;
         }
 
@@ -37,13 +57,13 @@ void checkPlayServicesAvailability(Boolean showDialog, Context applicationContex
 
         if (showDialog != null && showDialog) {
             googleApiAvailability
-                    .showErrorDialogFragment((Activity) applicationContext, connectionResult, GoogleApiAvailabilityConstants.REQUEST_GOOGLE_PLAY_SERVICES);
+                    .showErrorDialogFragment(activity, connectionResult, GoogleApiAvailabilityConstants.REQUEST_GOOGLE_PLAY_SERVICES);
         }
 
         successCallback.onSuccess(GoogleApiAvailabilityConstants.toPlayServiceAvailability(connectionResult));
     }
 
-    void makeGooglePlayServicesAvailable(Activity activity, MakeGooglePlayServicesAvailable successCallback, ErrorCallback errorCallback){
+    void makeGooglePlayServicesAvailable(Activity activity, MakeGooglePlayServicesAvailableCallback successCallback, ErrorCallback errorCallback){
         if (activity == null){
             Log.d(GoogleApiAvailabilityConstants.LOG_TAG, "Activity cannot be null.");
             errorCallback.onError("GoogleApiAvailability.makeGooglePlayServicesAvailable", "Android Activity cannot be null.");
@@ -53,4 +73,52 @@ void makeGooglePlayServicesAvailable(Activity activity, MakeGooglePlayServicesAv
         final boolean status = googleApiAvailability.makeGooglePlayServicesAvailable(activity).isSuccessful();
         successCallback.onSuccess(status);
     }
+
+    void getErrorString(Context applicationContext, getErrorStringCallback successCallback, ErrorCallback errorCallback){
+        if (applicationContext == null){
+            Log.d(GoogleApiAvailabilityConstants.LOG_TAG, "Context cannot be null.");
+            errorCallback.onError("GoogleApiAvailability.getErrorString", "Android context cannot be null.");
+            return;
+        }
+
+        final String errorString = googleApiAvailability.getErrorString(googleApiAvailability.isGooglePlayServicesAvailable(applicationContext));
+
+        successCallback.onSuccess(errorString);
+    }
+
+    void isUserResolvable(Context applicationContext, isUserResolvableCallback successCallback, ErrorCallback errorCallback){
+        if (applicationContext == null){
+            Log.d(GoogleApiAvailabilityConstants.LOG_TAG, "Context cannot be null.");
+            errorCallback.onError("GoogleApiAvailability.isUserResolvable", "Android context cannot be null.");
+            return;
+        }
+
+        final int connectionResult = googleApiAvailability
+                .isGooglePlayServicesAvailable(applicationContext);
+
+        successCallback.onSuccess(googleApiAvailability.isUserResolvableError(connectionResult));
+    }
+
+    void showErrorNotification(Context applicationContext, showErrorNotificationCallback successCallback, ErrorCallback errorCallback){
+        if (applicationContext == null){
+            Log.d(GoogleApiAvailabilityConstants.LOG_TAG, "Context cannot be null.");
+            errorCallback.onError("GoogleApiAvailability.showErrorNotification", "Android context cannot be null.");
+            return;
+        }
+
+        final int connectionResult = googleApiAvailability
+                .isGooglePlayServicesAvailable(applicationContext);
+
+        googleApiAvailability.showErrorNotification(applicationContext, connectionResult);
+
+        if (connectionResult == GoogleApiAvailabilityConstants.GOOGLE_PLAY_SERVICES_AVAILABILITY_SERVICE_DISABLED ||
+            connectionResult == GoogleApiAvailabilityConstants.GOOGLE_PLAY_SERVICES_AVAILABILITY_SERVICE_INVALID ||
+            connectionResult == GoogleApiAvailabilityConstants.GOOGLE_PLAY_SERVICES_AVAILABILITY_SERVICE_MISSING ||
+            connectionResult == GoogleApiAvailabilityConstants.GOOGLE_PLAY_SERVICES_AVAILABILITY_SERVICE_UPDATING ||
+            connectionResult == GoogleApiAvailabilityConstants.GOOGLE_PLAY_SERVICES_AVAILABILITY_SERVICE_VERSION_UPDATE_REQUIRED){
+            successCallback.onSuccess(true);
+        }
+
+        successCallback.onSuccess(false);
+    }
 }

android/src/main/java/com/baseflow/googleapiavailability/MethodCallHandlerImpl.java

@@ -42,7 +42,7 @@ public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
         switch (call.method) {
             case "checkPlayServicesAvailability": {
                 final Boolean showDialog = call.argument("showDialog");
-                googleApiAvailabilityManager.checkPlayServicesAvailability(showDialog, applicationContext, result::success,
+                googleApiAvailabilityManager.checkPlayServicesAvailability(showDialog, activity, applicationContext, result::success,
                         (String errorCode, String errorDescription) -> result.error(
                         errorCode,
                         errorDescription,
@@ -57,6 +57,27 @@ public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
                                 null));
                 break;
             }
+            case "getErrorString": {
+                googleApiAvailabilityManager.getErrorString(applicationContext, result::success,(String errorCode, String errorDescription) -> result.error(
+                        errorCode,
+                        errorDescription,
+                        null));
+                break;
+            }
+            case "isUserResolvable": {
+                googleApiAvailabilityManager.isUserResolvable(applicationContext, result::success,(String errorCode, String errorDescription) -> result.error(
+                        errorCode,
+                        errorDescription,
+                        null));
+                break;
+            }
+            case "showErrorNotification": {
+                googleApiAvailabilityManager.showErrorNotification(applicationContext, result::success,(String errorCode, String errorDescription) -> result.error(
+                        errorCode,
+                        errorDescription,
+                        null));
+                break;
+            }
             default:
                 result.notImplemented();
                 break;

coverage/lcov.info

@@ -0,0 +1,31 @@
+SF:lib\src\google_api_availability.dart
+DA:11,1
+DA:16,1
+DA:28,1
+DA:30,2
+DA:34,2
+DA:36,1
+DA:42,1
+DA:50,1
+DA:51,2
+DA:56,2
+DA:63,0
+DA:64,0
+DA:69,0
+DA:77,0
+DA:78,0
+DA:83,0
+DA:95,0
+DA:97,0
+LF:18
+LH:10
+end_of_record
+SF:lib\src\models\google_play_services_availability.dart
+DA:5,1
+DA:8,0
+DA:13,0
+DA:76,0
+DA:77,0
+LF:5
+LH:1
+end_of_record

example/lib/main.dart

@@ -19,6 +19,9 @@ class _MyAppState extends State<MyApp> {
   GooglePlayServicesAvailability _playStoreAvailability =
       GooglePlayServicesAvailability.unknown;
   bool _madeGooglePlayServiceAvailable = false;
+  String _errorString = "unknown";
+  bool _isUserResolvable = false;
+  bool _errorNotificationShown = false;
 
   // Platform messages are asynchronous, so we initialize in an async method.
   Future<void> checkPlayServices([bool showDialog = false]) async {
@@ -53,9 +56,6 @@ class _MyAppState extends State<MyApp> {
       madeGooglePlayServiceAvailable = false;
     }
 
-    // If the widget was removed from the tree while the asynchronous platform
-    // message was in flight, we want to discard the reply rather than calling
-    // setState to update our non-existent appearance.
     if (!mounted) {
       return;
     }
@@ -65,6 +65,62 @@ class _MyAppState extends State<MyApp> {
     });
   }
 
+  Future<void> getErrorString() async {
+    String errorString;
+
+    try {
+      errorString = await GoogleApiAvailability.instance.getErrorString();
+    } on PlatformException {
+      errorString = "Not available on non Android devices";
+    }
+
+    if (!mounted) {
+      return;
+    }
+
+    setState(() {
+      _errorString = errorString;
+    });
+  }
+
+  Future<void> isUserResolvable() async {
+    bool isUserResolvable;
+
+    try {
+      isUserResolvable =
+          await GoogleApiAvailability.instance.isUserResolvable();
+    } on PlatformException {
+      isUserResolvable = false;
+    }
+
+    if (!mounted) {
+      return;
+    }
+
+    setState(() {
+      _isUserResolvable = isUserResolvable;
+    });
+  }
+
+  Future<void> showErrorNotification() async {
+    bool errorNotificationShown;
+
+    try {
+      errorNotificationShown =
+          await GoogleApiAvailability.instance.showErrorNotification();
+    } on PlatformException {
+      errorNotificationShown = false;
+    }
+
+    if (!mounted) {
+      return;
+    }
+
+    setState(() {
+      _errorNotificationShown = errorNotificationShown;
+    });
+  }
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -79,6 +135,15 @@ class _MyAppState extends State<MyApp> {
                 child: const Text('Get PlayServices availability'),
                 color: Colors.red,
               ),
+              Center(
+                  child: Text(
+                      'Google Play Store status: ${_playStoreAvailability.toString().split('.').last}\n')),
+              MaterialButton(
+                onPressed: () => checkPlayServices(true),
+                child:
+                    const Text('Get PlayServices availability with fix dialog'),
+                color: Colors.redAccent,
+              ),
               Center(
                   child: Text(
                       'Google Play Store status: ${_playStoreAvailability.toString().split('.').last}\n')),
@@ -89,13 +154,29 @@ class _MyAppState extends State<MyApp> {
               ),
               Center(
                   child: Text(
-                      'Make available: $_madeGooglePlayServiceAvailable\n')),
+                      'Made available: $_madeGooglePlayServiceAvailable\n')),
               MaterialButton(
-                onPressed: () => checkPlayServices(true),
-                child:
-                    const Text('Get PlayServices availability with fix dialog'),
-                color: Colors.redAccent,
+                onPressed: () => getErrorString(),
+                child: const Text('Get string of the error code'),
+                color: Colors.red,
+              ),
+              Center(child: Text('Error string: $_errorString\n')),
+              MaterialButton(
+                onPressed: () => isUserResolvable(),
+                child: const Text('Error resolvable by user'),
+                color: Colors.red,
+              ),
+              Center(
+                  child:
+                      Text('Error resolvable by user: $_isUserResolvable\n')),
+              MaterialButton(
+                onPressed: () => showErrorNotification(),
+                child: const Text('Show error notification'),
+                color: Colors.red,
               ),
+              Center(
+                  child: Text(
+                      'Error notification shown: $_errorNotificationShown\n')),
             ],
           )),
     );