private void OnDeviceAdded(UPnPSmartControlPoint cp, UPnPDevice device)
{
Console.WriteLine("found player " + device);
//players.Add(new SonosPlayer(device));
// we need to save these for future reference
lock (playerDevices)
{
playerDevices[device.UniqueDeviceName] = device;
}
// okay, we will try and notify the players that they have been found now.
var player = players.FirstOrDefault(p => p.UUID == device.UniqueDeviceName);
if (player != null)
{
player.SetDevice(device);
}
// Subscribe to events
var topologyService = device.GetService("urn:upnp-org:serviceId:ZoneGroupTopology");
topologyService.Subscribe(600, (service, subscribeok) =>
{
if (!subscribeok) return;
var stateVariable = service.GetStateVariableObject("ZoneGroupState");
stateVariable.OnModified += OnZoneGroupStateChanged;
});
}
public UPnPDeviceLocator()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
DeviceTree.Nodes.Add(UPnpRoot);
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(AddSink));
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(RemoveSink);
}
public AVTargetDiscovery(ManagerHandler NewCallback)
{
OnRenderer += new ManagerHandler(Weak_OnRendererSink);
RemovedRenderer += new ManagerHandler(Weak_RemovedRendererSink);
if(NewCallback!=null) OnRenderer += NewCallback;
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(AddSink),
null,
new string[3]{CpAVTransport.SERVICE_NAME,CpRenderingControl.SERVICE_NAME,CpConnectionManager.SERVICE_NAME});
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(RemoveSink);
}
private void HandleRemovedDevice(UPnPSmartControlPoint sender, UPnPDevice device)
{
ArrayList TempList = new ArrayList();
TreeNode tn;
IEnumerator en = UPnpRoot.Nodes.GetEnumerator();
while(en.MoveNext())
{
tn = (TreeNode)en.Current;
if (((UPnPDevice)tn.Tag).UniqueDeviceName==device.UniqueDeviceName)
{
TempList.Add(tn);
}
}
Object[] args = new Object[1];
args[0] = TempList;
this.Invoke(new UpdateTreeRemoveDelegate(HandleTreeUpdate_Remove),args);
}
protected void AddSink(UPnPSmartControlPoint sender, UPnPDevice device)
{
AVRenderer avm = new AVRenderer(device);
lock(ManagerList)
{
ManagerList.Add(avm);
}
if(OnRenderer!=null) OnRenderer(avm);
}
/// <summary>
/// Method executes when smart control point notices that
/// a upnp media server has left the network.
/// </summary>
/// <param name="sender"></param>
/// <param name="device"></param>
private void RemoveServer(UPnPSmartControlPoint sender, UPnPDevice device)
{
string udn = device.UniqueDeviceName;
CpMediaServer removeThis = null;
lock (LockHashes)
{
if (UdnToInitStatus.Contains(udn))
{
InitStatus status = (InitStatus) UdnToInitStatus[udn];
}
if (UdnToServer.Contains(udn))
{
removeThis = (CpMediaServer) UdnToServer[udn];
UdnToServer.Remove(udn);
}
}
if (this.OnServerGone != null)
{
this.OnServerGone(this, device);
}
if (removeThis != null)
{
if (this.OnCpServerRemoved != null)
{
this.OnCpServerRemoved(this, removeThis);
}
}
System.GC.Collect();
}
/// <summary>
/// This is the internal constructor, that basically makes it so
/// only one object is responsible for keeping track of
/// media server objects.
/// </summary>
/// <param name="readOnlyDesiredContainerState">
/// If true, then the public programmer cannot set the desired
/// state of containers, automatically causing each container
/// to virtualize only their immediate child containers.
/// </param>
internal _MediaServerDiscovery(
bool readOnlyDesiredContainerState
)
{
m_Scp = new UPnPSmartControlPoint(
new UPnPSmartControlPoint.DeviceHandler(this.Temporary_AddServer),
null,
new string[2] { CpContentDirectory.SERVICE_NAME, CpConnectionManager.SERVICE_NAME } );
m_Scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(this.RemoveServer);
m_readOnlyDesiredState = readOnlyDesiredContainerState;
}
private void HandleRemovedDevice(UPnPSmartControlPoint sender, UPnPDevice device)
{
ArrayList TempList = new ArrayList();
TreeNode tn;
IEnumerator en = UPnpRoot.Nodes.GetEnumerator();
while(en.MoveNext())
{
tn = (TreeNode)en.Current;
if(((UPnPDevice)tn.Tag).UniqueDeviceName==device.UniqueDeviceName)
{
TempList.Add(tn);
}
}
for(int x=0;x<TempList.Count;++x)
{
UPnpRoot.Nodes.Remove((TreeNode)TempList[x]);
}
}
private void DvSink(UPnPSmartControlPoint sender, UPnPDevice Dv)
{
}
private void OnRemoveSink(UPnPSmartControlPoint sender, UPnPDevice d)
{
RemoveEvent.Fire(this, d);
}
protected void HandleRemovedDevice(UPnPSmartControlPoint sender, UPnPDevice device)
{
this.Invoke(new UPnPSmartControlPoint.DeviceHandler(HandleRemovedDeviceEx), new object[2] {sender, device});
}
// protected void HandleUpdatedDevice(UPnPSmartControlPoint sender, UPnPDevice device)
// {
// MessageBox.Show("Updated: " + device.FriendlyName);
// }
protected void HandleExpiredDevice(UPnPSmartControlPoint sender, UPnPDevice device)
{
int cnt = UPnpRoot.Nodes.Count;
for (int x = 0; x < cnt; ++x)
{
if (UPnpRoot.Nodes[x].Tag.GetHashCode() == device.GetHashCode())
{
UPnpRoot.Nodes.RemoveAt(x);
break;
}
}
MessageBox.Show("Expired: " + device.FriendlyName);
}
protected void HandleAddedDevice(UPnPSmartControlPoint sender, UPnPDevice device)
{
/*
for(int x=0;x<device.Services.Length;++x)
{
device.Services[x].OnInvokeError += new UPnPService.UPnPServiceInvokeErrorHandler(HandleInvokeError);
device.Services[x].OnInvokeResponse += new UPnPService.UPnPServiceInvokeHandler(HandleInvoke);
}
*/
HandleCreate(device, device.BaseURL);
}
public MainForm(string[] args)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
deviceTree.Nodes.Add(UPnpRoot);
foreach (string parm in args)
{
if (parm.ToUpper() == "/DEBUG")
{
OpenSource.Utilities.InstanceTracker.Enabled = true;
OpenSource.Utilities.EventLogger.Enabled = true;
OpenSource.Utilities.EventLogger.ShowAll = true;
OpenSource.Utilities.InstanceTracker.Display();
}
if (parm.ToUpper().StartsWith("/ST:"))
{
DText p = new DText();
p.ATTRMARK = ":";
p[0] = parm;
try
{
SubscribeTime = int.Parse(p[2]);
}
catch (Exception)
{ }
}
}
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(HandleAddedDevice));
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(HandleRemovedDevice);
// scp.OnUpdatedDevice += new UPnPSmartControlPoint.DeviceHandler(HandleUpdatedDevice);
}
private void AddSink(UPnPSmartControlPoint sender, UPnPDevice d)
{
HandleCreate(d, d.BaseURL);
}
private void UPnPServiceLocator_Load(object sender, System.EventArgs e)
{
this.deviceTree.Nodes[0].Nodes.Clear();
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(HandleAddedDevice));
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(HandleRemovedDevice);
}
private void OnAddSink(UPnPSmartControlPoint sender, UPnPDevice d)
{
AddEvent.Fire(this, d);
}
public virtual void StartScan()
{
ControlPoint = new UPnPSmartControlPoint(OnDeviceAdded, OnServiceAdded, "urn:schemas-upnp-org:device:ZonePlayer:1");
}
public void Start()
{
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(OnAddSink), null ,"urn:schemas-upnp-org:device:MediaRenderer:1");
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(OnRemoveSink);
}
private void OnServiceAdded(UPnPSmartControlPoint sender, UPnPService service)
{
}
private void HandleAddedDevice(UPnPSmartControlPoint sender, UPnPDevice device)
{
HandleCreate(device,device.BaseURL);
}
public MainForm()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(SCPAddSink));
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(SCPRemoveSink);
}
private void UPnPServiceLocator_Load(object sender, System.EventArgs e)
{
scp = new UPnPSmartControlPoint(new UPnPSmartControlPoint.DeviceHandler(HandleAddedDevice));
scp.OnRemovedDevice += new UPnPSmartControlPoint.DeviceHandler(HandleRemovedDevice);
}
private void SCPAddSink(UPnPSmartControlPoint sender, UPnPDevice device)
{
if (automaticMenuItem.Checked == false) return;
if (devicelist.Contains(device) == true) return;
if (device.FriendlyName.StartsWith("*") == true) return;
ListViewItem lv = new ListViewItem(new string[] {device.FriendlyName,"0","0"},1);
lv.Tag = device;
OutboundListViewTable[device] = lv;
//device.OnRemoved += new UPnPDevice.OnRemovedHandler(RemovedSink);
lock(outboundListView)
{
outboundListView.Items.Add(lv);
}
devicelist.Add(device);
gk.AddDevice(device);
}
/// <summary>
/// Memory cleanup.
/// </summary>
public void Dispose()
{
m_Scp.OnRemovedDevice -= new UPnPSmartControlPoint.DeviceHandler(this.RemoveServer);
this.OnCpServerAdded = null;
this.OnCpServerRemoved = null;
this.OnServerGone = null;
this.OnServerSeen = null;
m_Scp = null;
}
private void SCPRemoveSink(UPnPSmartControlPoint sender, UPnPDevice device)
{
if (devicelist.Contains(device) == false) return;
//if (automaticMenuItem.Checked == false) return;
lock(outboundListView)
{
foreach (ListViewItem lv in outboundListView.Items)
{
UPnPDevice d = (UPnPDevice)lv.Tag;
if (d == device) outboundListView.Items.Remove(lv);
}
}
//device.OnRemoved -= new UPnPDevice.OnRemovedHandler(RemovedSink);
devicelist.Remove(device);
gk.RemoveDevice(device);
}
/// <summary>
/// When a MediaServer device is found, we add it to a temp list.
/// Then we attempt to subscribe to its services.
/// </summary>
/// <param name="sender">the smart cp that found the device</param>
/// <param name="device">the mediaserver device</param>
private void Temporary_AddServer(UPnPSmartControlPoint sender, UPnPDevice device)
{
if (this.OnServerSeen != null)
{
this.OnServerSeen(this, device);
}
UPnPService sCD = device.GetServices(CpContentDirectory.SERVICE_NAME)[0];
UPnPService sCM = device.GetServices(CpConnectionManager.SERVICE_NAME)[0];
CpMediaServer newServer;
try
{
newServer = new CpMediaServer(device);
}
catch (UPnPCustomException)
{
newServer = null;
}
if (newServer != null)
{
InitStatus status = new InitStatus();
status.SubcribeCD = false;
status.SubcribeCM = false;
status.EventedCD = false;
status.EventedCM = false;
status.Server = newServer;
lock (LockHashes)
{
UdnToInitStatus[device.UniqueDeviceName] = status;
}
newServer.ConnectionManager.OnSubscribe += new CpConnectionManager.SubscribeHandler(this.Sink_OnCmServiceSubscribe);
newServer.ContentDirectory.OnSubscribe += new CpContentDirectory.SubscribeHandler(this.Sink_OnCdServiceSubscribe);
newServer.ConnectionManager.OnStateVariable_SourceProtocolInfo += new CpConnectionManager.StateVariableModifiedHandler_SourceProtocolInfo(this.Sink_OnCmEvented);
newServer.ContentDirectory.OnStateVariable_SystemUpdateID += new CpContentDirectory.StateVariableModifiedHandler_SystemUpdateID(this.Sink_OnCdEvented);
newServer.ConnectionManager._subscribe(600);
newServer.ContentDirectory._subscribe(600);
}
}
protected void RemoveSink(UPnPSmartControlPoint sender, UPnPDevice device)
{
AVRenderer RemoveThis = null;
lock(ManagerList)
{
for(int i=0;i<ManagerList.Count;++i)
{
AVRenderer avm = (AVRenderer)ManagerList[i];
if(avm.MainDevice.UniqueDeviceName == device.UniqueDeviceName)
{
RemoveThis = avm;
ManagerList.RemoveAt(i);
break;
}
}
}
if(RemoveThis!=null)
{
RemoveThis.Removed();
if(RemovedRenderer!=null) RemovedRenderer(RemoveThis);
}
}
