Exemple #1
0
        private async void DeleteItemTapped(object sender, TappedRoutedEventArgs args)
        {
            ListView listView = GetListView(sender as DependencyObject);

            if (listView != null)
            {
                var removeList = listView.SelectedItems.Cast <PlayListFile>().ToList();

                var result = playListDAO.DeletePlayListFiles(CurrentPlayList, removeList);
                if (result == SQLitePCL.SQLiteResult.DONE)
                {
                    foreach (var plf in removeList)
                    {
                        PlayListFileSource.Remove(plf);
                    }

                    //삭제 후 액션바 이전 상태로 복원
                    if (PlayListFileSource?.Count == 0)
                    {
                        BackNormalButtonSetTapped(null, null);
                    }
                }
                else
                {
                    var resource = ResourceLoader.GetForCurrentView();
                    var dlg      = DialogHelper.GetSimpleContentDialog(
                        resource.GetString("Message/Error/Remove"),
                        resource.GetString("Message/Error/Retry"),
                        resource.GetString("Button/Close/Content"));
                    await dlg.ShowAsync();
                }
            }
        }
Exemple #2
0
        private void ShowMediaInfoFlyout(FrameworkElement elem)
        {
            PlayListFile plf = null;

            if (elem != null && (plf = elem.DataContext as PlayListFile) != null)
            {
                MessengerInstance.Send <Message <DecoderTypes> >(
                    new Message <DecoderTypes>(async(decoderType) =>
                {
                    int newIndex          = PlayListFileSource.IndexOf(PlayListFileSource.FirstOrDefault(x => x == plf));
                    _RequestedDecoderType = decoderType;
                    if (SelectedIndex != newIndex)
                    {
                        SelectedIndex = newIndex;
                    }
                    //로딩 패널 표시
                    MessengerInstance.Send(new Message("IsOpen", true), "ShowLoadingPanel");
                    await ThreadPool.RunAsync(async handler =>
                    {
                        await DispatcherHelper.RunAsync(() =>
                        {
                            //재생요청
                            RequestPlayback(false);
                        });
                    }, WorkItemPriority.Normal);
                })
                    .Add("StorageItemInfo", plf)
                    .Add("ButtonName", "CodecInformation"),
                    "ShowMediaFileInformation");
            }
        }
Exemple #3
0
        private async Task LoadPlayListFiles(List <PlayListFile> playListFileList)
        {
            for (int i = 0; i < playListFileList.Count; i++)
            {
                var playListFile = playListFileList[i];
                //파일에 필요한 정보 셋팅
                SetPlayListFile(playListFile);
                //자막 목록 미리 로드
                await SetSubtitleList(playListFile);

                //UI리스트에 추가
                PlayListFileSource.Add(playListFile);
                //추가 정보 로드
                LoadExtraInfoAsync(playListFile);
            }
        }
Exemple #4
0
        private async void LoadPlayListFilesAsync(List <PlayListFile> playListFileList)
        {
            await ThreadPool.RunAsync(async handler =>
            {
                if (playListFileList != null)
                {
                    for (int i = 1; i <= playListFileList.Count; i++)
                    {
                        var playListFile = playListFileList[i - 1];
                        //파일에 필요한 정보 셋팅
                        SetPlayListFile(playListFile);
                        //자막 목록 미리 로드
                        await SetSubtitleList(playListFile);

                        int mod = i % LOAD_ITEM_COUNT;
                        if (mod == 0 || i == playListFileList.Count)
                        {
                            await DispatcherHelper.RunAsync(() =>
                            {
                                int j = mod > 0 ? i - mod : i - LOAD_ITEM_COUNT;
                                for (; j < i; j++)
                                {
                                    PlayListFileSource.Add(playListFileList[j]);
                                    //추가 정보 로드
                                    LoadExtraInfoAsync(playListFileList[j]);
                                }
                            });
                        }
                    }
                }

                //로딩 완료 처리
                await DispatcherHelper.RunAsync(() =>
                {
                    IsStopLoadingIndicator = true;
                    if (PlayListFileSource.Any(x => PreparedData?.StorageItemInfo.Path == x.Path))
                    {
                        _RequestedDecoderType = PreparedData.DecoderType;
                        RequestPlaybackWithLoadingPanel(PreparedData.StorageItemInfo);
                        //초기화
                        PreparedData = null;
                    }
                });
            }, WorkItemPriority.Low);
        }
Exemple #5
0
        private async void LoadPlayList()
        {
            _SubtitlesList.Clear();
            //목록 초기화
            PlayListFileSource.Clear();
            //DB에서 조회
            List <PlayListFile> playListFileList = new List <PlayListFile>();

            playListDAO.LoadPlayListFiles(CurrentPlayList, playListFileList);
            if (playListFileList.Count > 0)
            {
                IsStopLoadingIndicator = false;
                int count = playListFileList.Count > PreparedData?.SyncLoadPlayListFileCount ? PreparedData.SyncLoadPlayListFileCount : playListFileList.Count;

                //재생목록 파일들의 폴더 리스트
                foreach (var path in playListFileList.GroupBy(x => x.ParentFolderPath).Select(x => x.Key))
                {
                    _SubtitlesList.Add(path, null);
                }

                //탐색기에서 파일 선택시 선택한 파일 이후를 모두 지금 재생중에 로딩이 되므로 하나를 먼저 로드할 필요가 있음.
                await LoadPlayListFiles(playListFileList.GetRange(0, count));

                if (PlayListFileSource.Any(x => PreparedData?.StorageItemInfo.Path == x.Path))
                {
                    _RequestedDecoderType = PreparedData.DecoderType;
                    RequestPlaybackWithLoadingPanel(PreparedData.StorageItemInfo);
                    //초기화
                    PreparedData = null;
                }

                if (playListFileList.Count == count)
                {
                    //더이상 로딩할 아이템이 없으면 로딩 표시 정지
                    IsStopLoadingIndicator = true;
                }
                else
                {
                    //로딩할 아이템이 남았으면 비동기로 로딩
                    LoadPlayListFilesAsync(playListFileList.GetRange(count, playListFileList.Count - count));
                }
            }
            _ChangedIndexList.Clear();
        }
Exemple #6
0
 private async void RequestPlaybackWithLoadingPanel(StorageItemInfo item)
 {
     if (item != null)
     {
         //추가되는 경우가 있으므로 만일을 대비해 가장 뒤의 아이템 선택
         var newIndex = PlayListFileSource.IndexOf(PlayListFileSource.LastOrDefault(x => x.Path == item.Path));
         if (newIndex > -1 && newIndex < PlayListFileSource.Count)
         {
             SelectedIndex = newIndex;
             //로딩 패널 표시
             MessengerInstance.Send(new Message("IsOpen", true), "ShowLoadingPanel");
             await ThreadPool.RunAsync(async handler =>
             {
                 await DispatcherHelper.RunAsync(() =>
                 {
                     //재생요청
                     RequestPlayback(true);
                 });
             }, WorkItemPriority.Normal);
         }
     }
 }
Exemple #7
0
        protected override void RegisterMessage()
        {
            MessengerInstance.Register <PlayList>(this, "ChangePlayList", (playList) =>
            {
                CurrentPlayList = playList;
            });

            MessengerInstance.Register <bool>(this, "ResetSelectionMode", (val) =>
            {
                SelectedIndex = -1;
                BackNormalButtonSetTapped(null, null);
            });

            MessengerInstance.Register <Message>(this, "PrepareLoadPlayListFile", (message) =>
            {
                PreparedData = new PreparedData
                {
                    //재생목록에서 지금재생중으로 이동 직전에 동기로드 카운트 설정
                    //지금 재생할 비디오와 다음 재생 프리뷰용으로 총 2개
                    SyncLoadPlayListFileCount = 2,
                    DecoderType     = message.GetValue <DecoderTypes>("DecoderType"),
                    StorageItemInfo = message.GetValue <StorageItemInfo>("StorageItemInfo")
                };
            });

            //FileAssociation에서 이미 "지금 재생중"이 선택되어진 상태에서 넘어온다.
            MessengerInstance.Register <Message>(this, "SelectPlayListFile", async(message) =>
            {
                BackNormalButtonSetTapped(null, null);
                _RequestedDecoderType = message.GetValue <DecoderTypes>("DecoderType");
                var storageItemInfo   = message.GetValue <StorageItemInfo>("StorageItemInfo");
                var orderNo           = PlayListFileSource.LastOrDefault() != null ? (int)PlayListFileSource.LastOrDefault().OrderNo : 0;

                //새롭게 추가된
                List <PlayListFile> playListFileList = new List <PlayListFile>();
                playListDAO.LoadPlayListFiles(CurrentPlayList, orderNo, (playListFile) =>
                {
                    //이벤트 등록 및 표시명 설정
                    SetPlayListFile(playListFile);
                    //리스트에 바인딩
                    if (PlayListFileSource.All(x => x.Path != playListFile.Path))
                    {
                        PlayListFileSource.Add(playListFile);
                    }
                    else if (PlayListFileSource.Any(x => x.Path == playListFile.Path && x.OrderNo != playListFile.OrderNo))
                    {
                        //기존 리스트에 존재하나 순서가 변경된 경우
                        var tmp = PlayListFileSource.First(x => x.Path == playListFile.Path && x.OrderNo != playListFile.OrderNo);
                        PlayListFileSource.Remove(tmp);
                        PlayListFileSource.Add(playListFile);
                    }
                    //추가 정보 로드
                    LoadExtraInfoAsync(playListFile);
                });

                var newIndex = PlayListFileSource.IndexOf(PlayListFileSource.LastOrDefault(x => x.Path == storageItemInfo.Path));
                if (newIndex > -1 && newIndex < PlayListFileSource.Count)
                {
                    SelectedIndex = newIndex;
                    //로딩 패널 표시
                    MessengerInstance.Send(new Message("IsOpen", true), "ShowLoadingPanel");
                    await ThreadPool.RunAsync(async handler =>
                    {
                        await DispatcherHelper.RunAsync(() =>
                        {
                            //재생요청
                            RequestPlayback(true);
                        });
                    }, WorkItemPriority.Normal);
                }
            });

            MessengerInstance.Register <int>(this, "NextPlayListFile", (index) =>
            {
                var nextIndex = SelectedIndex + index;
                if (nextIndex > -1 && nextIndex < PlayListFileSource.Count)
                {
                    SelectedIndex = nextIndex;
                    PlayListFileSource[SelectedIndex].PausedTime = TimeSpan.FromSeconds(0);
                    RequestPlayback(false);
                }
            });

            MessengerInstance.Register <Message>(this, "SavePlayListFile", (message) =>
            {
                var file = message.GetValue <PlayListFile>();
                playListDAO.UpdatePausedTime(file);
                //System.Diagnostics.Debug.WriteLine("PlayListViewModel : Message - SavePlayListFile =>" + file.PausedTime);
            });
        }