public RoomViewModel(IEventAggregator eventAggregatorInstance, IMessagingService messagingServiceInstance, ZoneViewModel zoneViewModelInstance, MediaRenderer roomRendererInstance, string name, string udn, string powerState)
{
eventAggregator = eventAggregatorInstance;
messagingService = messagingServiceInstance;
zoneViewModel = zoneViewModelInstance;
roomRenderer = roomRendererInstance;
Name = name;
Udn = udn;
this.powerState = powerState;
switch (powerState)
{
case "ACTIVE":
isActive = true;
break;
case "AUTOMATIC_STANDBY":
case "MANUAL_STANDBY":
isActive = false;
break;
default:
break;
}
GetRoomVolumeCommand.Execute(null);
GetRoomMuteCommand.Execute(null);
eventAggregator.GetEvent <PowerStateChangedEvent>().Subscribe(onPowerStateChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == roomRenderer);
}
void FileExplorerCfgPanel_HandleCreated(object sender, EventArgs e)
{
Translator.TranslateControl(this, DesignMode);
nudMaxProcessedFiles.Value = AddonAppConfig.MaxProcessedEntries;
nudPreviewTimer.Value = BuiltinAddonConfig.FEPreviewTimer;
Dictionary <string, string> tableLinkedFiles = ProTONEConfig.LinkedFilesTable;
if (tableLinkedFiles.Count < 1)
{
List <string> supChildrenForAudioTypes = new List <string>();
supChildrenForAudioTypes.Add("BMK");
List <string> supChildrenForVideoTypes = new List <string>();
supChildrenForVideoTypes.AddRange(MediaRenderer.GetSupportedFileProvider().SupportedSubtitles);
supChildrenForVideoTypes.Add("BMK");
tableLinkedFiles.Add(
StringUtils.FromStringArray(MediaRenderer.SupportedAudioTypes.ToArray(), ';'),
StringUtils.FromStringArray(supChildrenForAudioTypes.ToArray(), ';'));
tableLinkedFiles.Add(
StringUtils.FromStringArray(MediaRenderer.SupportedVideoTypes.ToArray(), ';'),
StringUtils.FromStringArray(supChildrenForVideoTypes.ToArray(), ';'));
ProTONEConfig.LinkedFilesTable = new Dictionary <string, string>(tableLinkedFiles);
}
}
private bool TestFile(string file)
{
if (_shouldCancelSearch.WaitOne(0))
{
return(false);
}
if (file == null || File.Exists(file) == false)
{
return(false);
}
if (SearchBookmarksActive())
{
BookmarkFileInfo bfi = new BookmarkFileInfo(file, false);
if (bfi == null ||
!bfi.IsValid ||
(theTask.Option1 && bfi.IsOrphan) || /* for BMK files: option 1 = non-orphan bookmarks */
(theTask.Option2 && !bfi.IsOrphan)) /* for BMK files: option 2 = orphan bookmarks */
{
return(false); // skip this file
}
}
else if (SearchMediaFilesActive())
{
if (!MediaRenderer.IsSupportedMedia(file))
{
return(false); // not a media file
}
MediaFileInfo mfi = MediaFileInfo.FromPath(file);
if (mfi == null ||
!mfi.IsValid ||
(theTask.Option1 && mfi.Bookmarks.Count < 1) || /* for media files: option 1 = files with bookmarks */
(theTask.Option2 && mfi.Bookmarks.Count > 0)) /* for media files: option 2 = files w/o bookmarks */
{
return(false); // skip this file
}
}
if (!theTask.UseAttributes || AttributesMatch(File.GetAttributes(file), true))
{
bool match =
(theTask.SearchText.Length == 0) ||
(theTask.SearchProperties && ContainsProperty(file)) ||
(!theTask.SearchProperties && ContainsText(file));
if (match && !_matchingItems.Contains(file.ToLowerInvariant()))
{
_matchingItems.Add(file.ToLowerInvariant());
_displayItems.Add(file);
return(true);
}
}
return(false);
}
private MediaRendererInstance()
{
//_renderer = MediaRenderer.NewInstance();
_renderer = MediaRenderer.DefaultInstance;
_renderer.MediaRendererClock += new MediaRendererEventHandler(_renderer_MediaRendererClock);
_renderer.MediaRendererHeartbeat += new MediaRendererEventHandler(_renderer_MediaRendererHeartbeat);
_renderer.MediaRenderingException += new MediaRenderingExceptionHandler(_renderer_MediaRenderingException);
_renderer.FilterStateChanged += new FilterStateChangedHandler(_renderer_FilterStateChanged);
}
private bool ContainsProperty(string file)
{
if (_shouldCancelSearch.WaitOne(0))
{
return(false);
}
try
{
// So far only media files can have "text" properties
if (MediaRenderer.IsSupportedMedia(file))
{
MediaFileInfo mfi = MediaFileInfo.FromPath(file);
if (mfi != null)
{
foreach (KeyValuePair <string, string> kvp in mfi.ExtendedInfo)
{
string keyword = theTask.SearchText;
string name = kvp.Key;
string value = kvp.Value;
if (theTask.IsCaseInsensitive)
{
keyword = keyword != null?keyword.ToLowerInvariant() : string.Empty;
name = name != null?name.ToLowerInvariant() : string.Empty;
value = value != null?value.ToLowerInvariant() : string.Empty;
}
if (name.Contains(keyword) || value.Contains(keyword))
{
return(true);
}
}
}
}
return(false);
}
finally
{
GC.Collect();
}
}
public static void UnregisterServer(string s)
{
try
{
Logger.LogInfo("Attempt to unregister OPMedia.ShellSupport ...");
SuiteRegistrationSupport.Init(MediaRenderer.GetSupportedFileProvider());
SuiteRegistrationSupport.UnregisterKnownFileTypes();
SuiteRegistrationSupport.UnregisterContextMenuHandler();
SuiteRegistrationSupport.ReloadFileAssociations();
Logger.LogInfo("OPMedia.ShellSupport was succesfully unregistered !");
}
catch (Exception exception)
{
ErrorDispatcher.DispatchFatalError("Fatal unregistration error: " + exception.Message);
}
}
private async Task AddMediaRendererAsync(DeviceDescription deviceDescription, Uri deviceDescriptionUrl)
{
if (_mediaRenderers.ContainsKey(deviceDescriptionUrl.AbsoluteUri))
{
return;
}
_mediaRenderers.Add(deviceDescriptionUrl.AbsoluteUri, null);
MediaRenderer mediaRenderer = new MediaRenderer(deviceDescription, deviceDescriptionUrl);
await mediaRenderer.InitAsync();
_mediaRenderers[deviceDescriptionUrl.AbsoluteUri] = mediaRenderer;
if (OnMediaRendererFound != null)
{
OnMediaRendererFound(this, new MediaRendererFoundEventArgs(mediaRenderer));
}
}
internal void Run()
{
log4net.Config.BasicConfigurator.Configure();
System.Console.Title = "Press 'q' to quit";
System.Console.WriteLine("Starting...");
using (var upnp = new UPnP())
{
server = new MediaRenderer("TestMediaRenderer", (UInt16)1569);
server.GetCurrentConnectionInfo += Server_GetCurrentConnectionInfo;
server.SetAVTransportURI += Server_SetAVTransportURI;
server.Play += Server_Play;
server.Pause += Server_Pause;
server.Seek += Server_Seek;
server.Stop += Server_Stop;
upnp.AddDeviceHost(server);
upnp.Start();
avt = server.Services.Where(s => s.ServiceType == "urn:schemas-upnp-org:service:AVTransport:1").FirstOrDefault();
#region handle keyboard
for (bool quit = false; !quit;)
{
switch (System.Console.ReadKey(true).KeyChar)
{
case 'q':
quit = true;
break;
}
}
#endregion
upnp.Stop();
}
System.Console.WriteLine("Stopped.");
}
private void BuildFields(string path)
{
if (this.IsServerURI)
{
mediaType = "URL";
}
else if (!string.IsNullOrEmpty(path))
{
try
{
string mediaName = base.Name;
mediaType = PathUtils.GetExtension(path);
MediaRenderer renderer = MediaRenderer.DefaultInstance;
if (!MediaRenderer.AllMediaTypes.Contains(mediaType))
{
throw new FileLoadException("Unexpected file type: " + mediaType,
base.Path);
}
// Check for bookmark file
string bookmarkPath = string.Format("{0}.bmk", path);
_bookmarkInfo = new BookmarkFileInfo(bookmarkPath, false);
_bookmarkInfo.BookmarkCollectionChanged +=
new EventHandler(_bookmarkInfo_BookmarkCollectionChanged);
}
catch (FileLoadException)
{
throw;
}
catch (FileNotFoundException)
{
throw;
}
catch
{
}
}
}
private void OnMenuOpening(object sender, CancelEventArgs e)
{
bool playerInstalled = File.Exists(ProTONEConfig.PlayerInstallationPath);
tsmiSepProTONE.Visible = tsmiProTONEEnqueue.Visible = tsmiProTONEPlay.Visible =
playerInstalled;
bool enable = false;
foreach (string path in GetSelectedItems())
{
if (MediaRenderer.IsSupportedMedia(path))
{
enable = true;
break;
}
}
tsmiProTONEEnqueue.Enabled = tsmiProTONEPlay.Enabled = enable;
tsmiTaggingWizard.Enabled = (lvResults.SelectedItems.Count == 1);
}
private void OnMenuOpening(object sender, CancelEventArgs e)
{
bool playerInstalled = File.Exists(ProTONEConfig.PlayerInstallationPath);
tsmiSepProTONE.Visible = tsmiProTONEEnqueue.Visible = tsmiProTONEPlay.Visible =
playerInstalled;
bool enable = false;
foreach (string vpath in GetSelectedItems())
{
CatalogItem ci = (BkgTask as Task).Catalog.GetByVPath(vpath);
if (ci != null && MediaRenderer.IsSupportedMedia(ci.OrigItemPath))
{
enable = true;
break;
}
}
tsmiProTONEEnqueue.Enabled = tsmiProTONEPlay.Enabled = enable;
//tsmiTaggingWizard.Enabled = (lvResults.SelectedItems.SelectedItems.Count == 1);
}
private void InitializeAllJoyn()
{
Task _t1 = new Task(() =>
{
Debug.UseOSLogging(true);
//Debug.SetDebugLevel("ALLJOYN", 7);
string connectSpec = "null:";
try
{
_bus = new BusAttachment(APPLICATION_NAME, true, 4);
}
catch (Exception ex)
{
QStatus stat = AllJoynException.GetErrorCode(ex.HResult);
}
_bus.Start();
_bus.ConnectAsync(connectSpec).AsTask().Wait();
_listeners = new Listeners(_bus, this);
_bus.RegisterBusListener(_listeners);
_mediaSink = new MediaSink(_bus);
_mediaRender = new MediaRenderer();
_mediaRender.OnOpen += OnOpen;
_mediaRender.OnPlay += OnPlay;
_mediaRender.OnPause += OnPause;
_mediaRender.OnClose += OnClose;
_bus.FindAdvertisedName(MEDIA_SERVER_NAME);
});
_t1.Start();
}
/// <summary>
/// Interpret a received string from the udp sockets
/// </summary>
/// <param name="received_string">the body of the udp packet</param>
/// <param name="was_broadcasted">TRUE if it was received via broadcast</param>
private void InterpretReceivedString(string received_string, bool was_broadcasted)
{
string message = "Received a";
IPEndPoint received_from;
if (was_broadcasted)
{
message += " broadcasted unpnp string ";
message += "from :" + ((IPEndPoint)broadcast_receive_from_endpoint).Address.ToString();
message += ":" + ((IPEndPoint)broadcast_receive_from_endpoint).Port.ToString();
received_from = (IPEndPoint)broadcast_receive_from_endpoint;
}
else
{
message += "n unicasted unpnp string ";
message += "from :" + ((IPEndPoint)receive_from_endpoint).Address.ToString();
message += ":" + ((IPEndPoint)receive_from_endpoint).Port.ToString();
received_from = (IPEndPoint)receive_from_endpoint;
}
message += ": ";
/*
Console.WriteLine("");
Console.WriteLine(message);
Console.WriteLine(received_string);
Console.WriteLine("");
//Console.WriteLine("Header Lines:");
*/
//Console.WriteLine(received_string);
string[] seps = {"\r\n"};
string[] lines = received_string.Split(seps, StringSplitOptions.RemoveEmptyEntries);
string uuid = "";
string urn = "";
string server = "";
string location = "";
string usn = "";
string mx = "";
string st = "";
string nt = "";
string man = "";
bool discovery_request = false;
foreach (string line in lines)
{
//Console.WriteLine("line:" + line);
if (line.StartsWith("MX:", true, null))
{
mx = line.Substring("MX:".Length).Trim();
}
if (line.StartsWith("MAN:", true, null))
{
man = line.Substring("MAN:".Length).Trim();
}
if (line.StartsWith("NT:", true, null))
{
nt = line.Substring("NT:".Length).Trim();
}
if (line.StartsWith("ST:", true, null))
{
st = line.Substring("ST:".Length).Trim();
}
if (line == "M-SEARCH * HTTP/1.1")
{
discovery_request = true;
}
if (line.StartsWith("SERVER:", true, null))
{
server = line.Substring(8);
}
if (line.StartsWith("LOCATION:", true, null))
{
location = line.Substring(10);
}
if (line.StartsWith("USN:",true,null))
{
usn = line.Substring(5);
//Console.WriteLine("Found an Unique Service Name: " + usn);
//checking if it looks a router
int uuid_start = usn.IndexOf("uuid:");
int urn_start = usn.IndexOf("urn:");
if (uuid_start != -1)
{
uuid_start += 5;
int uuid_end = usn.Substring(uuid_start).IndexOf("::");
if (uuid_end != -1)
{
uuid = usn.Substring(uuid_start, uuid_end);
uuid = uuid.Trim();
}
}
if (urn_start != -1)
{
urn_start += 4;
//int urn_end = usn.Substring(urn_start).IndexOf(":");
//if (urn_end != -1)
//{
urn = usn.Substring(urn_start);
//urn = usn.Substring(urn_start, urn_end);
urn = urn.Trim();
//}
}
}
}
if (discovery_request)
{//received a discovery request
lock (discovery_request_lock)
{
//check header options
//and answer if needed
Console.WriteLine("checking local devices for service matching the search request: " + st);
//Console.WriteLine("searches for: " + st);
lock (local_devices_lock)
{
foreach (LocalDevice device in local_devices)
{
if (st.Equals("upnp:rootdevice", StringComparison.CurrentCultureIgnoreCase))
{
ReplyDevice(device, received_from);
Thread.Sleep(50);
}
else if(st.Equals("ssdp:all", StringComparison.CurrentCultureIgnoreCase))
{
ReplyDevice(device, received_from);
Thread.Sleep(50);
ReplyDeviceServices(device, received_from);
Thread.Sleep(50);
ReplyRootDevice(device, received_from);
Thread.Sleep(50);
ReplyRootDeviceV2(device, received_from);
Thread.Sleep(50);
}
else
{
foreach (SubDevice.Service service in device.RootDevice.Services)
{
//Console.WriteLine("comparing: "+st+" and urn:"+service.ServiceType);
if (st.Equals("urn:" + service.ServiceType, StringComparison.CurrentCultureIgnoreCase))
{
Console.WriteLine("found applicable device + service: " + device.RootDevice.FriendlyName);
//ReplyDevice(device, received_from);
//ReplyDeviceService(device, service, received_from);
//Thread.Sleep(100);
//device.LastAnnouncementTime = DateTime.Now;
device.LastAnnouncementTime = DateTime.MinValue; //force reannouncing if the device missed a reply
//ReplyDeviceServices(device, received_from);
//ReplyRootDevice(device, received_from);
//ReplyRootDeviceV2(device, received_from);
}
}
}
}
}
//TODO Add response discovery method
}
}
else if (urn != "" && uuid != "" && server != "" && location != "" && usn != "" && !discovery_request)
{//found a usable packet for a device urn compare
if (urn == "schemas-upnp-org:service:WANIPConnection:1") //TODO maybe change this to InternetGatewayDevice
{//we found a router
//check if its a new or to be updated entry
Device existing = GetDeviceByUUID(uuid);
if (existing != null)
{//we need to update a router entry
Router updated = (Router)existing;
}
else
{//we discovered a new router
Router r = new Router(usn, location, server, uuid);
devices.Add(r);
if (DeviceDiscovered != null)
DeviceDiscovered(r);
}
}
else if (urn == "schemas-upnp-org:device:MediaRenderer:1")
{//we found a media renderer
//check if its a new or to be updated entry
Device existing = GetDeviceByUUID(uuid);
if (existing != null)
{//we need to update a media renderer entry
MediaRenderer updated = (MediaRenderer)existing;
}
else
{//we discovered a new media renderer
MediaRenderer mr = new MediaRenderer(usn, location, server, uuid);
devices.Add(mr);
if (DeviceDiscovered != null)
DeviceDiscovered(mr);
}
}
else if (urn == "schemas-upnp-org:device:BinaryLight:1")
{//we found a binary light
//check if its a new or to be updated entry
Device existing = GetDeviceByUUID(uuid);
if (existing != null)
{//we need to update a binary light entry
BinaryLight updated = (BinaryLight)existing;
}
else
{//we discovered a binary light
BinaryLight bl = new BinaryLight(usn, location, server, uuid);
devices.Add(bl);
if (DeviceDiscovered != null)
DeviceDiscovered(bl);
}
}
}
//Console.WriteLine("");
//Console.WriteLine("-- End of Message --");
//Console.WriteLine("");
}
public static void Test2(ILoggerFactory loggerFactory)
{
//var client = new HttpUClient();
//client.OnResponse += Client_OnResponse;
//client.BroadcastDisvoeryRequst();
//var rendererDiscovery = new AVRendererDiscovery((new AVRendererDiscovery.DiscoveryHandler(RendererAddedSink)));
//_containerDiscovery = ContainerDiscovery.GetInstance();
//_containerDiscovery.AllRoots.OnContainerChanged += new CpRootContainer.Delegate_OnContainerChanged(ContainerChangedSink);
var devicesDiscovery = new CommonUPnPDevicesDiscovery(loggerFactory);
// Receiving notifications about new devices added to a network
devicesDiscovery.DevicesActivity.Where(e => e.Activity == DeviceActivity.Available).Subscribe(e =>
{
Console.WriteLine("{0} found", e.Device.FriendlyName);
});
// Receiving notifications about devices left the network
devicesDiscovery.DevicesActivity.Where(e => e.Activity == DeviceActivity.Gone).Subscribe(e =>
{
Console.WriteLine("{0} gone", e.Device.FriendlyName);
});
// Receiving notifications about new devices of specific type added to the network
var newMediaServers = from activityInfo in devicesDiscovery.DevicesActivity
where activityInfo.Activity == DeviceActivity.Available && activityInfo.Device.DeviceType == "urn:schemas-upnp-org:device:MediaServer"
select activityInfo.Device;
newMediaServers.Subscribe(s =>
{
Console.WriteLine("{0} found", s.FriendlyName);
});
var mediaServersDiscovery = new MediaServersDiscovery(loggerFactory);
var mediaRenderersDiscovery = new MediaRenderersDiscovery(loggerFactory);
// Enumerating currently available servers
foreach (var server in mediaServersDiscovery.DiscoveredDevices)
{
Console.WriteLine("Server found: {0}", server.FriendlyName);
}
// Receiving notifications about new media servers added to a network
mediaServersDiscovery.DevicesActivity.Where(e => e.Activity == DeviceActivity.Available).Subscribe(async e =>
{
Console.WriteLine("Server found: {0}", e.Device.FriendlyName);
if (e.Device.FriendlyName == "raspberrypi: minidlna")
{
//var rootObjects = await e.Device.BrowseAsync();
//var rootContainers = rootObjects.OfType<MediaContainer>();
//var rootMediaItems = rootObjects.OfType<MediaItem>();
//// Requesting media objects from child container
//var containerToBrowse = rootContainers.First(x=>x.Title=="Video");
//var childContainerObjects = await e.Device.BrowseAsync(containerToBrowse);
// var videos = await e.Device.SearchAsync<VideoItem>();
_mini = e.Device;
}
});
// Receiving notifications about media renderers left the network
mediaRenderersDiscovery.DevicesActivity.Where(e => e.Activity == DeviceActivity.Available).Subscribe(e =>
{
Console.WriteLine("Renderer found: {0}", e.Device.FriendlyName);
if (e.Device.FriendlyName == "yangchao (CD-PC029 : Windows Media Player)")
{
_renderer = e.Device;
}
});
}
//REMEMBER TO LOCK / UNLOCK FrontBackMediaRenderer
private bool IsFrontMediaRenderer(MediaRenderer r)
{
return r == mediaRendererCurrent[r.GetMediaRendererIndex()];
}
public void Initialize(IntPtr pidlFolder, IntPtr pDataObj, IntPtr hKeyProgID)
{
if (pDataObj == IntPtr.Zero)
{
throw new ArgumentException();
}
ApplicationInfo.RegisterAppName(GetType().Assembly);
Translator.RegisterTranslationAssembly(GetType().Assembly);
Translator.SetInterfaceLanguage(AppConfig.LanguageID);
FORMATETC fe = new FORMATETC();
fe.cfFormat = (short)CLIPFORMAT.CF_HDROP;
fe.ptd = IntPtr.Zero;
fe.dwAspect = DVASPECT.DVASPECT_CONTENT;
fe.lindex = -1;
fe.tymed = TYMED.TYMED_HGLOBAL;
STGMEDIUM stm = new STGMEDIUM();
// The pDataObj pointer contains the objects being acted upon. In this
// example, we get an HDROP handle for enumerating the selected files
// and folders.
IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(pDataObj);
dataObject.GetData(ref fe, out stm);
try
{
// Get an HDROP handle.
IntPtr hDrop = stm.unionmember;
if (hDrop == IntPtr.Zero)
{
throw new ArgumentException();
}
// Determine how many files are involved in this operation.
uint nFiles = Shell32.DragQueryFile(hDrop, UInt32.MaxValue, null, 0);
// Enumerate the selected files and folders.
if (nFiles > 0)
{
this.fileList = new List <string>();
StringBuilder fileName = new StringBuilder(Kernel32.MAX_FILE_BUFFER);
for (uint i = 0; i < Math.Min(nFiles, Kernel32.MAX_FILES); i++)
{
// Get the next file name.
if (Shell32.DragQueryFile(hDrop, i, fileName, fileName.Capacity) != 0 &&
MediaRenderer.IsSupportedMedia(fileName.ToString()))
{
// Add the file name to the list.
fileList.Add(fileName.ToString());
}
}
// If we did not find any files we can work with, throw
// exception.
if (fileList.Count == 0)
{
Marshal.ThrowExceptionForHR(WinError.E_FAIL);
}
}
else
{
Marshal.ThrowExceptionForHR(WinError.E_FAIL);
}
}
catch (Exception ex)
{
//ErrorDispatcher.DispatchException(ex);
Logger.LogException(ex);
fileList.Clear();
}
finally
{
Ole32.ReleaseStgMedium(ref stm);
}
}
public async Task PlayAsync(MediaRenderer renderer, MediaItem media)
{
await renderer.OpenAsync(media);
await renderer.PlayAsync();
}
public ZoneViewModel(IEventAggregator eventAggregatorInstance, IMessagingService messagingServiceInstance, IShellViewModel shellViewModelInstance, IRaumFeldService raumFeldServiceInstance, MediaRenderer zoneViewModelRendererInstance)
{
eventAggregator = eventAggregatorInstance;
messagingService = messagingServiceInstance;
shellViewModel = shellViewModelInstance;
raumFeldService = raumFeldServiceInstance;
zoneViewModelRenderer = zoneViewModelRendererInstance;
RoomViewModels = new ObservableCollection <IRoomViewModel>();
ZoneViewModelTracks = new ObservableCollection <IElement>();
Name = zoneViewModelRendererInstance.Name != string.Empty ? zoneViewModelRendererInstance.Name : "UnassignedRooms".GetLocalized();
Udn = zoneViewModelRendererInstance.Udn != string.Empty ? zoneViewModelRendererInstance.Name : "UnassignedRooms".GetLocalized();
eventAggregator.GetEvent <MuteChangedEvent>().Subscribe(onMuteChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <VolumeChangedEvent>().Subscribe(onVolumeChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <RoomMutesChangedEvent>().Subscribe(onRoomMutesChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <RoomVolumesChangedEvent>().Subscribe(onRoomVolumesChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <AVTransportURIChangedEvent>().Subscribe(onAVTransportURIChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <AVTransportURIMetaDataChangedEvent>().Subscribe(onAVTransportURIMetaDataChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <CurrentTrackChangedEvent>().Subscribe(onCurrentTrackChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <CurrentTrackURIChangedEvent>().Subscribe(onCurrentTrackURIChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <CurrentPlayModeChangedEvent>().Subscribe(onCurrentPlayModeChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <CurrentTrackMetaDataChangedEvent>().Subscribe(onCurrentTrackMetaDataChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <CurrentTransportActionsChangedEvent>().Subscribe(onCurrentTransportActionsChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <NumberOfTracksChangedEvent>().Subscribe(onNumberOfTracksChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
eventAggregator.GetEvent <RoomStatesChangedEvent>().Subscribe(onRoomStatesChanged,
ThreadOption.UIThread, false,
device => device.MediaDevice == zoneViewModelRenderer);
GetZoneVolumeCommand.Execute(null);
GetZoneMuteCommand.Execute(null);
GetCurrentTransportActionsCommand.Execute(null);
GetTransportSettingsCommand.Execute(null);
GetMediaInfoCommand.Execute(null);
GetPositionInfoCommand.Execute(null);
}
public void Dispose()
{
_renderer.Dispose();
_renderer = null;
}
public MediaRendererFoundEventArgs(MediaRenderer mediaRenderer)
{
MediaRenderer = mediaRenderer;
}
private void OnUpdateUi(ToolStripItemCollection tsic)
{
if (tsic == null)
{
return;
}
bool playerInstalled = File.Exists(ProTONEConfig.PlayerInstallationPath);
tsmiSepProTONE.Visible = tsmiProTONEEnqueue.Visible = tsmiProTONEPlay.Visible =
playerInstalled;
for (int i = 0; i < tsic.Count; i++)
{
ToolStripItem btn = tsic[i] as ToolStripItem;
if (btn == null)
{
continue;
}
btn.Enabled = true;
string tag = btn.Tag as string;
if (string.IsNullOrEmpty(tag))
{
continue;
}
ToolAction action = ToolAction.ToolActionNothing;
try
{
action = (ToolAction)Enum.Parse(typeof(ToolAction), tag);
}
catch
{
action = ToolAction.ToolActionNothing;
}
if (action == ToolAction.ToolActionNothing)
{
continue;
}
List <string> selItems = opmShellList.SelectedPaths;
switch (action)
{
case ToolAction.ToolActionNewFolder:
btn.Enabled = true;
btn.Visible = true;
BuildMenuText(btn, "TXT_NEWFOLDER", string.Empty, OPMShortcut.CmdGenericNew);
break;
case ToolAction.ToolActionBack:
btn.Enabled = opmShellList.ExploreBackTarget.Length > 0;
BuildMenuText(btn, "TXT_BACK", opmShellList.ExploreBackTarget, OPMShortcut.CmdNavigateBack);
break;
case ToolAction.ToolActionFwd:
btn.Enabled = opmShellList.ExploreForwardTarget.Length > 0;
BuildMenuText(btn, "TXT_FORWARD", opmShellList.ExploreForwardTarget, OPMShortcut.CmdNavigateForward);
break;
case ToolAction.ToolActionUp:
btn.Enabled = !opmShellList.IsInDriveRoot;
BuildMenuText(btn, "TXT_UP", opmShellList.ParentFolderTarget, OPMShortcut.CmdNavigateUp);
break;
case ToolAction.ToolActionSearch:
BuildMenuText(btn, "TXT_SEARCH", string.Empty, OPMShortcut.CmdGenericSearch);
btn.Enabled = !string.IsNullOrEmpty(opmShellList.Path);
break;
case ToolAction.ToolActionReload:
BuildMenuText(btn, "TXT_REFRESH", string.Empty, OPMShortcut.CmdGenericRefresh);
btn.Enabled = !string.IsNullOrEmpty(opmShellList.Path);
break;
case ToolAction.ToolActionCopy:
BuildMenuText(btn, "TXT_COPY", string.Empty, OPMShortcut.CmdGenericCopy);
btn.Enabled = opmShellList.SelectedPaths.Count > 0;
break;
case ToolAction.ToolActionCut:
BuildMenuText(btn, "TXT_CUT", string.Empty, OPMShortcut.CmdGenericCut);
btn.Enabled = opmShellList.SelectedPaths.Count > 0;
break;
case ToolAction.ToolActionDelete:
BuildMenuText(btn, "TXT_DELETE", string.Empty, OPMShortcut.CmdGenericDelete);
btn.Enabled = opmShellList.SelectedPaths.Count > 0;
break;
case ToolAction.ToolActionPaste:
BuildMenuText(btn, "TXT_PASTE", string.Empty, OPMShortcut.CmdGenericPaste);
btn.Enabled = (_pasteFileTask != null &&
(_pasteFileTask.FileTaskType == FileTaskType.Copy || _pasteFileTask.FileTaskType == FileTaskType.Move));
break;
case ToolAction.ToolActionRename:
BuildMenuText(btn, "TXT_RENAME", string.Empty, OPMShortcut.CmdGenericRename);
btn.Enabled = opmShellList.SelectedPaths.Count == 1;
break;
case ToolAction.ToolActionProTONEEnqueue:
case ToolAction.ToolActionProTONEPlay:
if (btn.Visible)
{
string text = (action == ToolAction.ToolActionProTONEEnqueue) ?
"TXT_PROTONE_ENQUEUE" : "TXT_PROTONE_PLAY";
BuildMenuText(btn, text, string.Empty, OPMShortcut.CmdOutOfRange);
bool enable = false;
foreach (string path in opmShellList.SelectedPaths)
{
if (MediaRenderer.IsSupportedMedia(path))
{
enable = true;
break;
}
}
btn.Enabled = enable;
}
break;
case ToolAction.ToolActionTaggingWizard:
BuildMenuText(btn, "TXT_TAGGINGWIZARD", string.Empty, OPMShortcut.CmdTaggingWizard);
break;
case ToolAction.ToolActionCdRipper:
BuildMenuText(btn, "TXT_CDRIPPERWIZARD", string.Empty, OPMShortcut.CmdCdRipperWizard);
break;
case ToolAction.ToolActionListDrives:
BuildMenuText(btn, "TXT_DRIVES", string.Empty, OPMShortcut.CmdChangeDisk);
break;
case ToolAction.ToolActionFavoritesAdd:
btn.Visible = true;
BuildMenuText(btn, "TXT_FAVORITES_ADD", string.Empty, OPMShortcut.CmdOutOfRange);
break;
case ToolAction.ToolActionFavoritesManage:
btn.Visible = true;
BuildMenuText(btn, "TXT_FAVORITES_MANAGE", string.Empty, OPMShortcut.CmdFavManager);
break;
case ToolAction.ToolActionFavoriteFolders:
btn.Visible = true;
BuildMenuText(btn, "TXT_FAVORITES", string.Empty, OPMShortcut.CmdOutOfRange);
break;
}
}
}
/// <summary>
/// Get Raumfeld DeviceDescription and create new MediaServer
/// </summary>
/// <returns></returns>
//private async Task<MediaServer> loadMediaServerAsync()
//{
// //if ((raumfeldDevices?.Devices?.Count() ?? 0) == 0 || server == null) { return null; }
// string uuid = ((Guid)server.Properties["System.Devices.ContainerId"]).ToString().ToLower();
// try
// {
// string serverDescription = raumfeldDevices.Devices.Where(server => server.Udn.Replace("uuid:", "").ToLower() == uuid).Select(server => server.Location).FirstOrDefault();
// if (!string.IsNullOrEmpty(serverDescription))
// {
// Uri serverUri = new Uri(serverDescription);
// var httpFilter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter();
// httpFilter.CacheControl.ReadBehavior = Windows.Web.Http.Filters.HttpCacheReadBehavior.NoCache;
// using (HttpClient client = new HttpClient())
// {
// using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, serverUri))
// {
// request.Headers.Add("User-Agent", "RaumfeldControl/0.0 RaumfeldProtocol/1"); /* RaumfeldControl/3.6 RaumfeldProtocol/399 Build => https://github.com/masmu/pulseaudio-dlna/issues/227 */
// request.Headers.Add("Accept-Language", "en");
// request.Headers.Add("ContentType", "text/xml; charset=\"utf - 8\"");
// using (HttpResponseMessage response = await client.SendRequestAsync(request))
// {
// if (response.StatusCode == Windows.Web.Http.HttpStatusCode.Ok)
// {
// string xmlString = await response.Content.ReadAsStringAsync();
// XmlDocument xmlDocument = new XmlDocument();
// xmlDocument.LoadXml(xmlString);
// if (xmlDocument != null)
// {
// DeviceDescription deviceDescription = xmlDocument.GetXml().Deserialize<DeviceDescription>();
// MediaServer mediaServer = new MediaServer(deviceDescription, serverUri.Host, serverUri.Port)
// {
// DeviceType = MediaDeviceType.MediaServer
// };
// await mediaServer.LoadServicesAsync();
// return mediaServer;
// }
// }
// }
// }
// }
// }
// }
// catch (Exception exception)
// {
// await UIService.ShowDialogAsync(string.Format("{0} {1}: {2}", UIService.GetResource("Error"), exception.HResult, exception.Message), "LoadMediaServer");
// Logger.GetLogger().SaveMessage(exception, "LoadMediaServerAsync");
// }
// return null;
//}
/// <summary>
/// Get Raumfeld DeviceDescription and create new MediaRenderer
/// </summary>
/// <returns></returns>
//private async Task<MediaRenderer> loadMediaRendererAsync(string rendererDescription, MediaDeviceType mediaDeviceType)
//{
// //if ((raumfeldDevices?.Devices?.Count() ?? 0) == 0 || server == null) { return null; }
// try
// {
// if (!string.IsNullOrEmpty(rendererDescription))
// {
// Uri serverUri = new Uri(rendererDescription);
// var httpFilter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter();
// httpFilter.CacheControl.ReadBehavior = Windows.Web.Http.Filters.HttpCacheReadBehavior.NoCache;
// using (HttpClient client = new HttpClient(httpFilter))
// {
// using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, serverUri))
// {
// request.Headers.Add("User-Agent", "RaumfeldControl/0.0 RaumfeldProtocol/1"); /* RaumfeldControl/3.6 RaumfeldProtocol/399 Build => https://github.com/masmu/pulseaudio-dlna/issues/227 */
// request.Headers.Add("Accept-Language", "en");
// request.Headers.Add("ContentType", "text/xml; charset=\"utf - 8\"");
// using (HttpResponseMessage response = await client.SendRequestAsync(request))
// {
// if (response.StatusCode == Windows.Web.Http.HttpStatusCode.Ok)
// {
// string xmlString = await response.Content.ReadAsStringAsync();
// XmlDocument xmlDocument = new XmlDocument();
// xmlDocument.LoadXml(xmlString);
// if (xmlDocument != null)
// {
// DeviceDescription deviceDescription = xmlDocument.GetXml().Deserialize<DeviceDescription>();
// MediaRenderer mediaRenderer = new MediaRenderer(deviceDescription, serverUri.Host, serverUri.Port);
// await mediaRenderer.LoadServicesAsync();
// mediaRenderer.DeviceType = mediaDeviceType;
// return mediaRenderer;
// }
// }
// }
// }
// }
// }
// }
// catch (Exception exception)
// {
// await UIService.ShowDialogAsync(string.Format("{0} {1}: {2}", UIService.GetResource("Error"), exception.HResult, exception.Message), "LoadMediaRenderer");
// Logger.GetLogger().SaveMessage(exception, "LoadMediaRendererAsync");
// }
// return null;
//}
/// <summary>
/// Get Raumfeld DeviceDescription and create new MediaRenderer
/// </summary>
/// <returns></returns>
private async Task <MediaDevice> loadMediaDeviceAsync(string rendererDescription, MediaDeviceType mediaDeviceType)
{
try
{
if (!string.IsNullOrEmpty(rendererDescription))
{
Uri serverUri = new Uri(rendererDescription);
var httpFilter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter();
httpFilter.CacheControl.ReadBehavior = Windows.Web.Http.Filters.HttpCacheReadBehavior.NoCache;
using (HttpClient client = new HttpClient(httpFilter))
{
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, serverUri))
{
request.Headers.Add("User-Agent", "RaumfeldControl/0.0 RaumfeldProtocol/1"); /* RaumfeldControl/3.6 RaumfeldProtocol/399 Build => https://github.com/masmu/pulseaudio-dlna/issues/227 */
request.Headers.Add("Accept-Language", "en");
request.Headers.Add("ContentType", "text/xml; charset=\"utf - 8\"");
using (HttpResponseMessage response = await client.SendRequestAsync(request))
{
if (response.StatusCode == Windows.Web.Http.HttpStatusCode.Ok)
{
string xmlString = await response.Content.ReadAsStringAsync();
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xmlString);
if (xmlDocument != null)
{
DeviceDescription deviceDescription = xmlDocument.GetXml().Deserialize <DeviceDescription>();
if (mediaDeviceType == MediaDeviceType.MediaServer)
{
MediaServer mediaServer = new MediaServer(deviceDescription, serverUri.Host, serverUri.Port)
{
DeviceType = mediaDeviceType
};
await mediaServer.LoadServicesAsync();
return(mediaServer);
}
else
{
MediaRenderer mediaRenderer = new MediaRenderer(deviceDescription, serverUri.Host, serverUri.Port)
{
DeviceType = mediaDeviceType
};
await mediaRenderer.LoadServicesAsync();
mediaRenderer.DeviceType = mediaDeviceType;
return(mediaRenderer);
}
}
}
}
}
}
}
}
catch (Exception exception)
{
await UIService.ShowDialogAsync(string.Format("{0} {1}: {2}", UIService.GetResource("Error"), exception.HResult, exception.Message), "loadMediaDeviceAsync");
Logger.GetLogger().SaveMessage(exception, "loadMediaDeviceAsync");
}
return(null);
}
private void OnUpdateUi(ToolStripItemCollection tsic)
{
if (tsic == null)
{
return;
}
bool playerInstalled = File.Exists(ProTONEConfig.PlayerInstallationPath);
tsmiSepProTONE.Visible = tsmiProTONEEnqueue.Visible = tsmiProTONEPlay.Visible =
playerInstalled;
for (int i = 0; i < tsic.Count; i++)
{
ToolStripItem btn = tsic[i] as ToolStripItem;
if (btn == null)
{
continue;
}
btn.Enabled = true;
string tag = btn.Tag as string;
if (string.IsNullOrEmpty(tag))
{
continue;
}
ToolAction action = ToolAction.ToolActionNothing;
try
{
action = (ToolAction)Enum.Parse(typeof(ToolAction), tag);
}
catch
{
action = ToolAction.ToolActionNothing;
}
if (action == ToolAction.ToolActionNothing)
{
continue;
}
List <string> selItems = GetSelectedVPaths();
switch (action)
{
case ToolAction.ToolActionNew:
BuildMenuText(btn, "TXT_NEW", string.Empty, OPMShortcut.CmdGenericNew);
break;
case ToolAction.ToolActionOpen:
BuildMenuText(btn, "TXT_OPEN", string.Empty, OPMShortcut.CmdGenericOpen);
break;
case ToolAction.ToolActionSave:
BuildMenuText(btn, "TXT_SAVE", string.Empty, OPMShortcut.CmdGenericSave);
btn.Enabled = (_cat != null);
break;
case ToolAction.ToolActionSaveAs:
BuildMenuText(btn, "TXT_SAVE_AS", string.Empty, OPMShortcut.CmdOutOfRange);
btn.Enabled = (_cat != null);
break;
case ToolAction.ToolActionBack:
btn.Enabled = ExploreBackTarget != null;
BuildMenuText(btn, "TXT_BACK", ExploreBackTarget, OPMShortcut.CmdNavigateBack);
break;
case ToolAction.ToolActionFwd:
btn.Enabled = ExploreForwardTarget != null;
BuildMenuText(btn, "TXT_FORWARD", ExploreForwardTarget, OPMShortcut.CmdNavigateForward);
break;
case ToolAction.ToolActionUp:
btn.Enabled = _cat != null;
string parentName = (ParentFolderTarget == null) ? Translator.Translate("TXT_ROOT") :
ParentFolderTarget.OrigItemPath.Replace("$:", ParentFolderTarget.RootItemLabel);
BuildMenuText(btn, "TXT_UP", parentName, OPMShortcut.CmdNavigateUp);
break;
case ToolAction.ToolActionSearch:
BuildMenuText(btn, "TXT_SEARCH", string.Empty, OPMShortcut.CmdGenericSearch);
btn.Enabled = (_cat != null);
break;
case ToolAction.ToolActionReload:
BuildMenuText(btn, "TXT_REFRESH", string.Empty, OPMShortcut.CmdGenericRefresh);
btn.Enabled = (_curFolder != null);
break;
case ToolAction.ToolActionDelete:
BuildMenuText(btn, "TXT_DELETE", string.Empty, OPMShortcut.CmdGenericDelete);
btn.Enabled = GetSelectedVPaths().Count > 0;
break;
case ToolAction.ToolActionCopy:
case ToolAction.ToolActionCut:
#if MC_COPY_PASTE
btn.Visible = true;
btn.Enabled = GetSelectedVPaths().Count > 0;
#else
btn.Visible = false;
btn.Enabled = false;
#endif
break;
case ToolAction.ToolActionPaste:
#if MC_COPY_PASTE
btn.Enabled = (_fileTask != null &&
(_fileTask.FileTaskType == FileTaskType.Copy || _fileTask.FileTaskType == FileTaskType.Move));
btn.Visible = true;
#else
btn.Visible = false;
btn.Enabled = false;
#endif
break;
case ToolAction.ToolActionMerge:
BuildMenuText(btn, "TXT_MERGECATALOGS", string.Empty, OPMShortcut.CmdCatalogMerge);
btn.Enabled = (_cat != null && _cat.IsValid);
break;
case ToolAction.ToolActionCatalog:
BuildMenuText(btn, "TXT_CATALOG", string.Empty, OPMShortcut.CmdCatalogWizard);
btn.Enabled = (_cat == null || !_cat.IsInDefaultLocation);
break;
case ToolAction.ToolActionRename:
BuildMenuText(btn, "TXT_RENAME", string.Empty, OPMShortcut.CmdGenericRename);
btn.Enabled = GetSelectedVPaths().Count == 1;
break;
case ToolAction.ToolActionProTONEEnqueue:
case ToolAction.ToolActionProTONEPlay:
if (btn.Visible)
{
string text = (action == ToolAction.ToolActionProTONEEnqueue) ?
"TXT_PROTONE_ENQUEUE" : "TXT_PROTONE_PLAY";
BuildMenuText(btn, text, string.Empty, OPMShortcut.CmdOutOfRange);
bool enable = false;
foreach (string path in GetSelectedOrigPaths())
{
if (MediaRenderer.IsSupportedMedia(path))
{
enable = true;
break;
}
}
btn.Enabled = enable;
}
break;
}
}
}
private void CreateMediaRenderer(int index)
{
Log(LogType.Debug, "++++++++ creating renderer pair " + index + " ++++++++");
mediaRendererBackFrontMutex[index] = new Mutex();
mediaRendererBackFrontMutex[index].WaitOne();
mediaRendererA[index] = new MediaRenderer(this, index);
mediaRendererB[index] = new MediaRenderer(this, index);
mediaRendererCurrent[index] = mediaRendererA[index];
mediaRendererNext[index] = mediaRendererB[index];
FImageOut[index] = mediaRendererCurrent[index].GetCVImageLink();
mediaRendererBackFrontMutex[index].ReleaseMutex();
Log(LogType.Debug, "++++++++ renderer pair " + index + " created ++++++++");
}
