public static HueObjectBase CreateHueObject(JObject jObject, string id, HueConnection hueConnection, HueObjectType type)
{
if (jObject["error"] != null)
{
return(new Error(jObject));
}
switch (type)
{
case HueObjectType.Light:
return(new Light(jObject, hueConnection, id));
case HueObjectType.Client:
return(new Client(jObject, id));
case HueObjectType.Group:
return(new Group(jObject, hueConnection, id));
case HueObjectType.Schedule:
return(new Schedule(jObject, hueConnection, id));
default:
return(new Error(jObject));
}
}
public void SetScene(HueConnection connection, int?brightness)
{
foreach (SceneState sceneState in SceneStates)
{
sceneState.SetState(connection, !IndividualBrightness.Value ? brightness : null);
}
}
public void SetState(HueConnection connection, int?brightness)
{
Brightness = brightness ?? Brightness;
On = Brightness != 0;
SetState(connection, this);
}
public static async Task <HueObjectCollectionBase <Bridge> > GetBridges()
{
var bridgeFinder = new BridgeFinder();
var connection = new HueConnection {
Throttle = true
};
return((HueObjectCollectionBase <Bridge>) await bridgeFinder.GetBridgesAsync(connection));
}
protected HueConnectedObjectBase(HueConnection context, string id) : base(id)
{
if (context == null)
{
throw new ArgumentNullException("context", @" cannot be null for Connected Object");
}
Context = context;
}
public void SetBrightness(HueConnection connection, int?brightness)
{
var newState = new State {
Brightness = brightness, On = brightness != 0
};
foreach (SceneState sceneState in SceneStates)
{
sceneState.SetState(connection, newState);
}
}
public SceneStatesViewModel(Scene scene, SceneType sceneType, HueConnection connection)
{
_scene = scene;
_sceneType = sceneType;
_connection = connection;
foreach (var sceneState in from s in scene.SceneStates where s.SceneType == sceneType select s)
{
Add(new SceneStateViewModel(sceneState, this));
}
}
public SceneViewModel(Scene scene, BridgeViewModel bridgeViewModel, IDelegateCommandFactory commandFactory)
{
_scene = scene;
_bridgeViewModel = bridgeViewModel;
_bridgeViewModel.Lights.CollectionChanged += LightsOnCollectionChanged;
_bridgeViewModel.Groups.CollectionChanged += GroupsOnCollectionChanged;
_connection = bridgeViewModel.Context;
SaveCommand = commandFactory.CreateCommand(ExecuteSave, CanExecuteSave);
CancelCommand = commandFactory.CreateCommand(ExecuteCancel, CanExecuteCancel);
InitialiseSceneViewModel();
}
public static HueObjectBase CreateHueObject(string myString, HueConnection hueConnection, HueObjectType type)
{
var myObject = myString.JSONParse();
if (myObject is JObject)
{
return(CreateHueObject(myObject as JObject, hueConnection, type));
}
if (myObject is JArray)
{
return(CreateHueObject(myObject as JArray, hueConnection, type));
}
throw new ArgumentException(Resources.NoObjectConstructorForType, myObject.GetType().ToString());
}
protected HueAppViewModel(ISettings settings, IDelegateCommandFactory commandFactory, IMessageHandler messageHandler)
{
_connection = new HueConnection {
Throttle = true
};
_bridgeFinder = new BridgeFinder();
Bridges = new ObservableCollection <BridgeViewModel>();
_settings = settings;
_commandFactory = commandFactory;
MessageHandler = messageHandler;
ScanBridgesCommand = _commandFactory.CreateCommand(ExecuteScanBridgesAsync, CanExecuteScanBridges);
ExecuteScanBridgesAsync();
SaveCommand = _commandFactory.CreateCommand(ExecuteSave, CanExecuteSave);
}
public static HueObjectBase CreateHueObject(JObject jObject, HueConnection hueConnection, HueObjectType type)
{
if (jObject["error"] != null)
{
return(new Error(jObject));
}
switch (type)
{
case HueObjectType.Success:
return(new Success(jObject));
case HueObjectType.Bridge:
return(new Bridge(jObject, hueConnection));
case HueObjectType.BridgeConfig:
return(new BridgeConfig(jObject));
case HueObjectType.BridgeSoftwareUpdate:
return(new BridgeSoftwareUpdate(jObject));
case HueObjectType.Light:
return(new HueObjectCollectionBase <Light>(jObject, hueConnection));
case HueObjectType.LastAddedLights:
return(new LastAddedLights(jObject));
case HueObjectType.LightState:
return(new State(jObject));
case HueObjectType.Group:
return(new HueObjectCollectionBase <Group>(jObject, hueConnection));
case HueObjectType.Schedule:
return(new HueObjectCollectionBase <Schedule>(jObject, hueConnection));
case HueObjectType.Command:
return(new Command(jObject));
default:
throw new ArgumentOutOfRangeException(String.Format(Resources.NoObjectConstructorForType, type));
}
}
internal void SetState(HueConnection connection, State newState)
{
switch (LightSourceType)
{
case LightSourceType.Group:
//connection.Bridge.Groups.Dictionary[PointID].SetStateAsync(newState);
var bridge = connection.Bridge;
var groups = bridge.Groups;
var dict = groups.Dictionary;
var group = dict[PointID];
var rv = group.SetStateAsync(newState);
break;
case LightSourceType.Light:
connection.Bridge.Lights.Dictionary[PointID].SetStateAsync(newState).ContinueWith(task => Debug.WriteLine(task.Result));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private static HueObjectBase CreateHueObject(JArray jArray, HueConnection hueConnection, HueObjectType type)
{
if (jArray[0]["error"] != null)
{
type = HueObjectType.Error;
}
switch (type)
{
case HueObjectType.Success:
return(new HueObjectCollectionBase <Success>(jArray, hueConnection));
case HueObjectType.Error:
return(new HueObjectCollectionBase <Error>(jArray, hueConnection));
case HueObjectType.Bridge:
return(new HueObjectCollectionBase <Bridge>(jArray, hueConnection));
default:
throw new ArgumentOutOfRangeException(String.Format(Resources.NoCollectionConstructorForType, type));
}
}
public HueObjectCollectionBase(JArray jArray, HueConnection connection)
{
Dictionary = new Dictionary <string, T>();
foreach (object myObject in JsonConvert.DeserializeObject <List <object> >(jArray.ToString()))
{
try
{
JObject myJObject = JObject.FromObject(myObject);
HueObjectBase item = HueObjectFactory.CreateHueObject(myJObject, connection, HueObjectFactory.GetType(typeof(T)));
if (item is T)
{
Dictionary.Add(Dictionary.Count.ToString(CultureInfo.InvariantCulture), (T)item);
}
}
catch (ArgumentException exception)
{
Debug.WriteLine("Error when converting {0} - {1}", myObject, exception.Message);
}
}
}
public HueObjectCollectionBase(JObject jObject, HueConnection connection)
{
Dictionary = new Dictionary <string, T>();
foreach (KeyValuePair <string, object> kvp in JsonConvert.DeserializeObject <Dictionary <string, object> >(jObject.ToString()))
{
try
{
JObject myObject = JObject.FromObject(kvp.Value);
HueObjectBase item = HueObjectFactory.CreateHueObject(myObject, kvp.Key, connection, HueObjectFactory.GetType(typeof(T)));
if (item is T)
{
Dictionary.Add(kvp.Key, (T)item);
}
}
catch (ArgumentException exception)
{
Debug.WriteLine("Error when converting {0} : {1} - {2}", kvp.Key, kvp.Value, exception.Message);
}
}
}
protected LightSourceBase(HueConnection context, string id) : base(context, id)
{
}
public void SetBrightness(HueConnection connection, int?brightness)
{
SetState(connection, new State {
Brightness = brightness, On = brightness != 0
});
}
public void SetSaturationAndHue(HueConnection connection, int?saturation, int?hue)
{
SetState(connection, new State {
Saturation = saturation, Hue = hue, On = true
});
}
public void SetSaturationAndColourTemperature(HueConnection connection, int?saturation, int?colourTemperature)
{
SetState(connection, new State {
Saturation = saturation, ColorTemperature = colourTemperature, On = true
});
}
