void startVideoLoading(string url, bool useMPSourceFilter = false)
{
PlayItemsModel.CheckQueryPlayAction(new VideoItem(url));
lastVideoUrl = url;
lastVideoSessionId = currentVideoSessionId;
lastUseMPUrlSourceFilter = useMPSourceFilter;
}
protected void FillList(IContentDirectory contentDirectory, Guid[] necessaryMIAs, ItemsList list, MediaItemToListItemAction converterAction)
{
MediaItemQuery query = new MediaItemQuery(necessaryMIAs, null)
{
Limit = (uint)QueryLimit, // Last 5 imported items
SortInformation = new List <SortInformation> {
new SortInformation(ImporterAspect.ATTR_DATEADDED, SortDirection.Descending)
}
};
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
var items = contentDirectory.Search(query, false, userProfile, false);
list.Clear();
foreach (MediaItem mediaItem in items)
{
PlayableMediaItem listItem = converterAction(mediaItem);
listItem.Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(listItem.MediaItem));
list.Add(listItem);
}
list.FireChange();
}
public override async Task <AsyncResult <ContentDirectoryMessaging.MediaItemChangeType> > ProcessAsync(MediaItem mediaItem)
{
await PlayItemsModel.PlayOrEnqueueItem(mediaItem, false, PlayerContextConcurrencyMode.None);
AsyncResult <ContentDirectoryMessaging.MediaItemChangeType> result = new AsyncResult <ContentDirectoryMessaging.MediaItemChangeType>(true, ContentDirectoryMessaging.MediaItemChangeType.None);
return(result);
}
public SlimTvFavoriteRecordingsMediaListProvider()
{
_necessaryMias = SlimTvConsts.NECESSARY_RECORDING_MIAS;
_optionalMias = SlimTvConsts.OPTIONAL_RECORDING_MIAS;
_playableConverterAction = mi => new RecordingItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
};
}
protected async void StartupCheck()
{
//Check if any removable drives are currently mounted
var tasks = DriveInfo.GetDrives().Where(driveInfo => driveInfo.DriveType == DriveType.CDRom || driveInfo.DriveType == DriveType.Removable).
Select(driveInfo => Task.Run(() => ExamineVolume(driveInfo.Name)));
await Task.WhenAll(tasks);
PlayItemsModel.AddOrUpdateRemovableMediaItems(_removableMediaItems.Values.SelectMany(i => i));
}
public SlimTvUnwatchedRecordingsMediaListProvider()
{
_necessaryMias = SlimTvConsts.NECESSARY_RECORDING_MIAS;
//Needed for calculating play percentage
_optionalMias = new Guid[] { VideoStreamAspect.ASPECT_ID };
_playableConverterAction = mi => new RecordingItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
};
}
protected override async Task PrepareAsync()
{
await base.PrepareAsync();
AbstractItemsScreenData.PlayableItemCreatorDelegate picd = mi => new RecordingItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
};
_defaultScreen = new RecordingsShowItemsScreenData(picd);
_availableScreens = new List <AbstractScreenData>
{
_defaultScreen,
new RecordingFilterByNameScreenData(),
new RecordingsFilterByChannelScreenData(),
//new VideosFilterByActorScreenData(),
//new VideosFilterByDirectorScreenData(),
//new VideosFilterByWriterScreenData(),
//new VideosFilterByGenreScreenData(),
//new VideosFilterByYearScreenData(),
//new VideosFilterBySystemScreenData(),
new RecordingsSimpleSearchScreenData(picd),
};
_defaultSorting = new SortByRecordingDateDesc();
_availableSortings = new List <Sorting>
{
_defaultSorting,
new SortByTitle(),
//new VideoSortByFirstGenre(),
//new VideoSortByDuration(),
//new VideoSortByFirstActor(),
//new VideoSortByFirstDirector(),
//new VideoSortByFirstWriter(),
//new VideoSortBySize(),
//new VideoSortByAspectRatio(),
//new SortBySystem(),
};
var optionalMias = new[]
{
MovieAspect.ASPECT_ID,
EpisodeAspect.ASPECT_ID,
AudioAspect.ASPECT_ID,
VideoAspect.ASPECT_ID,
VideoStreamAspect.ASPECT_ID,
VideoAudioStreamAspect.ASPECT_ID,
ImageAspect.ASPECT_ID
}.Union(MediaNavigationModel.GetMediaSkinOptionalMIATypes(MediaNavigationMode));
_customRootViewSpecification = new StackingViewSpecification(_viewName, null, _necessaryMias, optionalMias, true)
{
MaxNumItems = Consts.MAX_NUM_ITEMS_VISIBLE
};
}
public async Task <bool> StartTimeshiftAsync(int slotIndex, IChannel channel)
{
if (TimeshiftControl == null || channel == null)
{
return(false);
}
ServiceRegistration.Get <ILogger>().Debug("SlimTvHandler: StartTimeshift slot {0} for channel '{1}'", slotIndex, channel.Name);
int newSlotIndex = GetMatchingSlotIndex(slotIndex);
if (_slotContexes[newSlotIndex].Channel != null && _slotContexes[newSlotIndex].Channel.MediaType != channel.MediaType)
{
// Switching between TV and radio - must close old player and start brand new one
IPlayerContext playerContext = existingPlayerContext(newSlotIndex);
if (playerContext == null)
{
return(false);
}
playerContext.Close();
await StopTimeshiftAsync(newSlotIndex);
}
var result = await TimeshiftControl.StartTimeshiftAsync(newSlotIndex, channel);
IList <MultipleMediaItemAspect> pras;
MediaItem timeshiftMediaItem = result.Result;
if (result.Success && timeshiftMediaItem != null && MediaItemAspect.TryGetAspects(timeshiftMediaItem.Aspects, ProviderResourceAspect.Metadata, out pras))
{
string newAccessorPath = (string)pras[0].GetAttributeValue(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH);
// if slot was empty, start a new player
if (_slotContexes[newSlotIndex].AccessorPath == null)
{
AddOrUpdateTimeshiftContext(timeshiftMediaItem as LiveTvMediaItem, channel);
PlayerContextConcurrencyMode playMode = GetMatchingPlayMode();
await PlayItemsModel.PlayOrEnqueueItem(timeshiftMediaItem, true, playMode);
}
else
{
try
{
_slotContexes[newSlotIndex].CardChanging = true;
UpdateExistingMediaItem(timeshiftMediaItem, newSlotIndex);
}
finally
{
_slotContexes[newSlotIndex].CardChanging = false;
}
}
_slotContexes[newSlotIndex].AccessorPath = newAccessorPath;
_slotContexes[newSlotIndex].Channel = channel;
}
return(result.Success);
}
public SlimTvLatestRecordingsMediaListProvider()
{
_necessaryMias = SlimTvConsts.NECESSARY_RECORDING_MIAS;
_optionalMias = new Guid[] {
VideoStreamAspect.ASPECT_ID, // Needed for calculating play percentage
VideoAspect.Metadata.AspectId, // Needed for playing TV recording
AudioAspect.Metadata.AspectId // Needed for playing Radio recording
};
_playableConverterAction = mi => new RecordingItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
};
}
/// <summary>
/// Constructs a dynamic <see cref="MediaItem"/> that contains the URL for the given <paramref name="stream"/> and starts the playback.
/// </summary>
/// <param name="stream">Stream.</param>
public static void PlayStream(MyStream stream)
{
var mediaItem = CreateStreamMediaItem(stream);
if (ServiceRegistration.Get <IPlayerContextManager>().IsVideoContextActive)
{
PlayItemsModel.CheckQueryPlayAction(mediaItem);
}
else
{
PlayItemsModel.PlayItem(mediaItem);
}
}
void startPlayback()
{
AudioBufferStream stream = airtunesServer.GetStream(StreamType.Wave);
if (stream != null)
{
AudioItem item = new AudioItem(new PlayerSettings(stream));
setMetaData(item);
PlayItemsModel.CheckQueryPlayAction(item);
setDuration();
isAudioPlaying = true;
}
}
protected void LaunchLibRetroGame(string path, EmulatorConfiguration configuration, bool isExtractedPath)
{
LibRetroMediaItem mediaItem = new LibRetroMediaItem(configuration.Path, _mediaItem.Aspects);
if (isExtractedPath)
{
mediaItem.ExtractedPath = path;
}
else
{
Cleanup();
}
PlayItemsModel.CheckQueryPlayAction(mediaItem);
}
protected BaseNavigationInitializer()
{
// Create a generic delegate that knows all kind of our inbuilt media item types.
_genericPlayableItemCreatorDelegate = mi =>
{
if (mi.Aspects.ContainsKey(EpisodeAspect.ASPECT_ID))
{
return new EpisodeItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
}
}
;
if (mi.Aspects.ContainsKey(MovieAspect.ASPECT_ID))
{
return new MovieItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
}
}
;
if (mi.Aspects.ContainsKey(AudioAspect.ASPECT_ID))
{
return new AudioItem(mi)
{
Command = new MethodDelegateCommand(() => MediaNavigationModel.AddCurrentViewToPlaylist(mi))
}
}
;
if (mi.Aspects.ContainsKey(VideoAspect.ASPECT_ID))
{
return new VideoItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
}
}
;
if (mi.Aspects.ContainsKey(ImageAspect.ASPECT_ID))
{
return new ImageItem(mi)
{
Command = new MethodDelegateCommand(() => MediaNavigationModel.AddCurrentViewToPlaylist(mi))
}
}
;
return(null);
};
}
public void InitMediaNavigation(out string mediaNavigationMode, out NavigationData navigationData)
{
IEnumerable <Guid> skinDependentOptionalMIATypeIDs = MediaNavigationModel.GetMediaSkinOptionalMIATypes(MediaNavigationMode);
AbstractItemsScreenData.PlayableItemCreatorDelegate picd = mi => new VideoItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
};
ViewSpecification rootViewSpecification = new MediaLibraryQueryViewSpecification(Consts.RES_VIDEOS_VIEW_NAME,
null, Consts.NECESSARY_VIDEO_MIAS, skinDependentOptionalMIATypeIDs, true)
{
MaxNumItems = Consts.MAX_NUM_ITEMS_VISIBLE
};
AbstractScreenData filterByGenre = new VideosFilterByGenreScreenData();
ICollection <AbstractScreenData> availableScreens = new List <AbstractScreenData>
{
new VideosShowItemsScreenData(picd),
new VideosFilterByLanguageScreenData(),
new VideosFilterByActorScreenData(),
filterByGenre,
// C# doesn't like it to have an assignment inside a collection initializer
new VideosFilterByYearScreenData(),
new VideosFilterBySystemScreenData(),
new VideosSimpleSearchScreenData(picd),
};
Sorting.Sorting sortByTitle = new SortByTitle();
ICollection <Sorting.Sorting> availableSortings = new List <Sorting.Sorting>
{
sortByTitle,
new SortByYear(),
new VideoSortByFirstGenre(),
new VideoSortByDuration(),
new VideoSortByDirector(),
new VideoSortByFirstActor(),
new VideoSortBySize(),
new VideoSortByAspectRatio(),
new SortBySystem(),
};
navigationData = new NavigationData(null, Consts.RES_VIDEOS_VIEW_NAME, MediaNavigationRootState,
MediaNavigationRootState, rootViewSpecification, filterByGenre, availableScreens, sortByTitle)
{
AvailableSortings = availableSortings
};
mediaNavigationMode = MediaNavigationMode;
}
public bool WatchRecordingFromBeginning(IProgram program)
{
string fileOrStream;
if (ScheduleControl.GetRecordingFileOrStream(program, out fileOrStream))
{
IChannel channel;
if (ChannelAndGroupInfo.GetChannel(program.ChannelId, out channel))
{
MediaItem recordig = SlimTvMediaItemBuilder.CreateRecordingMediaItem(0, fileOrStream, program, channel);
PlayItemsModel.CheckQueryPlayAction(recordig);
return(true);
}
}
return(false);
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == RemovableMediaMessaging.CHANNEL)
{
RemovableMediaMessaging.MessageType messageType = (RemovableMediaMessaging.MessageType)message.MessageType;
if (messageType == RemovableMediaMessaging.MessageType.MediaInserted)
{
string drive = (string)message.MessageData[RemovableMediaMessaging.DRIVE_LETTER];
var type = ExamineVolume(drive);
if (_removableMediaItems.TryGetValue(drive, out var items))
{
PlayItemsModel.AddOrUpdateRemovableMediaItems(items);
}
RemovableMediaManagerSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <RemovableMediaManagerSettings>();
if (settings.AutoPlay == AutoPlayType.AutoPlay)
{
IPlayerContextManager pcm = ServiceRegistration.Get <IPlayerContextManager>();
if (!pcm.IsFullscreenContentWorkflowStateActive)
{
CheckAutoPlay(drive, type);
}
}
}
else if (messageType == RemovableMediaMessaging.MessageType.MediaRemoved)
{
string drive = (string)message.MessageData[RemovableMediaMessaging.DRIVE_LETTER];
IEnumerable <MediaItem> items;
if (_removableMediaItems.TryRemove(drive, out items))
{
PlayItemsModel.RemoveRemovableMediaItems(items);
}
if (_removableMediaItems.TryRemove(drive + @"\", out items))
{
PlayItemsModel.RemoveRemovableMediaItems(items);
}
}
}
else if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType = (ServerConnectionMessaging.MessageType)message.MessageType;
if (messageType == ServerConnectionMessaging.MessageType.HomeServerConnected && _runStartupCheck)
{
_runStartupCheck = false;
StartupCheck();
}
}
}
public bool WatchRecordingFromBeginning(IProgram program)
{
string fileOrStream;
if (ScheduleControl.GetRecordingFileOrStream(program, out fileOrStream))
{
IChannel channel;
if (ChannelAndGroupInfo.GetChannel(program.ChannelId, out channel))
{
MediaItem recordig = SlimTvMediaItemBuilder.CreateRecordingMediaItem(0, fileOrStream, program, channel);
PlayerContextConcurrencyMode playMode = GetMatchingPlayMode();
PlayItemsModel.PlayOrEnqueueItem(recordig, true, playMode);
return(true);
}
}
return(false);
}
public async Task <bool> WatchRecordingFromBeginningAsync(IProgram program)
{
var result = await ScheduleControl.GetRecordingFileOrStreamAsync(program);
if (result.Success)
{
string fileOrStream = result.Result;
var channelResult = await ChannelAndGroupInfo.GetChannelAsync(program.ChannelId);
if (channelResult.Success)
{
MediaItem recordig = SlimTvMediaItemBuilder.CreateRecordingMediaItem(0, fileOrStream, program, channelResult.Result);
PlayItemsModel.CheckQueryPlayAction(recordig);
return(true);
}
}
return(false);
}
protected void CheckAutoPlay(string drive, AVType type)
{
if (string.IsNullOrEmpty(drive))
{
return;
}
if (_removableMediaItems.TryGetValue(drive, out var items))
{
if (type == AVType.None)
{
PlayItemsModel.CheckQueryPlayAction(() => items);
}
else
{
PlayItemsModel.CheckQueryPlayAction(() => items, type);
}
}
}
public bool StartTimeshift(int slotIndex, IChannel channel)
{
if (TimeshiftControl == null || channel == null)
{
return(false);
}
ServiceRegistration.Get <ILogger>().Debug("SlimTvHandler: StartTimeshift slot {0} for channel '{1}'", slotIndex, channel.Name);
int newSlotIndex = GetMatchingSlotIndex(slotIndex);
MediaItem timeshiftMediaItem;
bool result = TimeshiftControl.StartTimeshift(newSlotIndex, channel, out timeshiftMediaItem);
IList <MultipleMediaItemAspect> pras;
if (result && timeshiftMediaItem != null && MediaItemAspect.TryGetAspects(timeshiftMediaItem.Aspects, ProviderResourceAspect.Metadata, out pras))
{
string newAccessorPath = (string)pras[0].GetAttributeValue(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH);
// if slot was empty, start a new player
if (_slotContexes[newSlotIndex].AccessorPath == null)
{
AddOrUpdateTimeshiftContext(timeshiftMediaItem as LiveTvMediaItem, channel);
PlayerContextConcurrencyMode playMode = GetMatchingPlayMode();
PlayItemsModel.PlayOrEnqueueItem(timeshiftMediaItem, true, playMode);
}
else
{
try
{
_slotContexes[newSlotIndex].CardChanging = true;
UpdateExistingMediaItem(timeshiftMediaItem);
}
finally
{
_slotContexes[newSlotIndex].CardChanging = false;
}
}
_slotContexes[newSlotIndex].AccessorPath = newAccessorPath;
_slotContexes[newSlotIndex].Channel = channel;
}
return(result);
}
internal static async Task PlayMediaItemAsync(Guid mediaItemGuid, int startPos)
{
ISet <Guid> necessaryMIATypes = new HashSet <Guid>();
necessaryMIATypes.Add(MediaAspect.ASPECT_ID);
necessaryMIATypes.Add(ProviderResourceAspect.ASPECT_ID);
necessaryMIATypes.Add(ImporterAspect.ASPECT_ID);
ISet <Guid> optionalMIATypes = new HashSet <Guid>();
optionalMIATypes.Add(AudioAspect.ASPECT_ID);
optionalMIATypes.Add(VideoAspect.ASPECT_ID);
optionalMIATypes.Add(MovieAspect.ASPECT_ID);
optionalMIATypes.Add(SeriesAspect.ASPECT_ID);
optionalMIATypes.Add(ImageAspect.ASPECT_ID);
IList <MediaItem> items = new List <MediaItem>();
IFilter searchFilter = new MediaItemIdFilter(mediaItemGuid);
MediaItemQuery searchQuery = new MediaItemQuery(necessaryMIATypes, optionalMIATypes, searchFilter)
{
Limit = 1
};
var cd = ServiceRegistration.Get <IServerConnectionManager>(false);
if (cd?.ContentDirectory != null)
{
items = await cd.ContentDirectory.SearchAsync(searchQuery, false, null, false);
}
if (items.Count == 0)
{
ServiceRegistration.Get <ILogger>().Info("WifiRemote: PlayFile: No media item found");
return;
}
await PlayItemsModel.PlayItem(items[0]);
if (startPos > 0)
{
SetPosition(startPos, true);
}
}
public bool StartTimeshift(int slotIndex, IChannel channel)
{
if (TimeshiftControl == null || channel == null)
{
return(false);
}
int newSlotIndex = GetMatchingSlotIndex(slotIndex);
MediaItem timeshiftMediaItem;
bool result = TimeshiftControl.StartTimeshift(newSlotIndex, channel, out timeshiftMediaItem);
if (result && timeshiftMediaItem != null)
{
string newAccessorPath =
(string)timeshiftMediaItem.Aspects[ProviderResourceAspect.ASPECT_ID].GetAttributeValue(
ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH);
// if slot was empty, start a new player
if (_slotContexes[newSlotIndex].AccessorPath == null)
{
AddTimeshiftContext(timeshiftMediaItem as LiveTvMediaItem, channel);
PlayerContextConcurrencyMode playMode = GetMatchingPlayMode();
PlayItemsModel.PlayOrEnqueueItem(timeshiftMediaItem, true, playMode);
}
else
{
try
{
_slotContexes[newSlotIndex].CardChanging = true;
UpdateExistingMediaItem(timeshiftMediaItem);
}
finally
{
_slotContexes[newSlotIndex].CardChanging = false;
}
}
_slotContexes[newSlotIndex].AccessorPath = newAccessorPath;
_slotContexes[newSlotIndex].Channel = channel;
}
return(result);
}
/// <summary>
/// Examines the media in the given <paramref name="drive"/> and auto-plays the inserted media. Depending on the type of the
/// inserted media, different play modes are choosen.
/// </summary>
/// <param name="drive">Drive to be examined. Format: <c>D:</c>.</param>
protected void ExamineVolume(string drive)
{
if (string.IsNullOrEmpty(drive))
{
return;
}
DriveInfo driveInfo = new DriveInfo(drive);
VideoDriveHandler vdh;
AudioCDDriveHandler acddh;
MultimediaDriveHandler mcddh;
if ((vdh = VideoDriveHandler.TryCreateVideoDriveHandler(driveInfo, Consts.NECESSARY_VIDEO_MIAS)) != null)
{
PlayItemsModel.CheckQueryPlayAction(vdh.VideoItem);
}
else if ((acddh = AudioCDDriveHandler.TryCreateAudioCDDriveHandler(driveInfo)) != null)
{
PlayItemsModel.CheckQueryPlayAction(() => acddh.GetAllMediaItems(), AVType.Audio);
}
else if ((mcddh = MultimediaDriveHandler.TryCreateMultimediaCDDriveHandler(driveInfo,
Consts.NECESSARY_VIDEO_MIAS, Consts.NECESSARY_AUDIO_MIAS, Consts.NECESSARY_IMAGE_MIAS)) != null)
{
switch (mcddh.MediaType)
{
case MultiMediaType.Video:
case MultiMediaType.Image:
PlayItemsModel.CheckQueryPlayAction(() => mcddh.GetAllMediaItems(), AVType.Video);
break;
case MultiMediaType.Audio:
PlayItemsModel.CheckQueryPlayAction(() => mcddh.GetAllMediaItems(), AVType.Audio);
break;
case MultiMediaType.Diverse:
PlayItemsModel.CheckQueryPlayAction(() => mcddh.GetAllMediaItems());
break;
}
}
return;
}
protected void FillList(IContentDirectory contentDirectory, Guid[] necessaryMIAs, ItemsList list, MediaItemToListItemAction converterAction)
{
MediaItemQuery query = new MediaItemQuery(necessaryMIAs, null)
{
Limit = (uint)QueryLimit, // Last 5 imported items
SortInformation = new List <SortInformation> {
new SortInformation(ImporterAspect.ATTR_DATEADDED, SortDirection.Descending)
}
};
var items = contentDirectory.Search(query, false);
list.Clear();
foreach (MediaItem mediaItem in items)
{
PlayableMediaItem listItem = converterAction(mediaItem);
listItem.Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(listItem.MediaItem));
list.Add(listItem);
}
list.FireChange();
}
private void OnSetAvTransportUri(OnEventSetAVTransportURIEventArgs e)
{
Logger.Debug("Set Uri Event fired");
Logger.Debug("CurrentURI " + e.CurrentURI);
Logger.Debug("CurrentURIMetaData " + e.CurrentURIMetaData);
//Logger.Debug("MimeType: {0}", Utils.GetMimeFromUrl(e.CurrentURI, e.CurrentURIMetaData));
_playerType = Utils.GetContentTypeFromUrl(e.CurrentURI, e.CurrentURIMetaData);
switch (_playerType)
{
case ContentType.Audio:
break;
case ContentType.Image:
var imageItem = UPnPMediaItemFactory.CreateImageItem(e.CurrentURI);
imageItem.AddMetaDataToMediaItem(e.CurrentURIMetaData);
var ic = GetPlayerContext <UPnPRendererImagePlayer>();
if (ic != null)
{
ic.DoPlay(imageItem);
}
else
{
PlayItemsModel.CheckQueryPlayAction(imageItem);
}
break;
case ContentType.Video:
break;
case ContentType.Unknown:
break;
}
}
void airplayServer_ShowPhoto(object sender, PhotoEventArgs e)
{
//When playing a video from the camera roll the client sends a thumbnail before the video.
//Occasionally we receive it after due to threading so we should ignore it if we have just started playing a video.
lock (videoInfoSync)
if (currentVideoSessionId != null && DateTime.Now.Subtract(videoReceiveTime).TotalSeconds < 2)
{
return;
}
lock (photoInfoSync)
photoSessionId = e.SessionId;
ImageItem item = new ImageItem(e.AssetKey, e.Photo);
var ic = getPlayerContext <AirplayImagePlayer>();
if (ic != null)
{
ic.DoPlay(item);
}
else
{
PlayItemsModel.CheckQueryPlayAction(item);
}
}
private void OnPlay()
{
TraceLogger.WriteLine("Event Fired! - Play -- ");
VolumeChanged();
var avTransportUri = _transportServiceImpl.StateVariables["AVTransportURI"].Value.ToString();
var avTransportUriMetadata = _transportServiceImpl.StateVariables["AVTransportURIMetaData"].Value.ToString();
switch (_playerType)
{
case ContentType.Audio:
if (_isPaused)
{
ChangeUPnPAVTransportServiceStateToPlaying();
ResumePlayer <UPnPRendererAudioPlayer>();
break;
}
StopPlayer <UPnPRendererAudioPlayer>();
var audioItem = UPnPMediaItemFactory.CreateAudioItem(avTransportUri);
audioItem.AddMetaDataToMediaItem(avTransportUriMetadata);
PlayItemsModel.CheckQueryPlayAction(audioItem);
break;
case ContentType.Image:
var imageItem = UPnPMediaItemFactory.CreateImageItem(avTransportUri);
imageItem.AddMetaDataToMediaItem(avTransportUriMetadata);
var ic = GetPlayerContext <UPnPRendererImagePlayer>();
if (ic != null)
{
ic.DoPlay(imageItem);
}
else
{
PlayItemsModel.CheckQueryPlayAction(imageItem);
}
break;
case ContentType.Video:
if (_isPaused)
{
Logger.Debug("Resume!!");
ChangeUPnPAVTransportServiceStateToPlaying();
ResumePlayer <UPnPRendererVideoPlayer>();
break;
}
Logger.Debug("NO Resume!!");
StopPlayer <UPnPRendererVideoPlayer>();
var videoItem = UPnPMediaItemFactory.CreateVideoItem(avTransportUri);
videoItem.AddMetaDataToMediaItem(avTransportUriMetadata);
PlayItemsModel.CheckQueryPlayAction(videoItem);
break;
case ContentType.Unknown:
Logger.Warn("Can't play because of unknown player type");
return; // we don't want to start the timer
}
_timer.Enabled = true;
_timer.AutoReset = true;
}
public virtual async Task <bool> UpdateItemsAsync(int maxItems, UpdateReason updateReason)
{
if (!ShouldUpdate(updateReason))
{
return(false);
}
if (_playableConverterAction == null && _playableContainerConverterAction == null)
{
return(false);
}
var contentDirectory = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (contentDirectory == null)
{
return(false);
}
MediaItemQuery query = await CreateQueryAsync();
if (query == null)
{
return(false);
}
query.Limit = (uint)maxItems;
Guid?userProfile = CurrentUserProfile?.ProfileId;
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_necessaryMias);
var items = await contentDirectory.SearchAsync(query, true, userProfile, showVirtual);
lock (_allItems.SyncRoot)
{
if (_currentMediaItems != null && _currentMediaItems.Select(m => m.MediaItemId).SequenceEqual(items.Select(m => m.MediaItemId)))
{
return(false);
}
_currentMediaItems = items;
IEnumerable <ListItem> listItems;
if (_playableConverterAction != null)
{
listItems = items.Select(mi =>
{
PlayableMediaItem listItem = _playableConverterAction(mi);
listItem.Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(listItem.MediaItem));
return(listItem);
});
}
else
{
listItems = items.Select(mi => _playableContainerConverterAction(mi));
}
_allItems.Clear();
CollectionUtils.AddAll(_allItems, listItems);
}
_allItems.FireChange();
return(true);
}
public override bool Process(MediaItem mediaItem, out ContentDirectoryMessaging.MediaItemChangeType changeType)
{
changeType = ContentDirectoryMessaging.MediaItemChangeType.None;
PlayItemsModel.PlayOrEnqueueItem(mediaItem, false, PlayerContextConcurrencyMode.None);
return(true);
}
public static async Task <bool> ParseAsync(JObject message, SocketServer server, AsyncSocket sender)
{
string action = GetMessageValue <string>(message, "Action");
var client = sender.GetRemoteClient();
if (!string.IsNullOrEmpty(action))
{
string search = GetMessageValue <string>(message, "Search");
int offset = GetMessageValue <int>(message, "Offset");
int count = GetMessageValue <int>(message, "Count", 10);
string seriesName = GetMessageValue <string>(message, "SeriesName");
int seasonNum = GetMessageValue <int>(message, "SeasonNumber");
string id = GetMessageValue <string>(message, "SeriesId");
int episodeNum = GetMessageValue <int>(message, "EpisodeNumber");
int startPos = GetMessageValue <int>(message, "StartPosition");
bool onlyUnwatched = GetMessageValue <bool>(message, "OnlyUnwatchedEpisodes");
// Search for series
if (action.Equals("seriessearch", StringComparison.InvariantCultureIgnoreCase))
{
var list = await GetItemListAsync <SeriesShowInfo>(client, search, Convert.ToUInt32(count), null, Helper.GetSeriesBySeriesSearchAsync);
SendMessageToClient.Send(new MessageSeries {
Series = list
}, sender, true);
}
// Show series list
else if (action.Equals("serieslist", StringComparison.InvariantCultureIgnoreCase))
{
var list = await GetItemListAsync <SeriesShowInfo>(client, null, Convert.ToUInt32(count), Convert.ToUInt32(offset), Helper.GetSeriesBySeriesSearchAsync);
SendMessageToClient.Send(new MessageSeries {
Series = list
}, sender, true);
}
// Show season list for series
else if (action.Equals("seasonlist", StringComparison.InvariantCultureIgnoreCase))
{
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: List Seasons: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var list = await Helper.GetSeasonsBySeriesIdAsync(client.UserId, mediaItemGuid.Value);
SendMessageToClient.Send(new MessageSeasons {
Seasons = list.Select(i => new SeriesSeasonInfo(i)).ToList()
}, sender, true);
}
// Show episode list for series season
else if (action.Equals("episodelist", StringComparison.InvariantCultureIgnoreCase))
{
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: List Episodes: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var list = await Helper.GetEpisodesBySeriesSeasonAsync(client.UserId, mediaItemGuid.Value, seasonNum);
SendMessageToClient.Send(new MessageEpisodes {
Episodes = list.Select(i => new SeriesEpisodeInfo(i)).ToList()
}, sender, true);
}
// Show movie details for this episode
else if (action.Equals("episodetails", StringComparison.InvariantCultureIgnoreCase))
{
// TODO: implementation possible?
}
// Play a episode
else if (action.Equals("playepisode", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Episode: SeriesName: {0}, SeriesId: {1}, SeasonNumber: {2}, EpisodeNumber: {3}, StartPos: {4}", seriesName, id, seasonNum, episodeNum, startPos);
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var episode = await Helper.GetEpisodeBySeriesEpisodeAsync(client.UserId, mediaItemGuid.Value, seasonNum, episodeNum);
if (episode == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't find episode");
return(false);
}
await Helper.PlayMediaItemAsync(episode.MediaItemId, startPos);
}
else if (action.Equals("playunwatchedepisode", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Episode: SeriesName: {0}, SeriesId: {1}", seriesName, id);
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var episodes = await Helper.GetEpisodesBySeriesIdAsync(client.UserId, mediaItemGuid.Value);
if (!(episodes?.Count > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't find episodes");
return(false);
}
var episode = episodes.FirstOrDefault(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") < 100);
if (episode == null)
{
episode = episodes.LastOrDefault(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") == 100);
}
if (episode == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't find episodes");
return(false);
}
await Helper.PlayMediaItemAsync(episode.MediaItemId, 0);
}
else if (action.Equals("playrandomepisode", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Episode: SeriesName: {0}, SeriesId: {1}", seriesName, id);
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var episodes = await Helper.GetEpisodesBySeriesIdAsync(client.UserId, mediaItemGuid.Value);
if (!(episodes?.Count > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Episode: Couldn't find episodes");
return(false);
}
var episodeList = episodes?.ToList();
var episodeIndex = new Random().Next(0, episodeList.Count - 1);
await Helper.PlayMediaItemAsync(episodeList[episodeIndex].MediaItemId, 0);
}
else if (action.Equals("playseason", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Season: SeriesName: {0}, SeriesId: {1}, SeasonNumber: {2}, OnlyUnwatchedEpisodes: {3}", seriesName, id, seasonNum, onlyUnwatched);
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Season: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var items = await Helper.GetEpisodesBySeriesSeasonAsync(client.UserId, mediaItemGuid.Value, seasonNum);
IEnumerable <MediaItem> episodes = null;
if (onlyUnwatched)
{
episodes = items.Where(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") < 100);
}
else
{
episodes = items;
}
if (!(episodes?.Count() > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Season: Couldn't find any episodes");
return(false);
}
PlayItemsModel.CheckQueryPlayAction(() => episodes, UI.Presentation.Players.AVType.Video);
}
else if (action.Equals("playseries", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Series: SeriesName: {0}, SeriesId: {1}, OnlyUnwatchedEpisodes: {2}", seriesName, id, onlyUnwatched);
var mediaItemGuid = await GetIdFromNameAsync(client, seriesName, id, Helper.GetSeriesBySeriesNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Series: Couldn't convert SeriesId '{0} to Guid", id);
return(false);
}
var items = await Helper.GetEpisodesBySeriesIdAsync(client.UserId, mediaItemGuid.Value);
IEnumerable <MediaItem> episodes = null;
if (onlyUnwatched)
{
episodes = items.Where(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") < 100);
}
else
{
episodes = items;
}
if (!(episodes?.Count() > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Series: Couldn't find any episodes");
return(false);
}
PlayItemsModel.CheckQueryPlayAction(() => episodes, UI.Presentation.Players.AVType.Video);
}
}
return(true);
}
