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 SlimTvFavoriteRecordingsMediaListProvider()
{
_necessaryMias = SlimTvConsts.NECESSARY_RECORDING_MIAS;
_optionalMias = SlimTvConsts.OPTIONAL_RECORDING_MIAS;
_playableConverterAction = mi => new RecordingItem(mi)
{
Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(mi))
};
}
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
};
}
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;
}
}
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);
}
}
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);
}
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);
}
}
}
/// <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 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 count = GetMessageValue <int>(message, "Count", 10);
int offset = GetMessageValue <int>(message, "Offset");
string albumName = GetMessageValue <string>(message, "AlbumName");
string id = GetMessageValue <string>(message, "AlbumId");
int discNum = GetMessageValue <int>(message, "DiscNumber");
int trackNum = GetMessageValue <int>(message, "TrackNumber");
int startPos = GetMessageValue <int>(message, "StartPosition");
bool onlyUnwatched = GetMessageValue <bool>(message, "OnlyUnplayedTracks");
// Search for album
if (action.Equals("albumsearch", StringComparison.InvariantCultureIgnoreCase))
{
var list = await GetItemListAsync <MusicAlbumInfo>(client, search, Convert.ToUInt32(count), null, Helper.GetAlbumsByAlbumSearchAsync);
SendMessageToClient.Send(new MessageAlbums {
Albums = list
}, sender, true);
}
// Show album list
else if (action.Equals("albumlist", StringComparison.InvariantCultureIgnoreCase))
{
var list = await GetItemListAsync <MusicAlbumInfo>(client, null, Convert.ToUInt32(count), Convert.ToUInt32(offset), Helper.GetAlbumsByAlbumSearchAsync);
SendMessageToClient.Send(new MessageAlbums {
Albums = list
}, sender, true);
}
// Search for track
if (action.Equals("tracksearch", StringComparison.InvariantCultureIgnoreCase))
{
var list = await GetItemListAsync <MusicInfo>(client, search, Convert.ToUInt32(count), null, Helper.GetTracksByTrackSearchAsync);
SendMessageToClient.Send(new MessageMusic {
Music = list
}, sender, true);
}
// Show track list for album
else if (action.Equals("tracklist", StringComparison.InvariantCultureIgnoreCase))
{
var mediaItemGuid = await GetIdFromNameAsync(client, albumName, id, Helper.GetAlbumByAlbumNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: List Tracks: Couldn't convert AlbumId '{0} to Guid", id);
return(false);
}
var list = await Helper.GetTracksByAlbumIdAsync(client.UserId, mediaItemGuid.Value);
SendMessageToClient.Send(new MessageMusic {
Music = list.Select(i => new MusicInfo(i)).ToList()
}, sender, true);
}
// Show track details for this track
else if (action.Equals("tracktails", StringComparison.InvariantCultureIgnoreCase))
{
// TODO: implementation possible?
}
// Play a track
else if (action.Equals("playtrack", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Track: AlbumName: {0}, AlbumId: {1}, DiscNumber: {2}, TrackNumber: {3}, StartPos: {4}", albumName, id, discNum, trackNum, startPos);
var mediaItemGuid = await GetIdFromNameAsync(client, albumName, id, Helper.GetAlbumByAlbumNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't convert AlbumId '{0} to Guid", id);
return(false);
}
var episode = await Helper.GetTrackByAlbumTrackAsync(client.UserId, mediaItemGuid.Value, discNum, trackNum);
if (!(episode?.Count > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't find track");
return(false);
}
await Helper.PlayMediaItemAsync(episode.First().MediaItemId, startPos);
}
else if (action.Equals("playunplayedtrack", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote Play Track: AlbumName: {0}, AlbumId: {1}", albumName, id);
var mediaItemGuid = await GetIdFromNameAsync(client, albumName, id, Helper.GetAlbumByAlbumNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't convert AlbumId '{0} to Guid", id);
return(false);
}
var tracks = await Helper.GetTracksByAlbumIdAsync(client.UserId, mediaItemGuid.Value);
if (!(tracks?.Count > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't find track");
return(false);
}
var track = tracks.FirstOrDefault(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") < 100);
if (track == null)
{
track = tracks.LastOrDefault(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") == 100);
}
if (track == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't find tracks");
return(false);
}
await Helper.PlayMediaItemAsync(track.MediaItemId, 0);
}
else if (action.Equals("playrandomtrack", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Track: AlbumName: {0}, AlbumId: {1}", albumName, id);
var mediaItemGuid = await GetIdFromNameAsync(client, albumName, id, Helper.GetAlbumByAlbumNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't convert AlbumId '{0} to Guid", id);
return(false);
}
var tracks = await Helper.GetTracksByAlbumIdAsync(client.UserId, mediaItemGuid.Value);
if (!(tracks?.Count > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Track: Couldn't find tracks");
return(false);
}
var trackList = tracks?.ToList();
var episodeIndex = new Random().Next(0, trackList.Count - 1);
await Helper.PlayMediaItemAsync(trackList[episodeIndex].MediaItemId, 0);
}
else if (action.Equals("playalbum", StringComparison.InvariantCultureIgnoreCase))
{
ServiceRegistration.Get <ILogger>().Debug("WifiRemote: Play Album: AlbumName: {0}, AlbumId: {1}, OnlyUnplayedTracks: {2}", albumName, id, onlyUnwatched);
var mediaItemGuid = await GetIdFromNameAsync(client, albumName, id, Helper.GetAlbumByAlbumNameAsync);
if (mediaItemGuid == null)
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Album: Couldn't convert AlbumId '{0} to Guid", id);
return(false);
}
var items = await Helper.GetTracksByAlbumIdAsync(client.UserId, mediaItemGuid.Value);
IEnumerable <MediaItem> tracks = null;
if (onlyUnwatched)
{
tracks = items.Where(e => Convert.ToInt32(e.UserData.FirstOrDefault(d => d.Key == UserDataKeysKnown.KEY_PLAY_PERCENTAGE).Value ?? "0") < 100);
}
else
{
tracks = items;
}
if (!(tracks?.Count() > 0))
{
ServiceRegistration.Get <ILogger>().Error("WifiRemote: Play Album: Couldn't find any tracks");
return(false);
}
PlayItemsModel.CheckQueryPlayAction(() => tracks, UI.Presentation.Players.AVType.Audio);
}
}
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);
}