private void OpenDevice(object o)
{
var deviceIndex = (int)o;
try
{
var player = new VideoCaptureElement();
player.BeginInit();
player.VideoCaptureDevice = MultimediaUtil.VideoInputDevices[deviceIndex];
player.VideoCaptureSource = MultimediaUtil.VideoInputDevices[deviceIndex].Name;
//player.Width = 320;
//player.DesiredPixelWidth = 320;
//player.Height = 240;
//player.DesiredPixelHeight = 240;
//player.FPS = 30;
player.EndInit();
player.Play();
IsPlaying = true;
_player = player;
HasChapters = false;
}
catch (Exception exc)
{
const string message = "Unable to load selected device.";
Logger.Instance.Warn(message, exc);
MessageBox.Show(message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
OnPropertyChanged("Media");
}
private void OpenFile(object o)
{
var path = o.ToString();
FileName = path;
if (string.IsNullOrEmpty(path))
{
return;
}
try
{
var player = CreateMediaUriElement();
player.LoadedBehavior = PauseOnLoaded ? MediaState.Pause : MediaState.Play;
player.Source = new Uri(path, UriKind.Absolute);
player.Play();
IsPlaying = false;
_player = player;
HasChapters = false;
}
catch (Exception exc)
{
var message = String.Format("Unable to load file '{0}'.", path);
Logger.Instance.Warn(message, exc);
MessageBox.Show(message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
OnPropertyChanged("Media");
}
private void OpenStream(object o)
{
var url = o.ToString();
if (string.IsNullOrEmpty(url))
{
return;
}
try
{
var player = CreateMediaUriElement();
player.Source = new Uri(url, UriKind.Absolute);
player.Play();
IsPlaying = true;
_player = player;
HasChapters = false;
}
catch (Exception exc)
{
var message = String.Format("Unable to load stream at '{0}'.", url);
Logger.Instance.Warn(message, exc);
MessageBox.Show(message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
OnPropertyChanged("Media");
}
private async Task <TvShow> ConfiguredRetrievedTvShowDetails(MediaElementBase tvShow)
{
TvShow retrievedTvShow = (TvShow)SelectedMediaElement;
foreach (TvShowSeason season in await _tvShowService.GetSeasonsBy((TvShow)tvShow))
{
retrievedTvShow.Seasons.Add(season);
foreach (TvShowEpisode episode in
await _tvShowService.GetEpisodesBy((TvShow)SelectedMediaElement, season))
{
if (season.TvShowEpisodes.Any(q => q.Id == episode.Id))
{
continue;
}
season.TvShowEpisodes.Add(episode);
retrievedTvShow.AllEpisodes.Add(episode);
episode.Season = season;
episode.TvShow = retrievedTvShow;
}
}
SelectedSeason = retrievedTvShow.Seasons[0];
return(retrievedTvShow);
}
private async Task LoadPlaybackInformation(MediaElementBase tvShow, TvShow retrievedTvShow)
{
if (retrievedTvShow.PlaybackInformation == null)
{
retrievedTvShow.PlaybackInformation = await _playbackInfoService.GetPlaybackInformation(tvShow.Id);
}
}
public async Task Load(MediaElementBase tvShow)
{
IsLoading = true;
try
{
Reinitialize();
await LoadTvShowDetails(tvShow);
TvShow retrievedTvShow = await ConfiguredRetrievedTvShowDetails(tvShow);
ConfigureSpecialPlaybackEpisodes(retrievedTvShow);
await LoadRelatedTvShows(tvShow);
await LoadPlaybackInformation(tvShow, retrievedTvShow);
}
catch (Exception xc)
{
_logManager.LogError(xc, $"An error occurred while initializing tv show detail for {SelectedMediaElement}.");
}
finally
{
IsLoading = false;
}
}
private void OpenDisc(object o)
{
if (o == null)
{
return;
}
var drive = (DriveInfo)o;
try
{
var player = new DvdPlayerElement();
player.BeginInit();
player.PlayOnInsert = true;
player.DvdDirectory = new Uri(string.Format(@"{0}VIDEO_TS", drive.Name)).AbsolutePath;
player.EndInit();
IsPlaying = true;
_player = player;
HasChapters = true;
}
catch (Exception exc)
{
var message = String.Format("Unable to read disc '{0}'.", drive);
Logger.Instance.Warn(message, exc);
MessageBox.Show(message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
OnPropertyChanged("Media");
}
private void ProcessTvShowImages(MediaElementBase mediaElementBase)
{
// TODO smurancsik: to fix up this workaround
if (mediaElementBase.GetType() == typeof(TvShowEpisode))
{
if (!string.IsNullOrEmpty(mediaElementBase.BackdropImageId))
{
mediaElementBase.BackdropImageData =
_imageService.GetImage(mediaElementBase.Id, mediaElementBase.BackdropImageId,
ImageTypeEnum.Primary).Result;
}
}
else
{
if (!string.IsNullOrEmpty(mediaElementBase.ImageId))
{
mediaElementBase.ImageData =
_imageService.GetImage(mediaElementBase.Id, mediaElementBase.ImageId, ImageTypeEnum.Primary)
.Result;
}
if (!string.IsNullOrEmpty(mediaElementBase.BackdropImageId))
{
mediaElementBase.BackdropImageData =
_imageService.GetImage(mediaElementBase.Id, mediaElementBase.BackdropImageId,
ImageTypeEnum.Backdrop).Result;
}
}
}
/// <summary>
/// Generates the playlist, and redirects to playback confirmation view.
/// </summary>
/// <param name="e"></param>
private void PlayImpl(MediaElementBase e)
{
NavigationService.Navigate(typeof(PlaybackConfirmationView), new PlaybackViewParameterModel
{
SelectedMediaElement = e,
Playlist = GetAllEpisodesAfter(e)
});
}
private void Reinitialize()
{
RelatedTvShows.Clear();
FirstAvailableEpisode = null;
ContinueWatchingEpisode = null;
NextUnplayedEpisode = null;
FirstEpisodeFromCurrentSeason = null;
}
public override void Unload()
{
Reset();
_timer.Stop();
if (_player != null)
{
_player.Stop();
}
_player = null;
}
/// <summary>
/// Retrieves the passed movie parameter from the old view.
/// </summary>
/// <param name="e"></param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
MediaElementBase mediaElement = e.Parameter as MediaElementBase;
if (mediaElement != null)
{
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
(DataContext as TvShowEpisodeDetailViewModel).ConfigureInitialTvShowDetails(mediaElement);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
}
private async Task LoadRelatedTvShows(MediaElementBase tvShow)
{
try
{
foreach (TvShow relatedTvShow in await _tvShowService.GetRelatedTvShows(tvShow.Id))
{
RelatedTvShows.Add(relatedTvShow);
}
}
catch (Exception xc)
{
_logManager.LogError(xc, "An error occurred while loading related TV shows.");
}
}
public void ConvertBase(Item source, MediaElementBase target)
{
target.Name = source.Name;
target.Id = source.Id;
target.OfficialRating = source.OfficialRating;
target.CommunityRating = source.CommunityRating;
target.Runtime = TimeSpan.FromTicks(source.RunTimeTicks);
target.Year = source.ProductionYear;
if (source.ImageTags != null)
{
target.ImageId = source.ImageTags.Primary;
}
}
private void SelectedSeasonChanged(TvShowSeason season)
{
if (season.TvShowEpisodes.Any())
{
var firstEpisodeFromCurrentSeason = season.TvShowEpisodes.OrderBy(q => q.IndexNumber).FirstOrDefault();
if (firstEpisodeFromCurrentSeason != null &&
firstEpisodeFromCurrentSeason != FirstAvailableEpisode &&
firstEpisodeFromCurrentSeason != ContinueWatchingEpisode &&
firstEpisodeFromCurrentSeason != NextUnplayedEpisode)
{
FirstEpisodeFromCurrentSeason = firstEpisodeFromCurrentSeason;
_logManager.LogDebug($"TV Show {season.TvShow}: season {season} premiere: {FirstEpisodeFromCurrentSeason}");
}
}
SelectedSeasonEpisodes = season.TvShowEpisodes;
RaisePropertyChanged(nameof(SelectedSeasonEpisodes));
RaisePropertyChanged(nameof(SeasonEpisodesText));
}
public TvShowEpisode[] GetAllEpisodesAfter(MediaElementBase episode)
{
if (!(episode is TvShowEpisode))
{
_logManager.LogWarn("Get All Episodes After was called, but not on an episode. Grab a programmer!");
return(new TvShowEpisode[0]);
}
var e = episode as TvShowEpisode;
if (e.TvShow == null)
{
_logManager.LogWarn("Get All Episodes After was called, but the referenced episode's tv show was null. Grab a programmer!");
return(new TvShowEpisode[0]);
}
var orderedEpisodeList = e.TvShow.AllEpisodes
.OrderBy(q => q.SeasonNumber).ThenBy(q => q.IndexNumber).ToList();
var toSlice = orderedEpisodeList.IndexOf(e);
return(orderedEpisodeList.Skip(toSlice).ToArray());
}
public async Task ConfigureInitialTvShowDetails(MediaElementBase mediaElementBase)
{
SelectedMediaElement = mediaElementBase;
await GetTvShowDetailsImpl();
}
private async Task LoadTvShowDetails(MediaElementBase tvShow)
{
SelectedMediaElement = await _tvShowService.GetTvShowDetails(tvShow.Id);
}
