Personal Home Safety Agent

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Devices.Gpio;

namespace SafetyAgent
{
    /// <summary>
    /// Mechanical state of the valve
    /// </summary>
    public enum ValveState
    {
        /// <summary>
        /// Open, water can flow
        /// </summary>
        Open,
        /// <summary>
        /// Was closed but is now opening
        /// </summary>
        Opening,
        /// <summary>
        /// Closed, no water can flow
        /// </summary>
        Closed,
        /// <summary>
        /// Was open but is now closing
        /// </summary>
        Closing,
        /// <summary>
        /// No data
        /// </summary>
        Unknown
    }
    
    public sealed class MotorizedValve 
    {
        private ValveState state = ValveState.Unknown;
        private GpioPin mainWaterValveActivationPin; // When that pin is set to High, the motor turns the valve On
        private GpioPin mainWaterValveDesactivationPin; // When that pin is set to High, the motor turns the valve Off
        private GpioPin mainWaterValveOpenSensorPin; //When that pin is low, it means the valve is open
        private GpioPin mainWaterValveClosedSensorPin; //When that pin is low, it means the valve is closed
        private bool isConnected = false;
        public event EventHandler<ValveStateChangedInfo> ValveStateChanged;

        /// <summary>
        /// Ctor
        /// </summary>
        /// <param name="openActuatorPinId">Pin where the motor is connected</param>
        /// <param name="closeActuatorPinId">Pin where the motor is connected </param>
        /// <param name="openSensorPinId">Pin that goes LOW when the motorized valve is Open</param>
        /// <param name="closedSensorPinId">Pin that goes LOW when the motorized valve is Closed</param>
        public MotorizedValve(int openActuatorPinId, int closeActuatorPinId, int openSensorPinId, int closedSensorPinId)
        {
            // Setup the actuator used to open the valve
            mainWaterValveActivationPin = GpioController.GetDefault().OpenPin(openActuatorPinId);
            mainWaterValveActivationPin.SetDriveMode(GpioPinDriveMode.Output);
            mainWaterValveActivationPin.Write(GpioPinValue.Low);
            // Setup the actuator used to close the valve
            mainWaterValveDesactivationPin = GpioController.GetDefault().OpenPin(closeActuatorPinId);
            mainWaterValveDesactivationPin.SetDriveMode(GpioPinDriveMode.Output);
            mainWaterValveDesactivationPin.Write(GpioPinValue.Low);
            // Setup the sensor used to confirm the valve is open
            mainWaterValveOpenSensorPin = GpioController.GetDefault().OpenPin(openSensorPinId);
            mainWaterValveOpenSensorPin.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 50);  //Ignore changes in value of less than 50ms
            mainWaterValveOpenSensorPin.SetDriveMode(GpioPinDriveMode.Input);
            mainWaterValveOpenSensorPin.ValueChanged += MainWaterValveOpenSensorPin_ValueChanged;
            // Setup the sensor used to confirm the valve is closed
            mainWaterValveClosedSensorPin = GpioController.GetDefault().OpenPin(closedSensorPinId);
            mainWaterValveClosedSensorPin.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 50);  //Ignore changes in value of less than 50ms
            mainWaterValveClosedSensorPin.SetDriveMode(GpioPinDriveMode.Input);
            mainWaterValveClosedSensorPin.ValueChanged += MainWaterValveClosedSensorPin_ValueChanged;
        }

        /// <summary>
        /// Connect to the motorized valve and gets current state
        /// </summary>
        /// <returns></returns>
        public bool Connect()
        {
            state = ValveState.Unknown;
            System.Diagnostics.Debug.WriteLine("Connecting to the motorized valve...");
            // Read current state
            if (mainWaterValveClosedSensorPin.Read() == GpioPinValue.Low && mainWaterValveOpenSensorPin.Read() == GpioPinValue.High)
            {
                State = ValveState.Closed;
                isConnected = true;
                return isConnected;
            }
            if (mainWaterValveClosedSensorPin.Read() == GpioPinValue.High && mainWaterValveOpenSensorPin.Read() == GpioPinValue.Low)
            {
                State = ValveState.Open;
                isConnected = true;
                return isConnected;
            }
            System.Diagnostics.Debug.WriteLine("Unable to connect to the motorized valve and to get a valid status...");
            isConnected = false;
            return isConnected;
        }
        /// <summary>
        /// Raises when there is a change at the motorized valve "open" sensor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void MainWaterValveOpenSensorPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            // System.Diagnostics.Debug.WriteLine("Motorized valve open pin value has changed: " + args.Edge.ToString());
            if (args.Edge == GpioPinEdge.FallingEdge)
            {
                State = ValveState.Open;
                mainWaterValveActivationPin.Write(GpioPinValue.Low);
                mainWaterValveDesactivationPin.Write(GpioPinValue.Low);
            }
        }
        /// <summary>
        /// Raises when there is a change at the motorized valve "closed" sensor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void MainWaterValveClosedSensorPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            // System.Diagnostics.Debug.WriteLine("Motorized valve closed pin value has changed: " + args.Edge.ToString());
            if (args.Edge == GpioPinEdge.FallingEdge)
            {
                State = ValveState.Closed;
                mainWaterValveActivationPin.Write(GpioPinValue.Low);
                mainWaterValveDesactivationPin.Write(GpioPinValue.Low);
            }
        }
        /// <summary>
        /// Get the current mechanical state
        /// </summary>
        public ValveState State
        {
            get
            {
                return state;
            }
            private set
            {
                ValveState previous = state;
                state = value;
                OnValveStateChanged(new ValveStateChangedInfo { previousState = previous, newState = state });
            }
        }
        /// <summary>
        /// When valve state changes
        /// </summary>
        /// <param name="e">Contains previous and current states</param>
        private void OnValveStateChanged(ValveStateChangedInfo e)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("Water valve was {0} and is now {1} at {2}", e.previousState.ToString(),
            //     e.newState.ToString(), DateTime.Now.ToString("dd-MMM-yyyy HH:mm:ss")));

            EventHandler <ValveStateChangedInfo> handler = ValveStateChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }
        /// <summary>
        /// True when the system can interact with the valve sensors
        /// </summary>
        public bool IsConnected
        {
            get
            {
                return isConnected;
            }
        }
        /// <summary>
        /// Turn the valve On
        /// </summary>
        public void Open()
        {
            if (!isConnected)
            {
                throw new Exception("System has no connection with the motorized valve");
            }
            if (state == ValveState.Closed || state == ValveState.Closing || state == ValveState.Unknown)
            {
                System.Diagnostics.Debug.WriteLine("Opening the motorized valve...");
                State = ValveState.Opening;
                mainWaterValveDesactivationPin.Write(GpioPinValue.Low);
                mainWaterValveActivationPin.Write(GpioPinValue.High);
            }
        }
        /// <summary>
        /// Turn the valve Off
        /// </summary>
        public void Close()
        {
            if (!isConnected)
            {
                throw new Exception("System has no connection with the motorized valve");
            }
            if (state == ValveState.Open || state == ValveState.Opening || state == ValveState.Unknown)
            {
                System.Diagnostics.Debug.WriteLine("Closing the motorized valve...");
                State = ValveState.Closing;
                mainWaterValveDesactivationPin.Write(GpioPinValue.High);
                mainWaterValveActivationPin.Write(GpioPinValue.Low);
            }
        }
    }
    /// <summary>
    /// Info regarding previous and current valve state 
    /// </summary>
    public sealed class ValveStateChangedInfo
    {
        public ValveState previousState { get; set; }
        public ValveState newState { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;

namespace NotificationGateway
{
    public class TwilioGateway
    {
        /// <summary>
        /// Sens an SMS using Twilio cloud based service
        /// See https://www.twilio.com/blog/2011/09/using-the-twilio-rest-api-in-windows-8-metro-style-applications.html for a detailed explanation
        /// </summary>
        /// <param name="content"></param>
        public static async void NotifyUsingSMS(string message)
        {
            const string from = "";
            const string to = "15819953112";                  
            var accountSid = "AC0czzzzzzzzzz4fe78c990f";  // see your Twilio account on line
            var authToken = "b9zzzzzzzzzzzzd8b4f276f9"; // see your Twilio account on line
            var targeturi = "https://api.twilio.com/2010-04-01/Accounts/{0}/SMS/Messages";

            var client = new System.Net.Http.HttpClient();
            client.DefaultRequestHeaders.Authorization = CreateBasicAuthenticationHeader(accountSid, authToken);

            var content = new StringContent(string.Format("From={0}&amp;To={1}&amp;Body={2}", from, to, message));
            content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

            var response = await client.PostAsync(string.Format(targeturi, accountSid), content);
            if (response.IsSuccessStatusCode)
            {
                System.Diagnostics.Debug.WriteLine(string.Format("SMS sent to`{0}", to));
            }
            else
            {
                System.Diagnostics.Debug.WriteLine(string.Format("Unable to send SMS. Error is {0} - {1}", response.StatusCode, response.ReasonPhrase));
            }            
        }
        /// <summary>
        /// Twilio uses HTTP Basic Authentication. We need therefore to generate an authentication header
        /// </summary>
        /// <param name="username"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        private static AuthenticationHeaderValue CreateBasicAuthenticationHeader(string username, string password)
        {
            return new AuthenticationHeaderValue("Basic",
                System.Convert.ToBase64String(System.Text.UTF8Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username, password))));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text;
using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;

namespace NotificationGateway
{
    public class AzureGateway
    {
        public static async void NotifyUsingToast(string content)
        {      
            // "Endpoint=sb://iotcontest.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=jSF6Szzzzzzz82r9avDo5PkECg2XVTU0D4Isi/4=";
            string baseAddress = "https://iotcontest.servicebus.windows.net/";
            string queueTopicName = "iotcontestnotificationhub";          
            string token = GetSASToken(baseAddress, "DefaultFullSharedAccessSignature", "jSF6SYX2M1OzzzzzzzzzzzzzzzzzzzVTU0D4Isi/4=");
            string body = string.Format("<toast><visual><binding template=\"ToastText01\"><text id=\"1\">{0}</text></binding></visual></toast>", content);

            Dictionary<string, string> props = new Dictionary<string, string>();
            props.Add("X-WNS-Type", "wns/toast");
            props.Add("ServiceBusNotification-Format", "windows");

            await SendWNSNativeNotification(baseAddress, queueTopicName, token, body, props);                                                  
        }

        /// <summary>
        /// Sends a WNS native notification through a notification hub.  Thanks to http://blogs.recneps.org/?tag=/Service-Bus&page=1 for the hints !
        /// </summary>
        /// <param name="baseAddress">Looks like https://{namespace}.servicebus.windows.net/</param>
        /// <param name="queueTopicName"> Notification Hub name </param>
        /// <param name="token">Token generated as specified in Shared Access Signature Authentication with Service Bus, or Service Bus authentication and authorization with Microsoft Azure Active Directory Access Control (also known as Access Control Service or ACS).</param>
        /// <param name="body">an XML document as specified by WNS. If the notification is of type wns/raw, the body is any text up to 5Kb. </param>
        /// <param name="properties"></param>   
        private static async System.Threading.Tasks.Task<HttpResponseMessage> SendWNSNativeNotification(string baseAddress, string queueTopicName, string token, string body, IDictionary<string, string> properties)
        {
            string fullServiceBusURI = baseAddress + queueTopicName + "/messages" + "?timeout=60&api-version=2015-01";
            return await SendViaHttp(token, body, properties, fullServiceBusURI, HttpMethod.Post);
        }

        /// <summary>
        /// Send notification to Azure REST API over http
        /// </summary>
        /// <param name="token"></param>
        /// <param name="body"></param>
        /// <param name="properties"></param>
        /// <param name="fullAddress"></param>
        /// <param name="httpMethod"></param>
        /// <returns></returns>
        private static async System.Threading.Tasks.Task<HttpResponseMessage> SendViaHttp(string token, string body, IDictionary<string, string> properties, string fullAddress, HttpMethod httpMethod)
        {
            HttpClient webClient = new HttpClient();
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(fullAddress),
                Method = httpMethod,

            };
            webClient.DefaultRequestHeaders.Add("Authorization", token);

            if (properties != null)
            {
                foreach (string property in properties.Keys)
                {
                    request.Headers.Add(property, properties[property]);
                }
            }
            request.Content = new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("", body) });
            return await webClient.SendAsync(request);            
        }

        /// <summary>
        /// Compute a SAS token
        /// The token is constructed from the information extracted from the connection string and the current request that has to be authenticated.
        /// </summary>
        /// <param name="baseAddress">Looks like https://{namespace}.servicebus.windows.net/</param>
        /// <param name="SASKeyName">To send notifications, you usually use "DefaultFullSharedAccessSignature"</param>
        /// <param name="SASKeyValue"></param>
        /// <returns></returns>
        private static string GetSASToken(string baseAddress, string SASKeyName, string SASKeyValue)
        {
            string targetURI = WebUtility.UrlEncode(baseAddress.ToLower());
            TimeSpan fromEpochStart = DateTime.UtcNow - new DateTime(1970, 1, 1);
            string expiry = Convert.ToString((int)fromEpochStart.TotalSeconds + 3600);
            string stringToSign = WebUtility.UrlEncode(baseAddress) + "\n" + expiry;            
            string hash = HmacSha256(SASKeyValue, stringToSign);
            string sasToken = String.Format(CultureInfo.InvariantCulture, "SharedAccessSignature sr={0}&sig={1}&se={2}&skn={3}",
                 targetURI, WebUtility.UrlEncode(hash), expiry, SASKeyName);
            return sasToken;
        }

        public static string HmacSha256(string secretKey, string value)
        {
            // Move strings to buffers.
            var key = CryptographicBuffer.ConvertStringToBinary(secretKey, BinaryStringEncoding.Utf8);
            var msg = CryptographicBuffer.ConvertStringToBinary(value, BinaryStringEncoding.Utf8);

            // Create HMAC.
            var objMacProv = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha256);
            var hash = objMacProv.CreateHash(key);
            hash.Append(msg);
            return CryptographicBuffer.EncodeToBase64String(hash.GetValueAndReset());
        }

    }
}

/// <summary>
        ///  Retrieves the ChannelURI for the app from WNS, and then registers that ChannelURI with your notification hub.
        /// </summary>
        private async void InitNotificationsAsync()
        {
            var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

            var hub = new NotificationHub("iotcontestnotificationhub", "Endpoint=sb://iotcontest.servicebus.windows.net/;SharedAccessKeyName=DefaultListenSharedAccessSignature;SharedAccessKey=Dk4rAV3xxxxxxxxxxxxefvDnKQpIQfR80bVc=");
            var result = await hub.RegisterNativeAsync(channel.Uri);

            // Displays the registration ID so you know it was successful
            if (result.RegistrationId != null)
            {
                var dialog = new MessageDialog("Registration successful: " + result.RegistrationId);
                dialog.Commands.Add(new UICommand("OK"));
                await dialog.ShowAsync();
            }

        }