Merge pull request #399 from gustavo-lara-molina/powerMonitor

Power monitor

Author: GregorBiswanger

ElectronNET.API/Electron.cs

@@ -73,5 +73,10 @@ public static class Electron
         /// <c>electronize add HostHook</c>
         /// </summary>
         public static HostHook HostHook { get { return HostHook.Instance; } }
+
+        /// <summary>
+        /// Allows you to execute native Lock and Unlock process.       
+        /// </summary>
+        public static PowerMonitor PowerMonitor { get { return PowerMonitor.Instance; } }
     }
 }

ElectronNET.API/PowerMonitor.cs

@@ -0,0 +1,107 @@
+using ElectronNET.API.Entities;
+using ElectronNET.API.Extensions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Monitor power state changes..
+    /// </summary>
+    public sealed class PowerMonitor
+    {
+           
+
+
+        /// <summary>
+        /// Emitted when the system is about to lock the screen. 
+        /// </summary>
+        public event Action OnLockScreen
+        {
+            add
+            {
+                if (_lockScreen == null)
+                {
+                    BridgeConnector.Socket.On("pm-lock-screen" , () =>
+                    {
+                        _lockScreen();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-lock-screen");
+                }
+                _lockScreen += value;
+            }
+            remove
+            {
+                _lockScreen -= value;
+
+                if (_lockScreen == null)
+                    BridgeConnector.Socket.Off("pm-lock-screen");
+            }
+        }
+
+        private event Action _lockScreen;
+
+        /// <summary>
+        /// Emitted when the system is about to unlock the screen. 
+        /// </summary>
+        public event Action OnUnLockScreen
+        {
+            add
+            {
+                if (_unlockScreen == null)
+                {
+                    BridgeConnector.Socket.On("pm-unlock-screen", () =>
+                    {
+                        _unlockScreen();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-unlock-screen");
+                }
+                _unlockScreen += value;
+            }
+            remove
+            {
+                _unlockScreen -= value;
+
+                if (_unlockScreen == null)
+                    BridgeConnector.Socket.Off("pm-unlock-screen");
+            }
+        }
+
+        private event Action _unlockScreen;
+
+
+
+        private static PowerMonitor _powerMonitor;
+        private static object _syncRoot = new object();
+
+        internal PowerMonitor() { }
+
+        internal static PowerMonitor Instance
+        {
+            get
+            {
+                if (_powerMonitor == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_powerMonitor == null)
+                        {
+                            _powerMonitor = new PowerMonitor();
+                        }
+                    }
+                }
+
+                return _powerMonitor;
+            }
+        }
+
+
+       
+    }
+}

ElectronNET.Host/api/powerMonitor.js

@@ -0,0 +1,16 @@
+import { powerMonitor } from 'electron';
+let electronSocket;
+
+export = (socket: SocketIO.Socket) => {
+    electronSocket = socket;
+    socket.on('register-pm-lock-screen', () => {
+        powerMonitor.on('lock-screen', () => {
+            electronSocket.emit('pm-lock-screen');
+        });
+    });
+    socket.on('register-pm-unlock-screen', () => {
+        powerMonitor.on('unlock-screen', () => {
+            electronSocket.emit('pm-unlock-screen');
+        });
+    });
+};

ElectronNET.Host/api/powerMonitor.js.map

@@ -8,6 +8,7 @@ let io, server, browserWindows, ipc, apiProcess, loadURL;
 let appApi, menu, dialogApi, notification, tray, webContents;
 let globalShortcut, shellApi, screen, clipboard, autoUpdater;
 let commandLine, browserView;
+let powerMonitor;
 let splashScreen, hostHook;
 let mainWindowId;
 
@@ -152,6 +153,7 @@ function startSocketApiBridge(port) {
             delete require.cache[require.resolve('./api/screen')];
             delete require.cache[require.resolve('./api/clipboard')];
             delete require.cache[require.resolve('./api/browserView')];
+            delete require.cache[require.resolve('./api/powerMonitor')];
         });
 
         global['electronsocket'] = socket;
@@ -173,6 +175,7 @@ function startSocketApiBridge(port) {
         screen = require('./api/screen')(socket);
         clipboard = require('./api/clipboard')(socket);
         browserView = require('./api/browserView')(socket);
+        powerMonitor = require('./api/powerMonitor')(socket);
 
 
 

ElectronNET.Host/api/powerMonitor.ts

@@ -1,12 +1,27 @@
 using Microsoft.AspNetCore.Mvc;
+using ElectronNET.API;
+using ElectronNET.API.Entities;
+using System;
 
 namespace ElectronNET.WebApp.Controllers
 {
     public class HomeController : Controller
     {
         public IActionResult Index()
         {
-            return View();
+            if (HybridSupport.IsElectronActive)
+            {
+                Electron.PowerMonitor.OnLockScreen += () =>
+                {
+                    Console.WriteLine("Screen Locked detected from C #");
+                };
+
+                Electron.PowerMonitor.OnUnLockScreen += () =>
+                {
+                    Console.WriteLine("Screen unlocked detected from C # ");
+                };
+            }
+                return View();
         }
     }
 }