public async Task <HueObjectBase> LoginAsync(string userID)
{
HueActionDelegate method = async delegate
{
string returnString = await Context.GetAsync(String.Format(Resources.ConfigURI, InternalIPAddress, userID));
HueObjectBase returnObject = HueObjectFactory.CreateHueObject(returnString, HueObjectType.BridgeConfig);
var bridgeConfig = returnObject as BridgeConfig;
if (bridgeConfig != null)
{
if (bridgeConfig.WhiteList.Count > 0)
{
Context.LoggedInID = userID;
var success = new HueObjectCollectionBase <Success>();
success.Dictionary.Add("1", new Success("", String.Format("Logged in with id {0}", userID)));
return(success);
}
var error = new HueObjectCollectionBase <Error>();
error.Dictionary.Add("1", new Error(-1, returnString, String.Format("unable to login with id {0}", userID)));
return(error);
}
return(returnObject);
};
return(await Context.ConnectionWrapperAsync(method));
}
public async Task <HueObjectBase> GetLightsFullAsync()
{
HueObjectBase lights = await GetLightsAsync();
var lightsList = lights as HueObjectCollectionBase <Light>;
if (lightsList != null)
{
var lightList2 = (from l in lightsList.Dictionary.Values select l).ToList();
foreach (Light light in lightList2)
{
HueObjectBase lightDetail = await light.GetAttributesAsync();
var detail = lightDetail as Light;
if (detail != null)
{
lightsList.Dictionary[light.ID] = detail;
}
}
_lights = lightsList;
}
return(lights);
}
public async Task <HueObjectBase> GetGroupsFullAsync()
{
HueActionDelegate method = async delegate
{
string returnString = await Context.GetAsync(Context.GroupsAllURI());
var groups = HueObjectFactory.CreateHueObject(returnString, Context, HueObjectType.Group) as HueObjectCollectionBase <Group>;
if (groups != null)
{
var groups2 = (from l in groups.Dictionary.Values select l).ToList();
foreach (Group group in groups2)
{
HueObjectBase groupDetail = await group.GetAttributesAsync();
var detail = groupDetail as Group;
if (detail != null)
{
groups.Dictionary[group.ID] = detail;
}
}
_groups = groups;
}
return(groups);
};
return(await Context.LoginWrapperAsync(method));
}
public BridgeConfig(JObject jObject)
{
Name = (string)jObject["name"];
MAC = (string)jObject["mac"];
DHCP = (bool?)jObject["dhcp"];
IPAddress = (string)jObject["ipaddress"];
NetMask = (string)jObject["netmask"];
Gateway = (string)jObject["gateway"];
ProxyAddress = (string)jObject["proxyaddress"];
ProxyPort = (int?)jObject["proxyport"];
LastUpdated = (DateTime?)jObject["UTC"];
WhiteList = jObject["whitelist"] != null ? new HueObjectCollectionBase <Client>(JObject.FromObject(jObject["whitelist"])) : new HueObjectCollectionBase <Client>();
SoftwareVersion = (string)jObject["swversion"];
if (jObject["swupdate"] != null)
{
HueObjectBase softwareUpdate = HueObjectFactory.CreateHueObject(jObject["swupdate"].ToString(), HueObjectType.BridgeSoftwareUpdate);
var update = softwareUpdate as BridgeSoftwareUpdate;
if (update != null)
{
SoftwareUpdate = update;
}
}
LinkButton = (bool?)jObject["linkbutton"];
PortalServices = (bool?)jObject["portalservices"];
}
public async Task <bool> ConnectAsync()
{
IsConnecting = true;
ConnectCommand.RaiseCanExecuteChanged();
_bridge.Connect();
HueObjectBase rv = await LoginAsync(_settings.ApplicationID.Value);
if (rv.IsError())
{
EventHandler eventHandler = async(s, e) => await TimerCallbackAsync();
await _messageHandler.GetResponseAsync("Information", string.Format("Please press the Link button on your bridge."), 500, 30000, MessageBoxButtons.None, eventHandler);
return(false);
}
ExecuteGetLightsAsync();
ExecuteGetGroupsAsync();
IsConnecting = false;
RaisePropertyChanged("IsConnected");
ConnectCommand.RaiseCanExecuteChanged();
return(true);
}
private void StartConsumer()
{
if (_task == null)
{
_scheduleTicker.TimerStart();
_task = Task.Factory.StartNew(async() =>
{
try
{
Debug.WriteLine("starting consumer thread");
Debug.WriteLine("waiting for queue or kill task");
while (WaitHandle.WaitAny(_queueEvents) != 0)
{
Debug.WriteLine("queued item detected, waiting for ticker");
while (WaitHandle.WaitAny(_tickerEvents) != 0)
{
Debug.WriteLine("ticker detected");
QueueItem dequeueItem = _queue.DequeueSync();
if (dequeueItem != null)
{
HueObjectBase rv = await LoginWrapperAsync(dequeueItem.Action);
if (_syncItemQueueResponses.ContainsKey(dequeueItem.Path))
{
_syncItemQueueResponses[dequeueItem.Path] = rv;
}
else
{
_syncItemQueueResponses.Add(dequeueItem.Path, rv);
}
Debug.WriteLine(rv);
var eventArgs = new HueResponseEventArgs {
Response = rv, Path = dequeueItem.Path
};
OnResponseReady(eventArgs);
}
break;
}
}
}
catch (Exception exception)
{
Debug.WriteLine(exception.Message);
_task = null;
}
Debug.WriteLine("stopping consumer thread");
});
}
}
public static HueObjectCollectionBase <T> To <T>(this HueObjectBase hueObject)
where T : HueObjectBase
{
if (hueObject is T)
{
return(new HueObjectCollectionBase <T> {
(T)hueObject
});
}
else if (hueObject is HueObjectCollectionBase <T> )
{
return((HueObjectCollectionBase <T>)hueObject);
}
return(null);
}
private async void SetAlertAsync()
{
_isSettingAlert = true;
SetAlertCommand.RaiseCanExecuteChanged();
HueObjectBase rv = await LightSourceModel.SetAlertAsync();
if (!rv.IsError())
{
bool refreshed = await LightSourceModel.RefreshAttributesAsync();
if (refreshed)
{
IsAlerting = LightSourceModel.State.Alert != "none";
}
}
_isSettingAlert = false;
SetAlertCommand.RaiseCanExecuteChanged();
}
public static bool IsError(this HueObjectBase hueObject)
{
return(hueObject is Error || hueObject is HueObjectCollectionBase <Error>);
}
