/// <summary> /// Add a property to the object. Makes a call to the server to get the value. /// </summary> /// <param name="propertyName">Name of the property (e.g. foo["propertyname"])</param> /// <param name="type">Property type</param> /// <param name="subscribe">True to cause the property to be subscribed to</param> /// <returns></returns> public async Task AddPropertyAsync(string propertyName, PremiseProperty.PremiseType type = PremiseProperty.PremiseType.TypeText, bool subscribe = false) { try { PremiseProperty prop; if (!_properties.TryGetValue(propertyName, out prop)) { _properties[propertyName] = new PremiseProperty(propertyName) { PropertyType = type }; } if (subscribe) { await PremiseServer.Instance.Subscribe(this, propertyName); } // Sadly, premise does not automatically send a update notification upon // a subscription. Thus even for properites where we are using a subscription // we have to block waiting for the initial value. string val = await PremiseServer.Instance.GetValueTaskAsync(Location, propertyName); Debug.WriteLine("got {0} {1} = {2}", Location, propertyName, val); SetMember(propertyName, val, false); HasServerData = true; } catch (Exception) { throw; } }
/// <summary> /// Add a property to the object. Makes a call to the server to get the value. /// </summary> /// <param name="propertyName">Name of the property (e.g. foo["propertyname"])</param> /// <param name="type">Property type</param> /// <param name="subscribe">True to cause the property to be subscribed to</param> /// <returns></returns> public async Task AddPropertyAsync(string propertyName, PremiseProperty.PremiseType type = PremiseProperty.PremiseType.TypeText, bool subscribe = false) { try { PremiseProperty prop = null; if (!_properties.TryGetValue(propertyName, out prop)) { _properties[propertyName] = new PremiseProperty(propertyName) { PropertyType = type }; } //Debug.WriteLine("getting {0} {1}", Location, propertyName); string val = await PremiseServer.Instance.GetValueTaskAsync(Location, propertyName); Debug.WriteLine("got {0} {1} = {2}", Location, propertyName, val.ToString()); this.SetMember(propertyName, val, false); if (subscribe) // BUGBUG: Should we await here? PremiseServer.Instance.Subscribe(this, propertyName); HasServerData = true; } catch (Exception ex) { throw ex; } }
/// <summary> /// Add a property to the object. Makes a call to the server to get the value. /// </summary> /// <param name="propertyName">Name of the property (e.g. foo["propertyname"])</param> /// <param name="initalValue">Initial value for the property (enables reducing UI churn on first load)</param> /// <param name="type">Property type</param> /// <param name="subscribe">True to cause the property to be subscribed to</param> /// <returns></returns> public async Task AddPropertyAsync(string propertyName, object initalValue, PremiseProperty.PremiseType type = PremiseProperty.PremiseType.TypeText, bool subscribe = false) { try { PremiseProperty prop = null; if (!_properties.TryGetValue(propertyName, out prop)) { _properties[propertyName] = new PremiseProperty(propertyName) {PropertyType = type, Value = initalValue}; } AddPropertyAsync(propertyName, type, subscribe); } catch (Exception ex) { throw ex; } }
//public async void SetMemberAsync(String propertyName, object value, bool sendToServer = true) { // PremiseProperty current = null; // if (!_properties.TryGetValue(propertyName, out current)) { // current = new PremiseProperty(propertyName); // } // // Only update value if it changed // if (current.Value == value) return; // current.Value = value; // _properties[propertyName] = current; // OnPropertyChanged(propertyName); // if (sendToServer) { // var server = PremiseServer.Instance; // if (server != null && !String.IsNullOrEmpty(Location)) { // // Spin up a new thread for this to get it off the UI thread (not really needed, probably) // server.SetValueAsync(Location, propertyName, value.ToString()); // } // } //} public void SetMember(String propertyName, object value, bool sendToServer = true) { PremiseProperty current = null; if (!_properties.TryGetValue(propertyName, out current)) { current = new PremiseProperty(propertyName); } // Only update value if it changed if (current.Value == value) return; current.Value = value; _properties[propertyName] = current; OnPropertyChanged(propertyName); if (sendToServer) { Debug.WriteLine("Updating server: {0}: {1}", propertyName, value); SendPropertyChangeToServer(propertyName, value); } }
/// <summary> /// Add a command property to the object. Commands are boolean toggles, so there is /// no need to request the state from the server. /// </summary> /// <param name="commandName">Name of the command (e.g. foo["trigger"])</param> /// <returns></returns> public void AddCommand(string commandName) { try { _properties[commandName] = new PremiseProperty(commandName, PremiseProperty.PremiseType.TypeBoolean); // Make sure any subscribers get notified with the correct property name OnPropertyChanged(commandName + "Command"); } catch (Exception ex) { throw ex; } }
/// <summary> /// Add a property to the object. Makes a call to the server to get the value if /// initialValue is not specified or subscribe is set to true. /// </summary> /// <param name="propertyName">Name of the property (e.g. foo["propertyname"])</param> /// <param name="initalValue">Initial value for the property (enables reducing UI churn on first load)</param> /// <param name="type">Property type</param> /// <param name="subscribe">True to cause the property to be subscribed to</param> /// <returns></returns> public async Task AddPropertyAsync(string propertyName, object initalValue, PremiseProperty.PremiseType type = PremiseProperty.PremiseType.TypeText, bool subscribe = false) { PremiseProperty prop; if (!_properties.TryGetValue(propertyName, out prop)) { _properties[propertyName] = new PremiseProperty(propertyName) {PropertyType = type, Value = initalValue}; } // Ignore server if (initalValue != null && subscribe == false) return; await AddPropertyAsync(propertyName, type, subscribe); }