private void DeviceStatus_PowerSourceChanged(object sender, EventArgs e)
 {
     isPlugged = DeviceStatus.PowerSource.ToString().CompareTo("External") == 0;
     PluginResult result = new PluginResult(PluginResult.Status.OK, GetCurrentBatteryStateFormatted());
     result.KeepCallback = true;
     DispatchCommandResult(result);
 }

        public void execute_statment(string options)
        {
            string callbackId;
            options = options.Replace("{}", ""); /// empty objects screw up the Deserializer
            try
            {
                /// query params
                string[] args = JSON.JsonHelper.Deserialize<string[]>(options);
                /// to test maybe is not an integer but a JSONObject
                EntryExecuteStatment entryExecute = JSON.JsonHelper.Deserialize<EntryExecuteStatment>(args[0]);
                string query = entryExecute.query;
                /// to test not sure that's work
                List<object> param = entryExecute.param;
                callbackId = args[1];

                if (mbTilesActions != null && mbTilesActions.isOpen())
                {
                    string result = mbTilesActions.executeStatment(query, param);
                    PluginResult pluginResult = new PluginResult(PluginResult.Status.OK);
                    pluginResult.Message = result;
                    DispatchCommandResult(pluginResult, callbackId);
                }
                else
                {
                    DispatchCommandResult(new PluginResult(PluginResult.Status.IO_EXCEPTION), callbackId);
                }

            }
            catch (Exception)
            {
                DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
            }
        }

 public void close(string options = "")
 {
     if (browser != null)
     {
         Deployment.Current.Dispatcher.BeginInvoke(() =>
         {
             PhoneApplicationFrame frame = Application.Current.RootVisual as PhoneApplicationFrame;
             if (frame != null)
             {
                 PhoneApplicationPage page = frame.Content as PhoneApplicationPage;
                 if (page != null)
                 {
                     Grid grid = page.FindName("LayoutRoot") as Grid;
                     if (grid != null)
                     {
                         grid.Children.Remove(browser);
                     }
                     page.ApplicationBar = null;
                 }
             }
             browser = null;
             string message = "{\"type\":\"exit\"}";
             PluginResult result = new PluginResult(PluginResult.Status.OK, message);
             result.KeepCallback = false;
             this.DispatchCommandResult(result);
         });
     }
 }

        async public void Reclaim(string options)
        {
            PluginResult result;

            if (barcodeScanner != null)
            {
                claimedBarcodeScanner = await barcodeScanner.ClaimScannerAsync();

                if (claimedBarcodeScanner != null)
                {
                    await claimedBarcodeScanner.EnableAsync();
                    claimedBarcodeScanner.DataReceived += DataReceived;

                    result = new PluginResult(PluginResult.Status.NO_RESULT);
                    result.KeepCallback = true;
                }
                else
                {
                    result = new PluginResult(PluginResult.Status.ERROR, "Barcode Scanner could not get claimed");
                }
            }
            else
            {
                result = new PluginResult(PluginResult.Status.ERROR, "Barcode Scanner Object not exists");
            }

            DispatchCommandResult(result);
        }

        public void pickContact(string arguments)
        {
            string[] args = JSON.JsonHelper.Deserialize<string[]>(arguments);

            // Use custom contact picker because WP8 api doesn't provide its' own
            // contact picker, only PhoneNumberChooser or EmailAddressChooserTask
            var task = new ContactPickerTask();
            var desiredFields = JSON.JsonHelper.Deserialize<string[]>(args[0]);

            task.Completed += delegate(Object sender, ContactPickerTask.PickResult e)
                {
                    if (e.TaskResult == TaskResult.OK)
                    {
                        string strResult = e.Contact.ToJson(desiredFields);
                        var result = new PluginResult(PluginResult.Status.OK)
                            {
                                Message = strResult
                            };
                        DispatchCommandResult(result);
                    }
                    if (e.TaskResult == TaskResult.Cancel)
                    {
                        DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Operation cancelled."));
                    }
                };

            task.Show();
        }

        public void start(string options)
        {
            // Register power changed event handler
            DeviceStatus.PowerSourceChanged += powerChanged;

            PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
            result.KeepCallback = true;
            DispatchCommandResult(result);
        }

        public void DispatchCommandResult(PluginResult result)
        {
            if (this.OnCommandResult != null)
            {
                this.OnCommandResult(this, result);
                this.OnCommandResult = null;

            }
        }

 public void start(string options)
 {
     // Register power changed event handler
     DeviceStatus.PowerSourceChanged += powerChanged;
     #if WP8
     battery.RemainingChargePercentChanged += Battery_RemainingChargePercentChanged;
     #endif
     PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
     result.KeepCallback = true;
     DispatchCommandResult(result);
 }

        public void DispatchCommandResult(PluginResult result)
        {
            if (this.OnCommandResult != null)
            {
                this.OnCommandResult(this, result);

                if (!result.KeepCallback)
                {
                    this.Dispose();
                }

            }
        }

        public void Method(string options)
        {
            string upperCase = JSON.JsonHelper.Deserialize<string[]>(options)[0].ToUpper();
            PluginResult result;
            if (upperCase != "")
            {
                result = new PluginResult(PluginResult.Status.OK, upperCase);
            } else
            {
                result = new PluginResult(PluginResult.Status.ERROR, upperCase);
            }

            DispatchCommandResult(result);
        }

        public void download(string options)
        {
            string url;
            string filePath;
            string callbackId;

            try
            {
                url = JSON.JsonHelper.Deserialize<string[]>(options)[0];
                filePath = JSON.JsonHelper.Deserialize<string[]>(options)[1];
                callbackId = JSON.JsonHelper.Deserialize<string[]>(options)[2];
            }
            catch (ArgumentException ex)
            {
                XLog.WriteError("download arguments occur Exception JSON_EXCEPTION " + ex.Message);
                DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
                return;
            }

            string workspace = this.app.GetWorkSpace();
            string target = XUtils.ResolvePath(workspace, filePath);
            if (null == target)
            {
                FileTransfer.FileTransferError error = new FileTransfer.FileTransferError(FILE_NOT_FOUND_ERR, url, filePath, 0);
                PluginResult result = new PluginResult(PluginResult.Status.ERROR, error);
                DispatchCommandResult(result);
                return;
            }

            String abstarget = XUtils.BuildabsPathOnIsolatedStorage(target);
            if (!url.StartsWith("http://"))
            {
                FileTransfer.FileTransferError error = new FileTransfer.FileTransferError(INVALID_URL_ERR, url, filePath, 0);
                PluginResult result = new PluginResult(PluginResult.Status.ERROR, error);
                DispatchCommandResult(result);
                return;
            }

            EventHandler<PluginResult> DispatchPluginResult = delegate(object sender, PluginResult result)
            {
                DispatchCommandResult(result, callbackId);
            };

            FileTransferManager.AddFileTranferTask(url, abstarget, workspace,
                    DispatchPluginResult, COMMAND_DOWNLOAD);
        }

        public void Band(string options)
        {
            string title = "";
            string message = "";

            string[] args  = JSON.JsonHelper.Deserialize<string[]>(options);
            title = args[0].ToString();
            message = args[1].ToString();

            PluginResult result;
            if (title != "" && message != "")
            {
                result = new PluginResult(PluginResult.Status.OK, args);
            } else
            {
                result = new PluginResult(PluginResult.Status.ERROR, args);
            }

            DispatchCommandResult(result);
        }

        /// <summary>
        /// Handler for barcode scanner task.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The scan result.</param>
        private void TaskCompleted(object sender, BarcodeScannerTask.ScanResult e)
        {
            PluginResult result;

            switch (e.TaskResult)
            {
                case TaskResult.OK:
                    result = new PluginResult(PluginResult.Status.OK);
                    result.Message = JsonHelper.Serialize(new BarcodeResult(e.Barcode));
                    break;
                case TaskResult.Cancel:
                    // If scan is cancelled we return PluginResult.Status.OK with Message contains cancelled: true
                    // See plugin docs https://github.com/MSOpenTech/BarcodeScanner#using-the-plugin
                    result = new PluginResult(PluginResult.Status.OK);
                    result.Message = JsonHelper.Serialize(new BarcodeResult());
                    break;
                default:
                    result = new PluginResult(PluginResult.Status.ERROR);
                    break;
            }

            this.DispatchCommandResult(result);
        }

        async public void Enable(string options)
        {
            PluginResult result;

            if (barcodeScanner == null)
            {
                barcodeScanner = await Windows.Devices.PointOfService.BarcodeScanner.GetDefaultAsync();

                if (claimedBarcodeScanner == null)
                {
                    claimedBarcodeScanner = await barcodeScanner.ClaimScannerAsync();

                    if (claimedBarcodeScanner != null)
                    {
                        await claimedBarcodeScanner.EnableAsync();
                        claimedBarcodeScanner.DataReceived += DataReceived;

                        result = new PluginResult(PluginResult.Status.NO_RESULT);
                        result.KeepCallback = true;
                    }
                    else
                    {
                        result = new PluginResult(PluginResult.Status.ERROR, "Barcode Scanner could not get claimed");
                    }
                }
                else
                {
                    result = new PluginResult(PluginResult.Status.ERROR, "Claimed Barcode Scanner Object already there");
                }
            }
            else
            {
                result = new PluginResult(PluginResult.Status.ERROR, "Barcode Scanner Object already there");
            }

            DispatchCommandResult(result);
        }

 void browser_Navigating(object sender, NavigatingEventArgs e)
 {
     string message = "{\"type\":\"loadstart\",\"url\":\"" + e.Uri.OriginalString + "\"}";
     PluginResult result = new PluginResult(PluginResult.Status.OK, message);
     result.KeepCallback = true;
     this.DispatchCommandResult(result, NavigationCallbackId);
 }

 void browser_NavigationFailed(object sender, System.Windows.Navigation.NavigationFailedEventArgs e)
 {
     string message = "{\"type\":\"error\",\"url\":\"" + e.Uri.OriginalString + "\"}";
     PluginResult result = new PluginResult(PluginResult.Status.ERROR, message);
     result.KeepCallback = true;
     this.DispatchCommandResult(result, NavigationCallbackId);
 }

        void browser_Navigated(object sender, System.Windows.Navigation.NavigationEventArgs e)
        {
#if WP8
            if (browser != null)
            {
                backButton.IsEnabled = browser.CanGoBack;
                fwdButton.IsEnabled = browser.CanGoForward;

            }
#endif
            string message = "{\"type\":\"loadstop\", \"url\":\"" + e.Uri.OriginalString + "\"}";
            PluginResult result = new PluginResult(PluginResult.Status.OK, message);
            result.KeepCallback = true;
            this.DispatchCommandResult(result, NavigationCallbackId);
        }

        public void injectScriptCode(string options)
        {
            string[] args = JSON.JsonHelper.Deserialize<string[]>(options);

            bool bCallback = false;
            if (bool.TryParse(args[1], out bCallback)) { };

            string callbackId = args[2];

            if (browser != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    var res = browser.InvokeScript("eval", new string[] { args[0] });

                    if (bCallback)
                    {
                        PluginResult result = new PluginResult(PluginResult.Status.OK, res.ToString());
                        result.KeepCallback = false;
                        this.DispatchCommandResult(result);
                    }

                });
            }
        }

        void compass_CurrentValueChanged(object sender, Microsoft.Devices.Sensors.SensorReadingEventArgs<CompassReading> e)
        {
            this.SetStatus(Running);
            if (compass.IsDataValid)
            {
                // trueHeading :: The heading in degrees from 0 - 359.99 at a single moment in time.
                //  magneticHeading:: The heading relative to the geographic North Pole in degrees 0 - 359.99 at a single moment in time. 
                //  A negative value indicates that the true heading could not be determined.
                // headingAccuracy :: The deviation in degrees between the reported heading and the true heading.
                //rawMagnetometerReading = e.SensorReading.MagnetometerReading;

                //Debug.WriteLine("Compass Result :: " + GetHeadingFormatted(e.SensorReading));

                PluginResult result = new PluginResult(PluginResult.Status.OK, GetHeadingFormatted(e.SensorReading));
                result.KeepCallback = true;

                DispatchCommandResult(result);
            }
        }

        void PushChannel_ShellToastNotificationReceived(object sender, NotificationEventArgs e)
        {
            StringBuilder message = new StringBuilder();
            string relativeUri = string.Empty;

            Toast toast = new Toast();
            if (e.Collection.ContainsKey("wp:Text1"))
            {
                toast.Title = e.Collection["wp:Text1"];
            }
            if (e.Collection.ContainsKey("wp:Text2"))
            {
                toast.Subtitle = e.Collection["wp:Text2"];
            }
            if (e.Collection.ContainsKey("wp:Param"))
            {
                toast.Param = e.Collection["wp:Param"];
            }

            PluginResult result = new PluginResult(PluginResult.Status.OK, toast);

            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                PhoneApplicationFrame frame = Application.Current.RootVisual as PhoneApplicationFrame;
                if (frame != null)
                {
                    PhoneApplicationPage page = frame.Content as PhoneApplicationPage;
                    if (page != null)
                    {
                        CordovaView cView = page.FindName("CordovaView") as CordovaView; // was: PGView
                        if (cView != null)
                        {
                            cView.Browser.Dispatcher.BeginInvoke((ThreadStart)delegate()
                            {
                                try
                                {
                                    cView.Browser.InvokeScript("execScript", this.toastCallback + "(" + result.Message + ")");
                                }
                                catch (Exception ex)
                                {
                                    Debug.WriteLine("ERROR: Exception in InvokeScriptCallback :: " + ex.Message);
                                }

                            });
                        }
                    }
                }
            });
        }