public PlaylistSidePaneContentViewModel(MediaPlayer mediaPlayer, HohoemaPlaylist playerModel, PlaylistSettings playlistSettings, PageManager pageManager)
{
_MediaPlayer = mediaPlayer;
_Player = playerModel;
_PlaylistSettings = playlistSettings;
_PageManager = pageManager;
CurrentPlaylist = playerModel.CurrentPlaylist;
CurrentPlayingItem = playerModel.Player.Current;
CurrentPlaylistName = new ReactiveProperty <string>(CurrentWindowContextScheduler, _Player.CurrentPlaylist?.Label)
.AddTo(_CompositeDisposable);
IsShuffleEnabled = _PlaylistSettings.ToReactivePropertyAsSynchronized(x => x.IsShuffleEnable, CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
IsTrackRepeatModeEnable = _PlaylistSettings.ObserveProperty(x => x.RepeatMode)
.Select(x => x == MediaPlaybackAutoRepeatMode.Track)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
IsListRepeatModeEnable = _PlaylistSettings.ObserveProperty(x => x.RepeatMode)
.Select(x => x == MediaPlaybackAutoRepeatMode.List)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
IsTrackRepeatModeEnable.Subscribe(x =>
{
_MediaPlayer.IsLoopingEnabled = x;
})
.AddTo(_CompositeDisposable);
IsReverseEnabled = _PlaylistSettings.ToReactivePropertyAsSynchronized(x => x.IsReverseModeEnable, CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
PlaylistCanGoBack = _Player.Player.ObserveProperty(x => x.CanGoBack)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
PlaylistCanGoNext = _Player.Player.ObserveProperty(x => x.CanGoNext)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
PlaylistItems = CurrentPlaylist.PlaylistItems
.ToReadOnlyReactiveCollection(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
RaisePropertyChanged(nameof(PlaylistItems));
}
public ChannelVideoPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
NiconicoSession niconicoSession,
ChannelProvider channelProvider,
PageManager pageManager,
HohoemaPlaylist hohoemaPlaylist,
ExternalAccessService externalAccessService,
NiconicoFollowToggleButtonService followToggleButtonService
)
{
ApplicationLayoutManager = applicationLayoutManager;
NiconicoSession = niconicoSession;
ChannelProvider = channelProvider;
PageManager = pageManager;
HohoemaPlaylist = hohoemaPlaylist;
ExternalAccessService = externalAccessService;
FollowToggleButtonService = followToggleButtonService;
}
public LocalPlaylistPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
PageManager pageManager,
LocalMylistManager localMylistManager,
HohoemaPlaylist hohoemaPlaylist,
PlaylistAggregateGetter playlistAggregate,
LocalPlaylistDeleteCommand localPlaylistDeleteCommand,
PlaylistPlayAllCommand playlistPlayAllCommand,
RemoveWatchedItemsInAfterWatchPlaylistCommand removeWatchedItemsInAfterWatchPlaylistCommand
)
{
ApplicationLayoutManager = applicationLayoutManager;
_pageManager = pageManager;
_localMylistManager = localMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
_playlistAggregate = playlistAggregate;
LocalPlaylistDeleteCommand = localPlaylistDeleteCommand;
PlaylistPlayAllCommand = playlistPlayAllCommand;
RemoveWatchedItemsInAfterWatchPlaylistCommand = removeWatchedItemsInAfterWatchPlaylistCommand;
}
public PlayerWithPageContainerViewModel(HohoemaApp hohoemaApp, HohoemaPlaylist playlist)
{
HohoemaPlaylist = playlist;
IsFillFloatContent = HohoemaPlaylist
.ToReactivePropertyAsSynchronized(x =>
x.IsPlayerFloatingModeEnable
, (x) => !x
, (x) => !x
);
IsFillFloatContent_DelayedRead = IsFillFloatContent
.Delay(TimeSpan.FromMilliseconds(300))
.ToReadOnlyReactiveProperty();
IsVisibleFloatContent = HohoemaPlaylist.ObserveProperty(x => x.IsDisplayPlayer)
.ToReactiveProperty();
IsContentDisplayFloating = Observable.CombineLatest(
IsFillFloatContent.Select(x => !x),
IsVisibleFloatContent
)
.Select(x => x.All(y => y))
.ToReactiveProperty();
ContentVM = new ReactiveProperty <ViewModelBase>();
HohoemaPlaylist.OpenPlaylistItem += HohoemaPlaylist_OpenPlaylistItem;
IsVisibleFloatContent
.Where(x => !x)
.Subscribe(x =>
{
ClosePlayer();
});
App.Current.Suspending += Current_Suspending;
}
public VideoInfomationPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
AppearanceSettings appearanceSettings,
NGSettings ngSettings,
Models.NiconicoSession niconicoSession,
UserMylistManager userMylistManager,
HohoemaPlaylist hohoemaPlaylist,
NicoVideoProvider nicoVideoProvider,
LoginUserMylistProvider loginUserMylistProvider,
VideoCacheManager videoCacheManager,
SubscriptionManager subscriptionManager,
Models.NicoVideoSessionProvider nicoVideo,
Services.PageManager pageManager,
Services.NotificationService notificationService,
Services.DialogService dialogService,
Services.ExternalAccessService externalAccessService,
AddMylistCommand addMylistCommand,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
{
ApplicationLayoutManager = applicationLayoutManager;
_appearanceSettings = appearanceSettings;
NgSettings = ngSettings;
NiconicoSession = niconicoSession;
UserMylistManager = userMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
NicoVideoProvider = nicoVideoProvider;
LoginUserMylistProvider = loginUserMylistProvider;
VideoCacheManager = videoCacheManager;
SubscriptionManager = subscriptionManager;
NicoVideo = nicoVideo;
PageManager = pageManager;
NotificationService = notificationService;
DialogService = dialogService;
ExternalAccessService = externalAccessService;
AddMylistCommand = addMylistCommand;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
NowLoading = new ReactiveProperty <bool>(false);
IsLoadFailed = new ReactiveProperty <bool>(false);
}
public VideoEndedRecommendation(
MediaPlayer mediaPlayer,
VideoPlayer videoPlayer,
IScheduler scheduler,
RelatedVideoContentsAggregator relatedVideoContentsAggregator,
HohoemaPlaylist hohoemaPlaylist,
PrimaryViewPlayerManager primaryViewPlayerManager,
PlayerSettings playerSettings,
VideoPlayRequestBridgeToPlayer videoPlayRequestBridgeToPlayer
)
{
_mediaPlayer = mediaPlayer;
_videoPlayer = videoPlayer;
_scheduler = scheduler;
_relatedVideoContentsAggregator = relatedVideoContentsAggregator;
_hohoemaPlaylist = hohoemaPlaylist;
_primaryViewPlayerManager = primaryViewPlayerManager;
_playerSettings = playerSettings;
_videoPlayRequestBridgeToPlayer = videoPlayRequestBridgeToPlayer;
IsEnded = new ReactiveProperty<bool>(_scheduler);
HasRecomend = new ReactiveProperty<bool>(_scheduler);
_mediaPlayer.PlaybackSession.PositionChanged += PlaybackSession_PositionChanged;
_videoPlayer.ObserveProperty(x => x.PlayingVideoId)
.Subscribe(x =>
{
_series = null;
_videoRelatedContents = null;
HasNextVideo = false;
NextVideoTitle = null;
_playNext = false;
_endedProcessed = false;
HasRecomend.Value = false;
})
.AddTo(_disposables);
}
public QueueRemoveItemCommand(HohoemaPlaylist hohoemaPlaylist)
{
_hohoemaPlaylist = hohoemaPlaylist;
}
public QualityDividedNicoVideoListItemViewModel(DividedQualityNicoVideo divQualityVideo, HohoemaPlaylist playlist)
{
DividedQualityNicoVideo = divQualityVideo;
HohoemaPlaylist = playlist;
Quality = DividedQualityNicoVideo.Quality;
CacheState = DividedQualityNicoVideo.ObserveProperty(x => x.CacheState)
.ToReadOnlyReactiveProperty()
.AddTo(_CompositeDisposable);
IsNotCacheRequested = CacheState.Select(x => x == NicoVideoCacheState.NotCacheRequested)
.ToReadOnlyReactiveProperty()
.AddTo(_CompositeDisposable);
IsCachePending = CacheState.Select(x => x == NicoVideoCacheState.Pending)
.ToReadOnlyReactiveProperty()
.AddTo(_CompositeDisposable);
IsCacheDownloading = CacheState.Select(x => x == NicoVideoCacheState.Downloading)
.ToReadOnlyReactiveProperty()
.AddTo(_CompositeDisposable);
IsCached = CacheState.Select(x => x == NicoVideoCacheState.Cached)
.ToReadOnlyReactiveProperty()
.AddTo(_CompositeDisposable);
ProgressPercent = new ReactiveProperty <float>(DividedQualityNicoVideo.IsCached ? 100.0f : 0.0f);
CacheState.Subscribe(x =>
{
if (x == NicoVideoCacheState.Downloading)
{
_ProgressParcentageMoniterDisposer?.Dispose();
_ProgressParcentageMoniterDisposer =
DividedQualityNicoVideo.ObserveProperty(y => y.CacheProgressSize)
.Subscribe(y =>
{
ProgressPercent.Value = DividedQualityNicoVideo.GetDonwloadProgressParcentage();
});
}
else
{
_ProgressParcentageMoniterDisposer?.Dispose();
_ProgressParcentageMoniterDisposer = null;
}
});
}
public CacheManagementPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
CacheSettings cacheSettings,
VideoCacheManager videoCacheManager,
CacheSaveFolder cacheSaveFolder,
NicoVideoProvider nicoVideoProvider,
PageManager pageManager,
DialogService dialogService,
NotificationService notificationService,
HohoemaPlaylist hohoemaPlaylist
)
{
ApplicationLayoutManager = applicationLayoutManager;
CacheSettings = cacheSettings;
VideoCacheManager = videoCacheManager;
CacheSaveFolder = cacheSaveFolder;
NicoVideoProvider = nicoVideoProvider;
HohoemaDialogService = dialogService;
NotificationService = notificationService;
HohoemaPlaylist = hohoemaPlaylist;
IsRequireUpdateCacheSaveFolder = new ReactiveProperty <bool>(false);
IsCacheUserAccepted = CacheSettings.ObserveProperty(x => x.IsUserAcceptedCache)
.ToReadOnlyReactiveProperty();
RequireEnablingCacheCommand = new DelegateCommand(async() =>
{
var result = await HohoemaDialogService.ShowAcceptCacheUsaseDialogAsync();
if (result)
{
CacheSettings.IsEnableCache = true;
CacheSettings.IsUserAcceptedCache = true;
(App.Current).Resources["IsCacheEnabled"] = true;
await RefreshCacheSaveFolderStatus();
NotificationService.ShowInAppNotification(
InAppNotificationPayload.CreateReadOnlyNotification("ChoiceCacheSavingFolder".Translate(),
showDuration: TimeSpan.FromSeconds(30)
));
if (await CacheSaveFolder.ChangeUserDataFolder())
{
await RefreshCacheSaveFolderStatus();
await VideoCacheManager.CacheFolderChanged();
await ResetList();
NotificationService.ShowInAppNotification(
InAppNotificationPayload.CreateReadOnlyNotification("ReadyForVideoCache".Translate())
);
}
}
});
ReadCacheAcceptTextCommand = new DelegateCommand(async() =>
{
var result = await HohoemaDialogService.ShowAcceptCacheUsaseDialogAsync(showWithoutConfirmButton: true);
});
CacheFolderStateDescription = new ReactiveProperty <string>("");
CacheSaveFolderPath = new ReactiveProperty <string>("");
OpenCurrentCacheFolderCommand = new DelegateCommand(async() =>
{
await RefreshCacheSaveFolderStatus();
var folder = await CacheSaveFolder.GetVideoCacheFolder();
if (folder != null)
{
await Launcher.LaunchFolderAsync(folder);
}
});
ChangeCacheFolderCommand = new DelegateCommand(async() =>
{
var prevPath = CacheSaveFolderPath.Value;
if (await CacheSaveFolder.ChangeUserDataFolder())
{
NotificationService.ShowInAppNotification(
InAppNotificationPayload.CreateReadOnlyNotification("CacheSaveFolderChangeToX".Translate(CacheSaveFolderPath.Value))
);
await RefreshCacheSaveFolderStatus();
await VideoCacheManager.CacheFolderChanged();
await ResetList();
}
});
}
public PlaylistPlayAllCommand(HohoemaPlaylist hohoemaPlaylist)
{
_hohoemaPlaylist = hohoemaPlaylist;
}
public PlaylistSidePaneContentViewModel(
MediaPlayer mediaPlayer,
HohoemaPlaylist playerModel,
PlayerSettings playerSettings,
PageManager pageManager,
IScheduler scheduler
)
{
MediaPlayer = mediaPlayer;
HohoemaPlaylist = playerModel;
_playerSettings = playerSettings;
PageManager = pageManager;
_scheduler = scheduler;
CurrentPlaylistName = HohoemaPlaylist.ObserveProperty(x => x.CurrentPlaylist).Select(x => x?.Label)
.ToReadOnlyReactiveProperty(eventScheduler: _scheduler)
.AddTo(_CompositeDisposable);
IsShuffleEnabled = _playerSettings.ToReactivePropertyAsSynchronized(x => x.IsShuffleEnable, _scheduler)
.AddTo(_CompositeDisposable);
IsListRepeatModeEnable = _playerSettings.ObserveProperty(x => x.IsPlaylistLoopingEnabled)
.ToReactiveProperty(_scheduler)
.AddTo(_CompositeDisposable);
IsReverseEnabled = _playerSettings.ToReactivePropertyAsSynchronized(x => x.IsReverseModeEnable, _scheduler)
.AddTo(_CompositeDisposable);
PlaylistCanGoBack = HohoemaPlaylist.ObserveProperty(x => x.CanGoBack)
.ToReactiveProperty(_scheduler)
.AddTo(_CompositeDisposable);
PlaylistCanGoNext = HohoemaPlaylist.ObserveProperty(x => x.CanGoNext)
.ToReactiveProperty(_scheduler)
.AddTo(_CompositeDisposable);
CurrentItems = HohoemaPlaylist.PlaylistItems.ToReadOnlyReactiveCollection(_scheduler)
.AddTo(_CompositeDisposable);
QueueItems = HohoemaPlaylist.QueuePlaylist.ToReadOnlyReactiveCollection(_scheduler)
.AddTo(_CompositeDisposable);
_currentItemCollectionView = new ObservableCollection <IVideoContent>();
_currentPlaylistViewItem = new PlaylistCollectionViewItem()
{
Id = "playlist",
Items = CurrentItems
};
_playlistCollectionViews = new ObservableCollection <PlaylistCollectionViewItem>()
{
new PlaylistCollectionViewItem()
{
Id = "_current_video_",
Label = "PlayingVideo".Translate(),
Items = _currentItemCollectionView
},
new PlaylistCollectionViewItem()
{
Id = "@queue",
Label = "@queue".Translate(),
Items = QueueItems,
},
_currentPlaylistViewItem
};
HohoemaPlaylist.ObserveProperty(x => x.CurrentPlaylist).Subscribe(x =>
{
_currentPlaylistViewItem.Label = x?.Label ?? string.Empty;
})
.AddTo(_CompositeDisposable);
HohoemaPlaylist.ObserveProperty(x => x.CurrentItem)
.Subscribe(x =>
{
_currentItemCollectionView.Clear();
_currentItemCollectionView.Add(x);
})
.AddTo(_CompositeDisposable);
CollectionViewSource = new CollectionViewSource()
{
IsSourceGrouped = true,
Source = _playlistCollectionViews,
ItemsPath = new Windows.UI.Xaml.PropertyPath(nameof(PlaylistCollectionViewItem.Items))
};
}
public LiveInfoViewModel(VideoInfo liveVideoInfo, HohoemaPlaylist playlist, PageManager pageManager)
{
LiveVideoInfo = liveVideoInfo;
PageManager = pageManager;
Playlist = playlist;
LiveId = liveVideoInfo.Video.Id;
CommunityName = LiveVideoInfo.Community?.Name;
if (LiveVideoInfo.Community?.Thumbnail != null)
{
CommunityThumbnail = LiveVideoInfo.Community?.Thumbnail;
}
else
{
CommunityThumbnail = LiveVideoInfo.Video.ThumbnailUrl;
}
CommunityGlobalId = LiveVideoInfo.Community?.GlobalId;
CommunityType = LiveVideoInfo.Video.ProviderType;
LiveTitle = LiveVideoInfo.Video.Title;
ViewCounter = int.Parse(LiveVideoInfo.Video.ViewCounter);
CommentCount = int.Parse(LiveVideoInfo.Video.CommentCount);
OpenTime = LiveVideoInfo.Video.OpenTime;
StartTime = LiveVideoInfo.Video.StartTime;
EndTime = LiveVideoInfo.Video.EndTime;
IsTimeshiftEnabled = LiveVideoInfo.Video.TimeshiftEnabled;
IsCommunityMemberOnly = LiveVideoInfo.Video.CommunityOnly;
Label = LiveVideoInfo.Video.Title;
AddImageUrl(CommunityThumbnail);
Description = $"来場者:{ViewCounter} コメ:{CommentCount}";
if (LiveVideoInfo.Video.StartTime > DateTime.Now)
{
// 予約
DurationText = $" 開始予定: {LiveVideoInfo.Video.StartTime}";
}
else if (LiveVideoInfo.Video.EndTime > DateTime.Now)
{
var duration = DateTime.Now - StartTime;
// 放送中
if (duration.Hours > 0)
{
DurationText = $"{duration.Hours}時間 {duration.Minutes}分 経過";
}
else
{
DurationText = $"{duration.Minutes}分 経過";
}
}
else
{
var duration = EndTime - StartTime;
// 終了
if (duration.Hours > 0)
{
DurationText = $"{LiveVideoInfo.Video.EndTime} 終了（{duration.Hours}時間 {duration.Minutes}分）";
}
else
{
DurationText = $"{LiveVideoInfo.Video.EndTime} 終了（{duration.Minutes}分）";
}
}
OptionText = DurationText;
}
public NicoRepoLiveTimeline(NicoRepoTimelineItem timelineItem, NicoRepoItemTopic itemType, HohoemaPlaylist playlist) : base(timelineItem, itemType, playlist)
{
}
public NicoRepoTimelineVM(NicoRepoTimelineItem timelineItem, NicoRepoItemTopic itemType, HohoemaPlaylist playlist)
{
TimelineItem = timelineItem;
HohoemaPlaylist = playlist;
ItemTopic = itemType;
if (TimelineItem.Program != null)
{
this.Label = TimelineItem.Program.Title;
AddImageUrl(TimelineItem.Program.ThumbnailUrl);
this.OptionText = $"{TimelineItem.Program.BeginAt.ToString()} 放送開始";
if (TimelineItem.Community != null)
{
_OwnerUserId = TimelineItem.Community.Id;
OwnerUserName = TimelineItem.Community.Name;
}
else
{
_OwnerUserId = TimelineItem.SenderChannel.Id.ToString();
OwnerUserName = TimelineItem.SenderChannel.Name;
OwnerUserType = UserType.User;
}
}
else if (TimelineItem.Video != null)
{
this.Label = TimelineItem.Video.Title;
if (TimelineItem.Video.ThumbnailUrl.Small != null)
{
AddImageUrl(TimelineItem.Video.ThumbnailUrl.Small);
}
else if (TimelineItem.Video.ThumbnailUrl.Normal != null)
{
AddImageUrl(TimelineItem.Video.ThumbnailUrl.Normal);
}
this.OptionText = $"{TimelineItem.CreatedAt.ToString()}";
}
if (TimelineItem.SenderNiconicoUser != null)
{
_OwnerUserId = TimelineItem.SenderNiconicoUser.Id.ToString();
OwnerUserName = TimelineItem.SenderNiconicoUser.Nickname;
OwnerUserType = UserType.User;
}
if (TimelineItem.SenderNiconicoUser != null)
{
this.Description = this.TimelineItem.SenderNiconicoUser.Nickname;
}
else if (TimelineItem.SenderChannel != null)
{
this.Description = this.TimelineItem.SenderChannel.Name;
OwnerUserType = UserType.Channel;
}
switch (ItemTopic)
{
case NicoRepoItemTopic.Unknown:
Description = $"（対応していないニコレポアイテム）";
break;
case NicoRepoItemTopic.NicoVideo_User_Video_Kiriban_Play:
Description = $"動画再生数がキリ番に到達しました";
break;
case NicoRepoItemTopic.NicoVideo_User_Video_Upload:
Description = $"{this.TimelineItem.SenderNiconicoUser.Nickname} さんが動画を投稿";
break;
case NicoRepoItemTopic.NicoVideo_Community_Level_Raise:
Description = $"コミュニティレベル";
break;
case NicoRepoItemTopic.NicoVideo_User_Mylist_Add_Video:
Description = $"{this.TimelineItem.SenderNiconicoUser.Nickname} さんがマイリストに動画を追加";
break;
case NicoRepoItemTopic.NicoVideo_User_Community_Video_Add:
Description = $"コミュニティ動画に動画が追加されました";
break;
case NicoRepoItemTopic.NicoVideo_User_Video_UpdateHighestRankings:
Description = $"動画がランキングにランクイン";
break;
case NicoRepoItemTopic.NicoVideo_User_Video_Advertise:
Description = $"動画が広告されました";
break;
case NicoRepoItemTopic.NicoVideo_Channel_Blomaga_Upload:
Description = $"ブロマガが投稿されました";
break;
case NicoRepoItemTopic.NicoVideo_Channel_Video_Upload:
Description = $"{this.TimelineItem.SenderChannel.Name} が動画を投稿";
break;
case NicoRepoItemTopic.Live_User_Program_OnAirs:
Description = $"{this.TimelineItem.SenderNiconicoUser.Nickname} さんが生放送を開始";
break;
case NicoRepoItemTopic.Live_User_Program_Reserve:
Description = $"{this.TimelineItem.SenderNiconicoUser.Nickname} さんが生放送を予約";
break;
case NicoRepoItemTopic.Live_Channel_Program_Onairs:
Description = $"{this.TimelineItem.SenderChannel.Name} が生放送を開始";
break;
case NicoRepoItemTopic.Live_Channel_Program_Reserve:
Description = $"{this.TimelineItem.SenderChannel.Name} が生放送を予約";
break;
default:
break;
}
}
public MylistPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
Services.PageManager pageManager,
NiconicoSession niconicoSession,
MylistProvider mylistProvider,
UserProvider userProvider,
FollowManager followManager,
LoginUserMylistProvider loginUserMylistProvider,
NGSettings ngSettings,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager,
MylistRepository mylistRepository,
HohoemaPlaylist hohoemaPlaylist,
SubscriptionManager subscriptionManager,
Services.DialogService dialogService,
NiconicoFollowToggleButtonService followToggleButtonService,
PlaylistAggregateGetter playlistAggregate,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
{
ApplicationLayoutManager = applicationLayoutManager;
PageManager = pageManager;
NiconicoSession = niconicoSession;
MylistProvider = mylistProvider;
UserProvider = userProvider;
FollowManager = followManager;
LoginUserMylistProvider = loginUserMylistProvider;
NgSettings = ngSettings;
UserMylistManager = userMylistManager;
LocalMylistManager = localMylistManager;
_mylistRepository = mylistRepository;
HohoemaPlaylist = hohoemaPlaylist;
SubscriptionManager = subscriptionManager;
DialogService = dialogService;
FollowToggleButtonService = followToggleButtonService;
_playlistAggregate = playlistAggregate;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
Mylist = new ReactiveProperty <MylistPlaylist>();
/*
* IsFavoriteMylist = new ReactiveProperty<bool>(mode: ReactivePropertyMode.DistinctUntilChanged)
* .AddTo(_CompositeDisposable);
* CanChangeFavoriteMylistState = new ReactiveProperty<bool>()
* .AddTo(_CompositeDisposable);
*
*
* IsFavoriteMylist
* .Where(x => PlayableList.Value.Id != null)
* .Subscribe(async x =>
* {
* if (PlayableList.Value.Origin != PlaylistOrigin.OtherUser) { return; }
*
* if (_NowProcessFavorite) { return; }
*
* _NowProcessFavorite = true;
*
* CanChangeFavoriteMylistState.Value = false;
* if (x)
* {
* if (await FavoriteMylist())
* {
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り登録しました.");
* }
* else
* {
* // お気に入り登録に失敗した場合は状態を差し戻し
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り登録に失敗");
* IsFavoriteMylist.Value = false;
* }
* }
* else
* {
* if (await UnfavoriteMylist())
* {
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り解除しました.");
* }
* else
* {
* // お気に入り解除に失敗した場合は状態を差し戻し
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り解除に失敗");
* IsFavoriteMylist.Value = true;
* }
* }
*
* CanChangeFavoriteMylistState.Value =
* IsFavoriteMylist.Value == true
|| FollowManager.CanMoreAddFollow(FollowItemType.Mylist);
||
||
|| _NowProcessFavorite = false;
|| })
|| .AddTo(_CompositeDisposable);
||
||
||UnregistrationMylistCommand = SelectedItems.ObserveProperty(x => x.Count)
|| .Where(_ => IsUserOwnerdMylist)
|| .Select(x => x > 0)
|| .ToReactiveCommand(false);
||
||UnregistrationMylistCommand.Subscribe(async _ =>
||{
|| if (PlayableList.Value.Origin == PlaylistOrigin.Local)
|| {
|| var localMylist = PlayableList.Value as LegacyLocalMylist;
|| var items = SelectedItems.ToArray();
||
|| foreach (var item in items)
|| {
|| localMylist.Remove(item.PlaylistItem);
|| IncrementalLoadingItems.Remove(item);
|| }
|| }
|| else if (PlayableList.Value.Origin == PlaylistOrigin.LoginUser)
|| {
|| var mylistGroup = HohoemaApp.UserMylistManager.GetMylistGroup(PlayableList.Value.Id);
||
|| var items = SelectedItems.ToArray();
||
||
|| var action = AsyncInfo.Run<uint>(async (cancelToken, progress) =>
|| {
|| uint progressCount = 0;
|| int successCount = 0;
|| int failedCount = 0;
||
|| Debug.WriteLine($"マイリストに追加解除を開始...");
|| foreach (var video in items)
|| {
|| var unregistrationResult = await mylistGroup.Unregistration(
|| video.RawVideoId
|| , withRefresh: false );
||
|| if (unregistrationResult == ContentManageResult.Success)
|| {
|| successCount++;
|| }
|| else
|| {
|| failedCount++;
|| }
||
|| progressCount++;
|| progress.Report(progressCount);
||
|| Debug.WriteLine($"{video.Label}[{video.RawVideoId}]:{unregistrationResult.ToString()}");
|| }
||
|| // 登録解除結果を得るためリフレッシュ
|| await mylistGroup.Refresh();
||
||
|| // ユーザーに結果を通知
|| var titleText = $"「{mylistGroup.Label}」から {successCount}件 の動画が登録解除されました";
|| var toastService = App.Current.Container.Resolve<NotificationService>();
|| var resultText = $"";
|| if (failedCount > 0)
|| {
|| resultText += $"\n登録解除に失敗した {failedCount}件 は選択されたままです";
|| }
|| toastService.ShowToast(titleText, resultText);
||
|| // 登録解除に失敗したアイテムだけを残すように
|| // マイリストから除外された動画を選択アイテムリストから削除
|| foreach (var item in SelectedItems.ToArray())
|| {
|| if (false == mylistGroup.CheckRegistratedVideoId(item.RawVideoId))
|| {
|| SelectedItems.Remove(item);
|| IncrementalLoadingItems.Remove(item);
|| }
|| }
||
|| Debug.WriteLine($"マイリストに追加解除完了---------------");
|| });
||
|| await PageManager.StartNoUIWork("マイリストに追加解除", items.Length, () => action);
||
|| }
||
||
||});
||
||
*/
}
public UserInfoPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
UserProvider userProvider,
NGSettings ngSettings,
Models.NiconicoSession niconicoSession,
SubscriptionManager subscriptionManager,
UserMylistManager userMylistManager,
HohoemaPlaylist hohoemaPlaylist,
PageManager pageManager,
MylistRepository mylistRepository,
ExternalAccessService externalAccessService,
NiconicoFollowToggleButtonService followToggleButtonService,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
{
NiconicoSession = niconicoSession;
SubscriptionManager = subscriptionManager;
UserMylistManager = userMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
PageManager = pageManager;
_mylistRepository = mylistRepository;
ExternalAccessService = externalAccessService;
FollowToggleButtonService = followToggleButtonService;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
ApplicationLayoutManager = applicationLayoutManager;
UserProvider = userProvider;
NgSettings = ngSettings;
HasOwnerVideo = true;
VideoInfoItems = new ObservableCollection <VideoInfoControlViewModel>();
OpenUserVideoPageCommand = VideoInfoItems.ObserveProperty(x => x.Count)
.Select(x => x > 0)
.ToReactiveCommand()
.AddTo(_CompositeDisposable);
OpenUserVideoPageCommand.Subscribe(x =>
{
PageManager.OpenPageWithId(HohoemaPageType.UserVideo, UserId);
})
.AddTo(_CompositeDisposable);
IsNGVideoOwner = new ReactiveProperty <bool>(false, ReactivePropertyMode.DistinctUntilChanged);
IsNGVideoOwner.Subscribe(isNgVideoOwner =>
{
if (isNgVideoOwner)
{
NgSettings.AddNGVideoOwnerId(UserId, UserName);
IsNGVideoOwner.Value = true;
Debug.WriteLine(UserName + "をNG動画投稿者として登録しました。");
}
else
{
NgSettings.RemoveNGVideoOwnerId(UserId);
IsNGVideoOwner.Value = false;
Debug.WriteLine(UserName + "をNG動画投稿者の指定を解除しました。");
}
});
}
public RemoveWatchedItemsInAfterWatchPlaylistCommand(HohoemaPlaylist hohoemaPlaylist)
{
_hohoemaPlaylist = hohoemaPlaylist;
}
public UserMylistPageViewModel(
Services.PageManager pageMaanger,
Services.DialogService dialogService,
NiconicoSession niconicoSession,
UserProvider userProvider,
LoginUserMylistProvider loginUserMylistProvider,
OtherOwneredMylistManager otherOwneredMylistManager,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager,
HohoemaPlaylist hohoemaPlaylist
)
: base(pageMaanger, useDefaultPageTitle: false)
{
DialogService = dialogService;
NiconicoSession = niconicoSession;
UserProvider = userProvider;
LoginUserMylistProvider = loginUserMylistProvider;
OtherOwneredMylistManager = otherOwneredMylistManager;
UserMylistManager = userMylistManager;
LocalMylistManager = localMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
IsLoginUserMylist = new ReactiveProperty <bool>(false);
OpenMylistCommand = new ReactiveCommand <Interfaces.IMylist>();
OpenMylistCommand.Subscribe(listItem =>
{
PageManager.OpenPage(HohoemaPageType.Mylist,
new MylistPagePayload()
{
Id = listItem.Id, Origin = listItem.ToMylistOrigin()
}
.ToParameterString()
);
});
AddMylistGroupCommand = new DelegateCommand(async() =>
{
MylistGroupEditData data = new MylistGroupEditData()
{
Name = "新しいマイリスト",
Description = "",
IsPublic = false,
MylistDefaultSort = MylistDefaultSort.Latest,
IconType = IconType.Default,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
var result = await UserMylistManager.AddMylist(
data.Name,
data.Description,
data.IsPublic,
data.MylistDefaultSort,
data.IconType
);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
await ResetList();
break;
}
}
else
{
break;
}
}
}
, () => UserMylistManager.Mylists.Count < UserMylistManager.MaxMylistGroupCountCurrentUser
);
RemoveMylistGroupCommand = new DelegateCommand <Interfaces.IMylist>(async(item) =>
{
var mylistOrigin = item.ToMylistOrigin();
if (mylistOrigin == PlaylistOrigin.Local)
{
if (item.Id == HohoemaPlaylist.WatchAfterPlaylistId)
{
return;
}
}
else if (mylistOrigin == PlaylistOrigin.LoginUser)
{
if (item.Id == "0")
{
return;
}
}
// 確認ダイアログ
var originText = mylistOrigin == PlaylistOrigin.Local ? "ローカルマイリスト" : "マイリスト";
var contentMessage = $"{item.Label} を削除してもよろしいですか？（変更は元に戻せません）";
var dialog = new MessageDialog(contentMessage, $"{originText}削除の確認");
dialog.Commands.Add(new UICommand("削除", async(i) =>
{
if (mylistOrigin == PlaylistOrigin.Local)
{
LocalMylistManager.RemoveCommand.Execute(item as LocalMylistGroup);
}
else if (mylistOrigin == PlaylistOrigin.LoginUser)
{
await UserMylistManager.RemoveMylist(item.Id);
// await UpdateUserMylist();
}
}));
dialog.Commands.Add(new UICommand("キャンセル"));
dialog.CancelCommandIndex = 1;
dialog.DefaultCommandIndex = 1;
await dialog.ShowAsync();
});
EditMylistGroupCommand = new DelegateCommand <Interfaces.IMylist>(async item =>
{
var mylistOrigin = item.ToMylistOrigin();
if (mylistOrigin == PlaylistOrigin.Local)
{
if (item.Id == HohoemaPlaylist.WatchAfterPlaylistId)
{
return;
}
}
else if (mylistOrigin == PlaylistOrigin.LoginUser)
{
if (item.Id == "0")
{
return;
}
}
if (mylistOrigin == PlaylistOrigin.Local)
{
var localMylist = item as LocalMylistGroup;
var resultText = await DialogService.GetTextAsync("プレイリスト名を変更",
localMylist.Label,
localMylist.Label,
(tempName) => !string.IsNullOrWhiteSpace(tempName)
);
if (!string.IsNullOrWhiteSpace(resultText))
{
localMylist.Label = resultText;
}
}
if (mylistOrigin == PlaylistOrigin.LoginUser)
{
var mylistGroupListItem = item as UserOwnedMylist;
var selectedMylistGroupId = mylistGroupListItem.Id;
if (selectedMylistGroupId == null)
{
return;
}
var mylistGroup = UserMylistManager.GetMylistGroup(selectedMylistGroupId);
MylistGroupEditData data = new MylistGroupEditData()
{
Name = mylistGroup.Label,
Description = mylistGroup.Description,
IsPublic = mylistGroup.IsPublic,
MylistDefaultSort = mylistGroup.Sort,
IconType = mylistGroup.IconType,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
mylistGroup.Label = data.Name;
mylistGroup.Description = data.Description;
mylistGroup.IsPublic = data.IsPublic;
mylistGroup.Sort = data.MylistDefaultSort;
mylistGroup.IconType = data.IconType;
var result = await LoginUserMylistProvider.UpdateMylist(mylistGroup);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
// TODO: UI上のマイリスト表示を更新する
break;
}
}
else
{
break;
}
}
}
});
PlayAllCommand = new DelegateCommand <Interfaces.IMylist>((mylist) =>
{
if (mylist.ItemCount == 0)
{
return;
}
HohoemaPlaylist.Play(mylist);
});
AddLocalMylistCommand = new DelegateCommand(async() =>
{
var name = await DialogService.GetTextAsync("新しいローカルマイリスト名を入力", "ローカルマイリスト名", "",
(s) =>
{
if (string.IsNullOrWhiteSpace(s))
{
return(false);
}
if (LocalMylistManager.Mylists.Any(x => x.Label == s))
{
return(false);
}
return(true);
});
if (name != null)
{
LocalMylistManager.Mylists.Add(new LocalMylistGroup(Guid.NewGuid().ToString(), name));
}
});
}
public FeedNewVideosList(Database.Feed feeds, FeedManager feedManager, HohoemaPlaylist playlist)
{
Feed = feeds;
FeedManager = feedManager;
Playlist = playlist;
Label = feeds.Label;
Bookmark = feeds.Sources.FirstOrDefault()?.BookmarkType ?? throw new Exception();
FeedVideos = new ObservableCollection <FeedVideoInfoControlViewModel>();
NowUpdate = new ReactiveProperty <bool>(false);
PlayAllCommand = FeedVideos.CollectionChangedAsObservable()
.Select(_ => FeedVideos.Count > 0)
.ToReactiveCommand();
PlayAllCommand.Subscribe(() =>
{
var firstItem = FeedVideos.LastOrDefault();
if (firstItem != null)
{
Playlist.PlayVideo(firstItem.RawVideoId, firstItem.Label);
}
foreach (var playItem in FeedVideos.Reverse().Skip(1))
{
Playlist.DefaultPlaylist.AddVideo(playItem.RawVideoId, playItem.Label, ContentInsertPosition.Head);
}
FeedCheckedCommand.Execute();
});
AllAddToAfterWatchCommand = FeedVideos.CollectionChangedAsObservable()
.Select(_ => FeedVideos.Count > 0)
.ToReactiveCommand();
AllAddToAfterWatchCommand.Subscribe(() =>
{
foreach (var playItem in FeedVideos.Reverse())
{
Playlist.DefaultPlaylist.AddVideo(playItem.RawVideoId, playItem.Label, ContentInsertPosition.Tail);
}
FeedCheckedCommand.Execute();
});
PlayAllCommand.Subscribe(() =>
{
IEnumerable <FeedVideoInfoControlViewModel> playItems = FeedVideos.AsEnumerable();
var firstItem = FeedVideos.FirstOrDefault();
if (firstItem != null)
{
Playlist.PlayVideo(firstItem.RawVideoId, firstItem.Label);
}
playItems = FeedVideos.Skip(1);
foreach (var playItem in playItems)
{
Playlist.DefaultPlaylist.AddVideo(playItem.RawVideoId, playItem.Label);
}
FeedCheckedCommand.Execute();
});
FeedCheckedCommand = FeedVideos.CollectionChangedAsObservable()
.Select(_ => FeedVideos.Count > 0)
.ToReactiveCommand();
FeedCheckedCommand.Subscribe(() =>
{
Feed.CheckedAt = DateTime.Now;
FeedManager.UpdateFeedGroup(Feed);
UpdateFeedVideos();
});
// UpdateFeedVideos();
UpdateCommand = NowUpdate.Select(x => !x).ToReactiveCommand();
UpdateCommand.Subscribe(() =>
{
UpdateFeedVideos();
});
feedManager.FeedUpdated += FeedManager_FeedUpdated;
}
public PlayWithPlaylistCommand(IPlaylist playlist, HohoemaPlaylist hohoemaPlaylist)
{
_playlist = playlist;
_hohoemaPlaylist = hohoemaPlaylist;
}
public WatchAfterAddItemCommand(HohoemaPlaylist hohoemaPlaylist)
{
_hohoemaPlaylist = hohoemaPlaylist;
}
public UserMylistPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
Services.PageManager pageManager,
Services.DialogService dialogService,
NiconicoSession niconicoSession,
UserProvider userProvider,
MylistRepository mylistRepository,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager,
HohoemaPlaylist hohoemaPlaylist,
CreateLocalMylistCommand createLocalMylistCommand
)
{
ApplicationLayoutManager = applicationLayoutManager;
PageManager = pageManager;
DialogService = dialogService;
NiconicoSession = niconicoSession;
UserProvider = userProvider;
_mylistRepository = mylistRepository;
_userMylistManager = userMylistManager;
_localMylistManager = localMylistManager;
CreateLocalMylistCommand = createLocalMylistCommand;
HohoemaPlaylist = hohoemaPlaylist;
IsLoginUserMylist = new ReactiveProperty <bool>(false);
OpenMylistCommand = new ReactiveCommand <IPlaylist>();
OpenMylistCommand.Subscribe(listItem =>
{
PageManager.OpenPage(HohoemaPageType.Mylist, $"id={listItem.Id}");
});
AddMylistGroupCommand = new DelegateCommand(async() =>
{
MylistGroupEditData data = new MylistGroupEditData()
{
Name = "",
Description = "",
IsPublic = false,
MylistDefaultSort = MylistDefaultSort.Latest,
IconType = IconType.Default,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
var result = await _userMylistManager.AddMylist(
data.Name,
data.Description,
data.IsPublic,
data.MylistDefaultSort,
data.IconType
);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
await ResetList();
break;
}
}
else
{
break;
}
}
}
, () => _userMylistManager.Mylists.Count < _userMylistManager.MaxMylistGroupCountCurrentUser
);
RemoveMylistGroupCommand = new DelegateCommand <Interfaces.IPlaylist>(async(item) =>
{
{
if (item is LocalPlaylist localPlaylist)
{
if (localPlaylist.IsWatchAfterPlaylist())
{
return;
}
}
else if (item is LoginUserMylistPlaylist loginUserMylist)
{
if (loginUserMylist.IsDefaultMylist())
{
return;
}
}
}
// 確認ダイアログ
var contentMessage = "ConfirmDeleteX_ImpossibleReDo".Translate(item.Label);
var dialog = new MessageDialog(contentMessage, "ConfirmDeleteX".Translate(item.GetOrigin().Translate()));
dialog.Commands.Add(new UICommand("Delete".Translate(), async(i) =>
{
if (item is LocalPlaylist localPlaylist)
{
_localMylistManager.RemovePlaylist(localPlaylist);
}
else if (item is LoginUserMylistPlaylist loginUserMylist)
{
await _userMylistManager.RemoveMylist(item.Id);
}
}));
dialog.Commands.Add(new UICommand("Cancel".Translate()));
dialog.CancelCommandIndex = 1;
dialog.DefaultCommandIndex = 1;
await dialog.ShowAsync();
});
EditMylistGroupCommand = new DelegateCommand <Interfaces.IPlaylist>(async item =>
{
if (item is LocalPlaylist localPlaylist)
{
if (item.Id == HohoemaPlaylist.WatchAfterPlaylistId)
{
return;
}
var resultText = await DialogService.GetTextAsync("RenameLocalPlaylist".Translate(),
localPlaylist.Label,
localPlaylist.Label,
(tempName) => !string.IsNullOrWhiteSpace(tempName)
);
if (!string.IsNullOrWhiteSpace(resultText))
{
localPlaylist.Label = resultText;
}
}
else if (item is LoginUserMylistPlaylist loginUserMylist)
{
if (loginUserMylist.IsDefaultMylist())
{
return;
}
MylistGroupEditData data = new MylistGroupEditData()
{
Name = loginUserMylist.Label,
Description = loginUserMylist.Description,
IsPublic = loginUserMylist.IsPublic,
MylistDefaultSort = loginUserMylist.DefaultSort,
IconType = loginUserMylist.IconType,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
var result = await loginUserMylist.UpdateMylist(data);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
loginUserMylist.Label = data.Name;
loginUserMylist.Description = data.Description;
loginUserMylist.IsPublic = data.IsPublic;
loginUserMylist.DefaultSort = data.MylistDefaultSort;
loginUserMylist.IconType = data.IconType;
break;
}
}
else
{
break;
}
}
}
});
}
public VideoPlayerPageViewModel(
IScheduler scheduler,
IEventAggregator eventAggregator,
Models.NiconicoSession niconicoSession,
Models.Subscription.SubscriptionManager subscriptionManager,
NicoVideoProvider nicoVideoProvider,
ChannelProvider channelProvider,
MylistProvider mylistProvider,
PlayerSettings playerSettings,
CacheSettings cacheSettings,
NGSettings ngSettings,
ApplicationLayoutManager applicationLayoutManager,
HohoemaPlaylist hohoemaPlaylist,
LocalMylistManager localMylistManager,
UserMylistManager userMylistManager,
PageManager pageManager,
MediaPlayer mediaPlayer,
NotificationService notificationService,
DialogService dialogService,
ExternalAccessService externalAccessService,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand,
Commands.Mylist.CreateLocalMylistCommand createLocalMylistCommand,
Commands.Mylist.CreateMylistCommand createMylistCommand,
UseCase.NicoVideoPlayer.VideoStreamingOriginOrchestrator videoStreamingOriginOrchestrator,
UseCase.VideoPlayer videoPlayer,
UseCase.CommentPlayer commentPlayer,
KeepActiveDisplayWhenPlaying keepActiveDisplayWhenPlaying,
ObservableMediaPlayer observableMediaPlayer,
WindowService windowService,
VideoEndedRecommendation videoEndedRecommendation,
PrimaryViewPlayerManager primaryViewPlayerManager,
TogglePlayerDisplayViewCommand togglePlayerDisplayViewCommand,
ShowPrimaryViewCommand showPrimaryViewCommand,
MediaPlayerSoundVolumeManager soundVolumeManager
)
{
_scheduler = scheduler;
NiconicoSession = niconicoSession;
SubscriptionManager = subscriptionManager;
NicoVideoProvider = nicoVideoProvider;
ChannelProvider = channelProvider;
MylistProvider = mylistProvider;
PlayerSettings = playerSettings;
CacheSettings = cacheSettings;
NgSettings = ngSettings;
ApplicationLayoutManager = applicationLayoutManager;
HohoemaPlaylist = hohoemaPlaylist;
LocalMylistManager = localMylistManager;
UserMylistManager = userMylistManager;
PageManager = pageManager;
_NotificationService = notificationService;
_HohoemaDialogService = dialogService;
ExternalAccessService = externalAccessService;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
CreateLocalMylistCommand = createLocalMylistCommand;
CreateMylistCommand = createMylistCommand;
_videoStreamingOriginOrchestrator = videoStreamingOriginOrchestrator;
VideoPlayer = videoPlayer;
CommentPlayer = commentPlayer;
PrimaryViewPlayerManager = primaryViewPlayerManager;
TogglePlayerDisplayViewCommand = togglePlayerDisplayViewCommand;
ShowPrimaryViewCommand = showPrimaryViewCommand;
SoundVolumeManager = soundVolumeManager;
ObservableMediaPlayer = observableMediaPlayer
.AddTo(_CompositeDisposable);
WindowService = windowService
.AddTo(_CompositeDisposable);
VideoEndedRecommendation = videoEndedRecommendation
.AddTo(_CompositeDisposable);
_keepActiveDisplayWhenPlaying = keepActiveDisplayWhenPlaying
.AddTo(_CompositeDisposable);
MediaPlayer = mediaPlayer;
SeekCommand = new MediaPlayerSeekCommand(MediaPlayer);
SetPlaybackRateCommand = new MediaPlayerSetPlaybackRateCommand(MediaPlayer);
ToggleMuteCommand = new MediaPlayerToggleMuteCommand(MediaPlayer);
VolumeUpCommand = new MediaPlayerVolumeUpCommand(SoundVolumeManager);
VolumeDownCommand = new MediaPlayerVolumeDownCommand(SoundVolumeManager);
}
public RankingCategoryPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
PageManager pageManager,
HohoemaPlaylist hohoemaPlaylist,
NicoVideoProvider nicoVideoProvider,
RankingProvider rankingProvider,
RankingSettings rankingSettings,
NGSettings ngSettings,
IScheduler scheduler,
IEventAggregator eventAggregator
)
{
ApplicationLayoutManager = applicationLayoutManager;
PageManager = pageManager;
HohoemaPlaylist = hohoemaPlaylist;
NicoVideoProvider = nicoVideoProvider;
RankingProvider = rankingProvider;
RankingSettings = rankingSettings;
NgSettings = ngSettings;
_scheduler = scheduler;
_eventAggregator = eventAggregator;
IsFailedRefreshRanking = new ReactiveProperty <bool>(false)
.AddTo(_CompositeDisposable);
CanChangeRankingParameter = new ReactiveProperty <bool>(false)
.AddTo(_CompositeDisposable);
SelectedRankingTag = new ReactiveProperty <Database.Local.RankingGenreTag>();
SelectedRankingTerm = new ReactiveProperty <RankingTerm?>(RankingTerm.Hour);
CurrentSelectableRankingTerms = new[]
{
this.ObserveProperty(x => RankingGenre).ToUnit(),
SelectedRankingTag.ToUnit()
}
.CombineLatest()
.Select(x =>
{
if (RankingGenre != RankingGenre.HotTopic)
{
if (string.IsNullOrEmpty(SelectedRankingTag.Value?.Tag))
{
return(NiconicoRanking.Constants.AllRankingTerms);
}
else
{
return(NiconicoRanking.Constants.GenreWithTagAccepteRankingTerms);
}
}
else
{
return(NiconicoRanking.Constants.HotTopicAccepteRankingTerms);
}
})
.ToReadOnlyReactivePropertySlim()
.AddTo(_CompositeDisposable);
new[] {
this.ObserveProperty(x => RankingGenre).ToUnit(),
SelectedRankingTag.ToUnit(),
SelectedRankingTerm.Where(x => !_nowInitializeRankingTerm).ToUnit()
}
.CombineLatest()
.Where(_ => _IsNavigateCompleted)
.Throttle(TimeSpan.FromMilliseconds(250))
.Subscribe(__ =>
{
_ = ResetList();
})
.AddTo(_CompositeDisposable);
CurrentSelectableRankingTerms
.Delay(TimeSpan.FromMilliseconds(50))
.Subscribe(x =>
{
_nowInitializeRankingTerm = true;
SelectedRankingTerm.Value = x[0];
_nowInitializeRankingTerm = false;
})
.AddTo(_CompositeDisposable);
}
