public void OnDiscoveringDevice(Peripheral peripheral)
{
DiscoveredDeviceEventArgs args = new DiscoveredDeviceEventArgs();
args.DiscoveredPeripheral = peripheral;
DiscoveredDevice?.Invoke(this, args);
}
public static Action GetDeviceInformation(DiscoveredDevice discoveredDevice, Action <DeviceEureka> callback, ILogger logger)
{
return(async() => {
try
{
var http = new HttpClient
{
Timeout = new TimeSpan(0, 0, 5)
};
var response = await http.GetAsync($"http://{discoveredDevice.IPAddress}:8008/setup/eureka_info?params=version,audio,name,build_info,detail,device_info,net,wifi,setup,settings,opt_in,opencast,multizone,proxy,night_mode_params,user_eq,room_equalizer&options=detail");
var receiveStream = await response.Content.ReadAsStreamAsync();
var readStream = new StreamReader(receiveStream, Encoding.UTF8);
var eurekaInfo = readStream.ReadToEnd();
if (response.StatusCode == HttpStatusCode.OK)
{
var eureka = JsonConvert.DeserializeObject <DeviceEureka>(eurekaInfo);
callback?.Invoke(eureka);
}
}
catch (Exception ex)
{
logger?.Log(ex, "DeviceInformation.GetDeviceInformation");
}
});
}
public void TestDevices()
{
asyncEvent = new AutoResetEvent(false);
// Add a device
var devices = new Devices();
devices.SetCallback(OnAddDeviceCallback);
var discoveredDevice = new DiscoveredDevice();
discoveredDevice.IPAddress = "192.168.111.111";
discoveredDevice.Usn = "usn";
discoveredDevice.Name = "Device_Name";
discoveredDevice.Port = 8009;
devices.OnDeviceAvailable(discoveredDevice);
asyncEvent.WaitOne(100);
Assert.AreEqual(discoveredDevice.Name, device.GetFriendlyName());
Assert.AreEqual(discoveredDevice.Usn, device.GetUsn());
Assert.AreEqual(discoveredDevice.IPAddress, device.GetHost());
// Not connected, volume messages are not send.
TestMessagesWhenNotConnected(devices);
// Connect and launch app
TestConnectAndLoadMedia(devices);
// Test the other messages
TestMessages(devices);
}
/// <summary>
/// A new device is discoverd. Add the device, or update if it already exists.
/// </summary>
/// <param name="discoveredDevice">the discovered device</param>
public void OnDeviceAvailable(DiscoveredDevice discoveredDevice)
{
if (deviceList == null || discoveredDevice == null)
{
return;
}
var existingDevice = deviceList.FirstOrDefault(
d => d.GetHost().Equals(discoveredDevice.IPAddress) &&
d.GetPort().Equals(discoveredDevice.Port));
if (existingDevice == null)
{
if (!deviceList.Any(d => d.GetUsn() != null &&
d.GetUsn().Equals(discoveredDevice.Usn) &&
d.GetPort().Equals(discoveredDevice.Port)))
{
var newDevice = DependencyFactory.Container.Resolve <Device>();
newDevice.Initialize(discoveredDevice);
deviceList.Add(newDevice);
onAddDeviceCallback?.Invoke(newDevice);
newDevice.OnGetStatus();
if (AutoStart)
{
newDevice.OnClickPlayPause();
}
}
}
else
{
existingDevice.Initialize(discoveredDevice);
existingDevice.SetDeviceName(existingDevice.GetFriendlyName());
}
}
public override void OnBindViewHolder(RecyclerView.ViewHolder holder, int position)
{
DeviceViewHolder DeviceHolder = (DeviceViewHolder)holder;
DiscoveredDevice Item = this.Dataset[position];
DeviceHolder.Model.Text = Item.ModelName;
DeviceHolder.Address.Text = Item.IpAddress;
}
public Device(ILogger loggerIn, IDeviceConnection deviceConnectionIn, IDeviceCommunication deviceCommunicationIn)
{
logger = loggerIn;
deviceConnection = deviceConnectionIn;
deviceCommunication = deviceCommunicationIn;
deviceConnection.SetCallback(GetHost, SetDeviceState, OnReceiveMessage);
deviceState = DeviceState.NotConnected;
discoveredDevice = new DiscoveredDevice();
}
/// <summary>
/// Check if the device is on.
/// </summary>
/// <param name="discoveredDevice"></param>
/// <param name="callback"></param>
public static void CheckDeviceIsOn(DiscoveredDevice discoveredDevice, Action <DiscoveredDevice> callback)
{
Task.Run(async() => {
// Check if the device is on.
var http = new HttpClient();
var response = await http.GetAsync($"http://{discoveredDevice.IPAddress}:8008/setup/eureka_info?params=version,audio,name,build_info,detail,device_info,net,wifi,setup,settings,opt_in,opencast,multizone,proxy,night_mode_params,user_eq,room_equalizer&options=detail");
if (response.StatusCode == HttpStatusCode.OK)
{
callback?.Invoke(discoveredDevice);
}
});
}
/// <summary>
/// Callback for when the device information is collected.
/// </summary>
/// <param name="eurekaIn"></param>
private void SetDeviceInformation(DeviceEureka eurekaIn)
{
var discoveredDevice = new DiscoveredDevice
{
IPAddress = eurekaIn.GetIpAddress(),
Name = eurekaIn.GetName(),
Port = 8009,
Protocol = "",
Usn = null,
IsGroup = false,
AddedByDeviceInfo = true,
Eureka = eurekaIn
};
OnDeviceAvailable(discoveredDevice);
if (eurekaIn?.Multizone?.Groups == null)
{
return;
}
foreach (var group in eurekaIn.Multizone.Groups)
{
discoveredDevice = new DiscoveredDevice
{
IPAddress = GetIpOfGroup(group, eurekaIn),
Name = group.Name,
Port = GetPortOfGroup(group, eurekaIn),
Protocol = "",
Usn = null,
IsGroup = true,
AddedByDeviceInfo = true,
Eureka = eurekaIn,
Group = group
};
// Add the group.
if (group.Elected_leader == "self")
{
OnDeviceAvailable(discoveredDevice);
}
// Get device information from unknown devices.
if (!deviceList.Any(x => x.GetHost() == GetIpOfGroup(group, eurekaIn)))
{
applicationLogic.StartTask(DeviceInformation.GetDeviceInformation(discoveredDevice, SetDeviceInformation, logger));
}
}
}
/// <summary>
/// Was the device playing when the application was closed for the last time?
/// </summary>
/// <returns>true if the device was playing, or false</returns>
public bool WasPlaying(DiscoveredDevice discoveredDevice)
{
for (int i = 0; i < settings.ChromecastDiscoveredDevices.Count; i++)
{
if (settings.ChromecastDiscoveredDevices[i].Port == discoveredDevice.Port &&
settings.ChromecastDiscoveredDevices[i].Name == discoveredDevice.Name)
{
return(settings.ChromecastDiscoveredDevices[i].DeviceState == Communication.DeviceState.Playing ||
settings.ChromecastDiscoveredDevices[i].DeviceState == Communication.DeviceState.Buffering ||
settings.ChromecastDiscoveredDevices[i].DeviceState == Communication.DeviceState.LoadingMedia);
}
}
return(false);
}
/// <summary>
/// Initialize a device.
/// </summary>
/// <param name="discoveredDeviceIn">the discovered device</param>
public void Initialize(DiscoveredDevice discoveredDeviceIn)
{
if (discoveredDevice == null || deviceCommunication == null || deviceConnection == null)
{
return;
}
logger.Log($"Discovered device: {JsonConvert.SerializeObject(discoveredDeviceIn)}");
if (discoveredDeviceIn.Headers != null)
{
discoveredDevice.Headers = discoveredDeviceIn.Headers;
}
if (discoveredDeviceIn.IPAddress != null)
{
discoveredDevice.IPAddress = discoveredDeviceIn.IPAddress;
}
if (discoveredDeviceIn.Name != null)
{
discoveredDevice.Name = discoveredDeviceIn.Name;
}
if (discoveredDeviceIn.Port != 0)
{
discoveredDevice.Port = discoveredDeviceIn.Port;
}
if (discoveredDeviceIn.Protocol != null)
{
discoveredDevice.Protocol = discoveredDeviceIn.Protocol;
}
deviceCommunication.SetCallback(SetDeviceState,
OnVolumeUpdate,
deviceConnection.SendMessage,
GetDeviceState,
IsConnected,
deviceConnection.IsConnected,
GetHost,
GetPort,
SendSilence,
WasPlayingWhenStopped);
deviceConnection.SetPort(discoveredDevice.Port);
OnGetStatus();
volumeSetting = new Volume
{
controlType = "attenuation",
level = 0.0f,
muted = false,
stepInterval = 0.05f
};
}
/// <summary>
/// Get the device with the IP and port.
/// </summary>
/// <returns></returns>
private IDevice GetDevice(DiscoveredDevice discoveredDevice)
{
if (discoveredDevice == null)
{
return(null);
}
if (discoveredDevice.IsGroup)
{
return(deviceList.FirstOrDefault(d => d.GetDiscoveredDevice()?.Group?.Uuid == discoveredDevice.Group?.Uuid));
}
else
{
return(deviceList.FirstOrDefault(d => d.GetDiscoveredDevice()?.Eureka?.DeviceInfo?.Mac_address == discoveredDevice.Eureka?.DeviceInfo?.Mac_address));
}
}
public Device(ILogger loggerIn, IDeviceConnection deviceConnectionIn, IDeviceCommunication deviceCommunicationIn)
{
logger = loggerIn;
deviceConnection = deviceConnectionIn;
deviceCommunication = deviceCommunicationIn;
deviceConnection.SetCallback(GetHost, GetPort, SetDeviceState, OnReceiveMessage);
deviceState = DeviceState.NotConnected;
discoveredDevice = new DiscoveredDevice();
volumeSetting = new Volume
{
controlType = "attenuation",
level = 0.0f,
muted = false,
stepInterval = 0.05f
};
}
/// <summary>
/// Get the device with the IP and port.
/// </summary>
/// <returns></returns>
private IDevice GetDevice(DiscoveredDevice discoveredDevice)
{
if (discoveredDevice == null)
{
return(null);
}
if (discoveredDevice.IsGroup)
{
return(deviceList.FirstOrDefault(d => d.GetDiscoveredDevice()?.Id == discoveredDevice.Id));
}
else
{
return(deviceList.FirstOrDefault(d => d.GetDiscoveredDevice()?.Eureka?.GetMacAddress() == discoveredDevice.Eureka?.GetMacAddress()));
}
}
/// <summary>
/// Callback for when the device information is collected.
/// </summary>
/// <param name="eurekaIn"></param>
private void SetDeviceInformation(DeviceEureka eurekaIn)
{
var discoveredDevice = new DiscoveredDevice
{
IPAddress = eurekaIn.GetIpAddress(),
MACAddress = eurekaIn.GetMacAddress(),
Name = eurekaIn.GetName(),
Port = 8009,
Protocol = "",
Usn = null,
IsGroup = false,
AddedByDeviceInfo = true,
Eureka = eurekaIn
};
OnDeviceAvailable(discoveredDevice);
}
/// <summary>
/// A new device is discoverd. Add the device, or update if it already exists.
/// </summary>
/// <param name="discoveredDevice">the discovered device</param>
public void OnDeviceAvailable(DiscoveredDevice discoveredDevice)
{
if (deviceList == null || discoveredDevice == null)
{
return;
}
if (discoveredDevice.Port == 0 || discoveredDevice.Port == 10001)
{
return;
}
if (!discoveredDevice.AddedByDeviceInfo)
{
if (!discoveredDevice.IsGroup)
{
DeviceInformation.GetDeviceInformation(discoveredDevice, SetDeviceInformation);
}
}
else
{
lock (deviceList)
{
var existingDevice = GetDevice(discoveredDevice);
if (existingDevice == null)
{
var newDevice = DependencyFactory.Container.Resolve <Device>();
newDevice.Initialize(discoveredDevice, SetDeviceInformation);
deviceList.Add(newDevice);
onAddDeviceCallback?.Invoke(newDevice);
if (AutoStart && !newDevice.IsGroup())
{
newDevice.ResumePlaying();
}
}
else
{
existingDevice.Initialize(discoveredDevice, SetDeviceInformation);
}
}
}
}
/// <summary>
/// A new device is discoverd. Add the device, or update if it already exists.
/// </summary>
/// <param name="discoveredDevice">the discovered device</param>
public void OnDeviceAvailable(DiscoveredDevice discoveredDevice)
{
if (deviceList == null || discoveredDevice == null)
{
return;
}
if (discoveredDevice.Port == 0 || discoveredDevice.Port == 10001)
{
return;
}
if (!discoveredDevice.AddedByDeviceInfo && !discoveredDevice.IsGroup)
{
applicationLogic.StartTask(DeviceInformation.GetDeviceInformation(discoveredDevice, SetDeviceInformation, logger));
}
else
{
lock (deviceList)
{
var existingDevice = GetDevice(discoveredDevice);
if (existingDevice == null)
{
var newDevice = DependencyFactory.Container.Resolve <Device>();
newDevice.Initialize(discoveredDevice, SetDeviceInformation, StopGroup, applicationLogic.StartTask, IsGroupStatusBlank, AutoMute);
deviceList.Add(newDevice);
onAddDeviceCallback?.Invoke(newDevice);
var wasPlaying = applicationLogic.WasPlaying(discoveredDevice);
if ((AutoStart && !newDevice.IsGroup()) || (StartLastUsedDevices && wasPlaying))
{
newDevice.ResumePlaying();
}
}
else
{
existingDevice.Initialize(discoveredDevice, SetDeviceInformation, StopGroup, applicationLogic.StartTask, IsGroupStatusBlank, AutoMute);
}
}
}
}
/// <summary>
/// Check if the device is on.
/// </summary>
/// <param name="discoveredDevice"></param>
/// <param name="callback"></param>
public static Action CheckDeviceIsOn(DiscoveredDevice discoveredDevice, Action <DiscoveredDevice> callback, ILogger logger)
{
return(async() => {
var ipAddress = discoveredDevice.IPAddress;
try
{
// Check if the device is on.
var http = new HttpClient
{
Timeout = new TimeSpan(0, 0, 5)
};
var response = await http.GetAsync($"http://{ipAddress}:8008/setup/eureka_info?params=version,audio,name,build_info,detail,device_info,net,wifi,setup,settings,opt_in,opencast,multizone,proxy,night_mode_params,user_eq,room_equalizer&options=detail");
if (response.StatusCode == HttpStatusCode.OK)
{
discoveredDevice.AddedByDeviceInfo = false;
callback?.Invoke(discoveredDevice);
}
}
catch (Exception ex)
{
logger?.Log(ex, $"DeviceInformation.CheckDeviceIsOn [{ipAddress}]");
}
});
}
/// <summary>
/// Initialize a device.
/// </summary>
/// <param name="discoveredDeviceIn">the discovered device</param>
public void Initialize(DiscoveredDevice discoveredDeviceIn, Action <DeviceEureka> setDeviceInformationCallbackIn
, Action <IDevice> stopGroupIn, Action <Action, CancellationTokenSource> startTaskIn, Func <IDevice, bool> isGroupStatusBlankIn
, Action <bool> autoMuteIn)
{
setDeviceInformationCallback = setDeviceInformationCallbackIn;
//stopGroup = stopGroupIn;
startTask = startTaskIn;
isGroupStatusBlank = isGroupStatusBlankIn;
autoMute = autoMuteIn;
if (discoveredDevice == null || deviceCommunication == null || deviceConnection == null ||
discoveredDeviceIn == null || setDeviceInformationCallbackIn == null || stopGroupIn == null)
{
return;
}
var ipChanged = discoveredDevice.IPAddress != discoveredDeviceIn.IPAddress;
// Logging
if (ipChanged ||
discoveredDevice.Name != discoveredDeviceIn.Name ||
discoveredDevice.Port != discoveredDeviceIn.Port ||
JsonConvert.SerializeObject(discoveredDevice.Eureka?.Multizone?.Groups)
!= JsonConvert.SerializeObject(discoveredDeviceIn.Eureka?.Multizone?.Groups))
{
logger.Log($"Discovered device: {discoveredDeviceIn?.Name} {discoveredDeviceIn?.IPAddress}:{discoveredDeviceIn?.Port} {JsonConvert.SerializeObject(discoveredDeviceIn?.Eureka?.Multizone?.Groups)} {discoveredDeviceIn?.Id}");
}
if (discoveredDeviceIn.Headers != null)
{
discoveredDevice.Headers = discoveredDeviceIn.Headers;
}
if (discoveredDeviceIn.IPAddress != null)
{
discoveredDevice.IPAddress = discoveredDeviceIn.IPAddress;
}
if (discoveredDeviceIn.MACAddress != null)
{
discoveredDevice.MACAddress = discoveredDeviceIn.MACAddress;
}
if (discoveredDeviceIn.Id != null)
{
discoveredDevice.Id = discoveredDeviceIn.Id;
}
if (discoveredDeviceIn.Name != null)
{
discoveredDevice.Name = discoveredDeviceIn.Name;
}
if (discoveredDeviceIn.Port != 0)
{
discoveredDevice.Port = discoveredDeviceIn.Port;
}
if (discoveredDeviceIn.Protocol != null)
{
discoveredDevice.Protocol = discoveredDeviceIn.Protocol;
}
if (discoveredDeviceIn.Usn != null)
{
discoveredDevice.Usn = discoveredDeviceIn.Usn;
}
discoveredDevice.AddedByDeviceInfo = discoveredDeviceIn.AddedByDeviceInfo;
if (discoveredDeviceIn.Eureka != null)
{
discoveredDevice.Eureka = discoveredDeviceIn.Eureka;
}
if (discoveredDeviceIn.Group != null)
{
discoveredDevice.Group = discoveredDeviceIn.Group;
}
deviceCommunication.SetCallback(this, deviceConnection.SendMessage, deviceConnection.IsConnected);
if (ipChanged && GetDeviceState() == DeviceState.Playing)
{
ResumePlaying();
}
}
private void DeviceDiscovered(object sender, DiscoveredDevice device)
{
this.Adapter.Dataset.Add(device);
}
private async void DiscoveredDeviceClick(object sender, DiscoveredDevice device)
{
await this.Connect($"{device.IpAddress}:{device.PortNumber}");
}
private void DiscoverCallBack(DiscoveredDevice discoveredDevice)
{
this.discoveredDevice = discoveredDevice;
asyncEvent.Set();
}
public GlobalJsonResult <ProjectDevice> AddDiscoveredDeviceToProject(int projectId, [FromBody] DiscoveredDevice device)
{
var result = dispatcher.Dispatch(DeviceActions.AddDeviceToProject(projectId, device.Map()));
return(GlobalJsonResult <ProjectDevice> .Success(HttpStatusCode.OK, result));
}
/// <summary>
/// Initialize a device.
/// </summary>
/// <param name="discoveredDeviceIn">the discovered device</param>
public void Initialize(DiscoveredDevice discoveredDeviceIn, Action <DeviceEureka> setDeviceInformationCallbackIn)
{
if (discoveredDevice == null || deviceCommunication == null || deviceConnection == null)
{
return;
}
var ipChanged = discoveredDevice.IPAddress != discoveredDeviceIn.IPAddress;
// Logging
if (ipChanged ||
discoveredDevice.Name != discoveredDeviceIn.Name ||
discoveredDevice.Port != discoveredDeviceIn.Port ||
JsonConvert.SerializeObject(discoveredDevice.Eureka?.Multizone?.Groups)
!= JsonConvert.SerializeObject(discoveredDeviceIn.Eureka?.Multizone?.Groups))
{
logger.Log($"Discovered device: {discoveredDeviceIn.Name} {discoveredDeviceIn.IPAddress}:{discoveredDeviceIn.Port} {JsonConvert.SerializeObject(discoveredDeviceIn.Eureka.Multizone.Groups)}");
}
if (discoveredDeviceIn.Headers != null)
{
discoveredDevice.Headers = discoveredDeviceIn.Headers;
}
if (discoveredDeviceIn.IPAddress != null)
{
discoveredDevice.IPAddress = discoveredDeviceIn.IPAddress;
}
if (discoveredDeviceIn.Name != null)
{
discoveredDevice.Name = discoveredDeviceIn.Name;
}
if (discoveredDeviceIn.Port != 0)
{
discoveredDevice.Port = discoveredDeviceIn.Port;
}
if (discoveredDeviceIn.Protocol != null)
{
discoveredDevice.Protocol = discoveredDeviceIn.Protocol;
}
if (discoveredDeviceIn.Usn != null)
{
discoveredDevice.Usn = discoveredDeviceIn.Usn;
}
discoveredDevice.AddedByDeviceInfo = discoveredDeviceIn.AddedByDeviceInfo;
if (discoveredDeviceIn.Eureka != null)
{
discoveredDevice.Eureka = discoveredDeviceIn.Eureka;
}
if (discoveredDeviceIn.Group != null)
{
discoveredDevice.Group = discoveredDeviceIn.Group;
}
deviceCommunication.SetCallback(this, deviceConnection.SendMessage, deviceConnection.IsConnected);
if (!IsGroup() || (IsGroup() && discoveredDevice.AddedByDeviceInfo))
{
OnGetStatus();
}
setDeviceInformationCallback = setDeviceInformationCallbackIn;
if (ipChanged && deviceState == DeviceState.Playing)
{
ResumePlaying();
}
}
