C# UPnP.UPnPDevice类代码示例

 public static Hashtable CreateTableOfServiceNames(UPnPDevice rootDevice)
 {
     Hashtable RetVal = new Hashtable();
     foreach (UPnPDevice d in rootDevice.EmbeddedDevices) { ProcessDevice(d, RetVal); }
     foreach (UPnPService s in rootDevice.Services) { ProcessService(s, RetVal); }
     return (RetVal);
 }

        public Gatekeeper(int PortNumber)
        {
            A_ICB = new UPnPService.UPnPServiceInvokeHandler(A_InvokeSink);
            A_IECB = new UPnPService.UPnPServiceInvokeErrorHandler(A_InvokeErrorSink);

            Port = PortNumber;
            Root = UPnPDevice.CreateRootDevice(1000,1,"");
            Root.FriendlyName = "UPnPShare";

            Root.StandardDeviceType = "UPnPGateKeeper";
            DV = new DvGateKeeper();
            Root.AddService(DV);

            DV.External_Register = new DvGateKeeper.Delegate_Register(RegisterSink);
            DV.External_UnRegister = new DvGateKeeper.Delegate_UnRegister(UnRegisterSink);
            DV.External_GetDocument = new DvGateKeeper.Delegate_GetDocument(GetDocumentSink);
            DV.External_AddDevice = new DvGateKeeper.Delegate_AddDevice(AddDeviceSink);
            DV.External_RemoveDevice = new DvGateKeeper.Delegate_RemoveDevice(RemovedDeviceSink);
            DV.External_FireEvent = new DvGateKeeper.Delegate_FireEvent(FireEventSink);
            DV.External_GetStateTable = new DvGateKeeper.Delegate_GetStateTable(GetStateTableSink);

            DV.External_Invoke = new DvGateKeeper.Delegate_Invoke(InvokeSink);
            DV.External_InvokeAsync = new DvGateKeeper.Delegate_InvokeAsync(InvokeAsyncSink);
            DV.External_InvokeAsyncResponse = new DvGateKeeper.Delegate_InvokeAsyncResponse(InvokeAsyncResponseSink);

            (new UPnPDebugObject(Root)).SetField("NoSSDP",true);

            Root.StartDevice(PortNumber);
        }

        private static void AddSink(DimmableLightDiscovery sender, UPnPDevice d)
        {
            Console.WriteLine("Added Device: " + d.FriendlyName);

            // To interface with a service, instantiate the appropriate wrapper class on the appropriate service
            // Traverse the device heirarchy to the correct device, and invoke 'GetServices', passing in the static field 'SERVICE_NAME'
            // of the appropriate wrapper class. This method returns an array of all services with this service type. For most purposes,
            // there will only be one service, in which case you can use array index 0.
            // Save a reference to this instance of the wrapper class for later use.

            CpDimming Dimming = new CpDimming(d.GetServices(CpDimming.SERVICE_NAME)[0]);

            sw = new CpSwitchPower(d.GetServices(CpSwitchPower.SERVICE_NAME)[0]);

            // To subscribe to Events, call the '_subscribe' method of the wrapper class. The only parameter is
            // the duration of the event. A good value is 300 seconds.
            //Dimming._subscribe(300);

            // The wrapper class exposes all the evented state variables through events in the form 'OnStateVariable_xx', where xx is the variable name.

            // The wrapper class exposes methods in two formats. Asyncronous and Syncronous. The Async method calls are exposed simply
            // by the name of the method. The Syncronous version is the same, except with the word, 'Sync_' prepended to the name.
            // Asyncronous responses to th async method calls are dispatched through the event in the format, 'OnResult_x' where x is the method name.

            // Note: All arguments are automatically type checked. Allowed Values are abstracted through enumerations, that are defined in the wrapper class.
            // To access the list of allowed values or ranges for a given device, refer to the property 'Values_XXX' for a list of the allowed values for a
            // given state variable. Similarly, refer to the properties 'HasMaximum_XXX', 'HasMinimum_XXX', 'Maximum_XXX', and 'Minimum_XXX' where XXX is the variable name, for the Max/Min values.

            // To determine if a given service implements a particular StateVariable or Method, use the properties, 'HasStateVariableXXX' and 'HasActionXXX' where XXX is the method/variable name.
        }

        public override bool Generate(UPnPDevice[] devices, DirectoryInfo outputDirectory)
        {
            bool ok = false;
            bool RetVal = false;
            foreach (UPnPDevice device in devices)
            {
                if (((ServiceGenerator.Configuration)device.User).ConfigType == ServiceGenerator.ConfigurationType.CONTROLPOINT)
                {
                    ok = true;
                    if (Configuration.UPNP_1dot1)
                    {
                        device.ArchitectureVersion = "1.1";
                    }
                    else
                    {
                        device.ArchitectureVersion = "1.0";
                    }

                    device.ClearCustomFieldsInDescription();
                    ((ServiceGenerator.Configuration)device.User).AddAllCustomFieldsToDevice(device);

                    RetVal = GenerateEx(device, outputDirectory, GetServiceNameTable(device));
                    if (!RetVal) { break; }
                }
            }
            return (ok ? RetVal : true);
        }

		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;
				});
		}

        /// <summary>
        /// Creates a programmer-friendly object for using a device
        /// that happens implement a MediaServer.
        /// </summary>
        /// <param name="device"></param>
        public CpMediaServer(UPnPDevice device)
        {
            UPnPService sCM = device.GetServices(CpConnectionManager.SERVICE_NAME)[0];
            UPnPService sCD = device.GetServices(CpContentDirectory.SERVICE_NAME)[0];

            CpConnectionManager cpCM = new CpConnectionManager(sCM);
            CpContentDirectory cpCD = new CpContentDirectory(sCD);

            UDN = device.UniqueDeviceName;

            if (
                (cpCD.HasAction_GetSearchCapabilities == false) ||
                (cpCD.HasAction_GetSortCapabilities == false) ||
                (cpCD.HasAction_GetSystemUpdateID == false) ||
                (cpCD.HasAction_Browse == false)
                )
            {
                throw new UPnPCustomException(0, "MediaServer does not implement minimum features.");
            }

            this.m_ConnectionManager = cpCM;
            this.m_ContentDirectory = cpCD;

            //create a virtualized root container with the desired settings
            m_Root = new CpRootContainer(this);
            m_Root.UDN = device.UniqueDeviceName;
        }

        public UPnPDeviceHostServiceProxy(Assembly assembly)
        {
            this.Name = Environment.MachineName + ":" + assembly.FullName.Split(',').First();
            this.Namespace = assembly.FullName;
            var regex = new Regex("Version=(.\\..)");
            var version = regex.Match(this.Namespace).Groups[1].Value;
            this.Version = double.Parse(version);

            _device = UPnPDevice.CreateRootDevice(int.MaxValue, this.Version, "\\");
            _device.FriendlyName = this.Name;
            _device.DeviceURN = this.Namespace;
            _device.HasPresentation = false;

            var types = (from type in assembly.GetTypes()
                         let ifs = type.GetInterfaces().Where(t => t.GetCustomAttributes<ServiceContractAttribute>().Count() > 0).First()
                         select new { Type = type, Interface = ifs }).ToList();

            List<IUPnPService> services = new List<IUPnPService>();
            foreach (var tc in types)
            {
                var service = new UPnPServiceProxy(tc.Type, tc.Interface);
                services.Add(service);
                _device.AddService(service);
            }

            this.Services = services.ToList();
            _device = this.GetUPnPDevice();
        }

        public static string BuildDeviceDescriptionStreamer(UPnPDevice d, string templateString)
        {
            string WS = BuildDeviceDescriptionStreamer_EmbeddedDevice(d,"",SourceCodeRepository.GetTextBetweenTags(templateString,"//{{{DEVICE_BEGIN}}}","//{{{DEVICE_END}}}"));

            templateString = SourceCodeRepository.InsertTextBeforeTag(templateString,"//{{{DEVICE_BEGIN}}}",WS);
            templateString = SourceCodeRepository.RemoveAndClearTag("//{{{DEVICE_BEGIN}}}","//{{{DEVICE_END}}}",templateString);
            return(templateString);
        }

 public void ForceDisposeDevice(UPnPDevice root)
 {
     while (root.ParentDevice != null)
     {
         root = root.ParentDevice;
     }
     iSCP.SSDPNotifySink(null, null, null, false, root.UniqueDeviceName, "upnp:rootdevice", 0, null);
 }

 public static void GenerateStateVariableLookupTable(UPnPDevice d, Hashtable t)
 {
     foreach(UPnPDevice ed in d.EmbeddedDevices)
     {
         GenerateStateVariableLookupTable(ed,t);
     }
     foreach(UPnPService s in d.Services)
     {
         GenerateStateVariableLookupTable_Service(s,t);
     }
 }

 public void ForceDisposeDevice(UPnPDevice dev)
 {
     if (dev.ParentDevice != null)
     {
         ForceDisposeDevice(dev.ParentDevice);
     }
     else
     {
         scp.ForceDisposeDevice(dev);
     }
 }

        public ModifyDevice(UPnPDevice d)
        {
            OriginalDevice = d;
            NewDevice = OriginalDevice;

            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();
            ShowDevice(d);
        }

        /// <summary>
        /// Eventfunction that is run when an UPnP sink is detected on the network. Only accepts sinks with the friendly name: "HiPi - Sink". 
        /// If it has the right name then it creates three stacks (AVTransport, ConnectionManager and RenderingControl)
        /// </summary>
        /// <param name="sender">The object that send the event</param>
        /// <param name="d">The discovered sink device</param>
        private void AddSink(MediaRendererDiscovery sender, UPnPDevice d)
        {
            Console.WriteLine("Added Sink Device: " + d.FriendlyName);
            if (d.FriendlyName == "HiPi - Sink")
            {
                UPnP_SinkFunctions func = new UPnP_SinkFunctions(
                    new SinkStack.CpAVTransport(d.GetServices(SinkStack.CpAVTransport.SERVICE_NAME)[0]),
                    new SinkStack.CpConnectionManager(d.GetServices(SinkStack.CpConnectionManager.SERVICE_NAME)[0]),
                    new SinkStack.CpRenderingControl(d.GetServices(SinkStack.CpRenderingControl.SERVICE_NAME)[0]));

                AddSinkEvent(func, null);
            }
        }

        public CpContentDirectory GetCDS(UPnPDevice device)
        {
            UPnPDevice d = device;

            UPnPService[] services = d.GetServices(CpContentDirectory.SERVICE_NAME);

            if (services == null || services.Length == 0)
            {
                return null;
            }

            return new CpContentDirectory(services[0]);
        }

 public override void Start(UPnPDevice device)
 {
     if (ScriptorInterface != null)
     {
         Reset();
         ScriptorInterface.SetUPnPDevice(device);
         ScriptorInterface.Execute();
         for (int i=0; i<states.Length; i++)
         {
             if (state < states[i])
                 state = states[i];
         }
     }
 }