feat: allow enabling screen-off functionality on Android

the call will fail on iOS

Author: holzgeist

android/src/main/kotlin/dev/jeremyko/proximity_sensor/ProximitySensorPlugin.kt

@@ -3,20 +3,40 @@ package dev.jeremyko.proximity_sensor
 
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import io.flutter.plugin.common.MethodChannel.MethodCallHandler
+import io.flutter.plugin.common.MethodChannel.Result
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-class ProximitySensorPlugin: FlutterPlugin  {
-  private lateinit var channel : EventChannel
+class ProximitySensorPlugin: FlutterPlugin, MethodCallHandler  {
+  private lateinit var methodChannel: MethodChannel
+  private lateinit var eventChannel : EventChannel
   private lateinit var streamHandler : ProximityStreamHandler
 
   override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
-    channel = EventChannel(flutterPluginBinding.binaryMessenger, "proximity_sensor")
+    methodChannel = MethodChannel(flutterPluginBinding.binaryMessenger, "proximity_sensor_enable")
+    methodChannel.setMethodCallHandler(this)
+
+    eventChannel = EventChannel(flutterPluginBinding.binaryMessenger, "proximity_sensor")
     streamHandler = ProximityStreamHandler( flutterPluginBinding.applicationContext)
-    channel.setStreamHandler(streamHandler)
+    eventChannel.setStreamHandler(streamHandler)
   }
 
   override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-    channel.setStreamHandler(null)
+    eventChannel.setStreamHandler(null)
+  }
+
+  override fun onMethodCall(call: MethodCall, result: Result) {
+    if (call.method == "enableProximityScreenOff") {
+      val enabled: Boolean? = call.argument("enabled")
+      if (enabled == null) {
+        result.error("INVALID_ARGUMENTS", "'enabled' cannot be null", null)
+      } else {
+        streamHandler.setScreenOffEnabled(enabled)
+        result.success(null);
+      }
+    }
   }
 }
 

android/src/main/kotlin/dev/jeremyko/proximity_sensor/ProximityStreamHandler.kt

@@ -21,7 +21,8 @@ class ProximityStreamHandler(
     private var proximitySensor: Sensor? = null
 
     private lateinit var powerManager: PowerManager
-    private lateinit var wakeLock: PowerManager.WakeLock
+    private var wakeLock: PowerManager.WakeLock? = null;
+    private var enableScreenOff: Boolean = false;
 
     @SuppressLint("WakelockTimeout")
     override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
@@ -34,18 +35,20 @@ class ProximityStreamHandler(
         powerManager = applicationContext.getSystemService(Context.POWER_SERVICE) as
             PowerManager
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-            wakeLock = powerManager.newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, "dev.jeremyko.proximity_sensor:lock")
-            if (!wakeLock.isHeld) {
-                wakeLock.acquire()
+        if (enableScreenOff && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            if (wakeLock == null) {
+                wakeLock = powerManager.newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, "dev.jeremyko.proximity_sensor:lock")
+            }
+            if (!wakeLock!!.isHeld) {
+                wakeLock!!.acquire()
             }
         }
     }
 
     override fun onCancel(arguments: Any?) {
         sensorManager.unregisterListener(this, proximitySensor)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-            wakeLock.release()
+        if (wakeLock != null && wakeLock!!.isHeld) {
+            wakeLock!!.release()
         }
     }
 
@@ -65,4 +68,11 @@ class ProximityStreamHandler(
     override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
         //do nothing
     }
+
+    fun setScreenOffEnabled(enabled: Boolean) {
+        enableScreenOff = enabled;
+        if (!enabled && wakeLock != null && wakeLock!!.isHeld) {
+            wakeLock!!.release()
+        }
+    }
 }

example/lib/main.dart

@@ -37,6 +37,10 @@ class _MyAppState extends State<MyApp> {
         FlutterError.dumpErrorToConsole(details);
       }
     };
+    await ProximitySensor.setProximityScreenOff(true).onError((error, stackTrace) {
+      print("could not enable screen off functionality");
+      return null;
+    });
     _streamSubscription = ProximitySensor.events.listen((int event) {
       setState(() {
         _isNear = (event > 0) ? true : false;

ios/Classes/SwiftProximitySensorPlugin.swift

@@ -41,11 +41,21 @@ public class SwiftProximityStreamHandler : NSObject,FlutterStreamHandler
 public class SwiftProximitySensorPlugin: NSObject, FlutterPlugin
 {
     static var stream_handler:SwiftProximityStreamHandler = SwiftProximityStreamHandler()
-    static var channel:FlutterEventChannel = FlutterEventChannel()
+    static var eventChannel:FlutterEventChannel = FlutterEventChannel()
+    static var methodChannel:FlutterMethodChannel = FlutterMethodChannel()
 
     public static func register(with registrar: FlutterPluginRegistrar)    {
-        let channel = FlutterEventChannel.init(name: "proximity_sensor", binaryMessenger: registrar.messenger())
-        channel.setStreamHandler(stream_handler)
-     }
+        let eventChannel = FlutterEventChannel.init(name: "proximity_sensor", binaryMessenger: registrar.messenger())
+        eventChannel.setStreamHandler(stream_handler)
+
+        let methodChannel = FlutterMethodChannel(name: "proximity_sensor_enable", binaryMessenger: registrar.messenger())
+
+        let instance = SwiftProximitySensorPlugin()
+        registrar.addMethodCallDelegate(instance, channel: channel)
+    }
+
+  public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+    result(FlutterMethodNotImplemented)
+  }
 }
 

lib/proximity_sensor.dart

@@ -4,9 +4,19 @@ import 'package:flutter/services.dart';
 ////////////////////////////////////////////////////////////////////////////////
 class ProximitySensor {
   static EventChannel _streamChannel = EventChannel('proximity_sensor');
+  static MethodChannel _methodChannel =
+      MethodChannel('proximity_sensor_enable');
+
   static Stream<int> get events {
     return _streamChannel.receiveBroadcastStream().map((event) {
       return event;
     });
   }
+
+  static Future<void> setProximityScreenOff(bool enabled) async {
+    await _methodChannel
+        .invokeMethod<void>('enableProximityScreenOff', <String, dynamic>{
+      'enabled': enabled,
+    });
+  }
 }