Пример #1
0
        async void ReloadAllVideo()
        {
            Stopwatch st     = null;
            var       loader = ResourceLoader.GetForCurrentView();

            //앱바에 시작 상태 통지
            EnableButtons(false);

            if (Debugger.IsAttached)
            {
                st = new Stopwatch();
                st.Start();
            }

            await ThreadPool.RunAsync(async handler =>
            {
                var mfiList = new List <MediaInfo>();
                //재생목록 로드 (이미 추가된 파일인지 표시를 위해)
                playlist = new List <MediaInfo>();
                fileDAO.LoadPlayList(playlist, 100, 0, false);

                //캐시 로딩의 경우 DB로 부터 캐시를 먼저 로드
                if (loadingMode == LoadingMode.Caching)
                {
                    fileDAO.LoadAllVideoList(mfiList, playlist);
                }

                await DispatcherHelper.RunAsync(() =>
                {
                    //목록 초기화
                    AllVideoSource.Clear();
                    //캐시 로드인 경우 로딩 경로를 "캐시에서 로딩" 으로 변경
                    if (loadingMode == LoadingMode.Caching && mfiList.Count > 0)
                    {
                        SearchFolderPath = loader.GetString("Cache");
                    }
                });

                bool isLoaded = false;
                if (loadingMode == LoadingMode.Caching && mfiList.Count > 0)
                {
                    //로딩 표시
                    loadingMode = LoadingMode.None;
                    //캐시 로딩 처리...
                    var jumpGroupList = mfiList.ToAlphaGroups(x => x.Name);
                    foreach (var jumpGroup in jumpGroupList)
                    {
                        await DispatcherHelper.RunAsync(() =>
                        {
                            AllVideoSource.Add(jumpGroup);
                        });
                    }
                    //캐시 로딩 완료 처리
                    isLoaded = true;
                }
                else
                {
                    //로딩 표시
                    loadingMode = LoadingMode.None;

                    List <FolderInfo> folderList = null;
                    InitializeAllVideos(out folderList);

                    //폴더 목록이 비어 있으면 로딩완료 처리
                    isLoaded = folderList.Count == 0;

                    //캐시 로딩이 아닌경우 (디렉토리 풀스캔)
                    //폴더내 파일 로딩 처리
                    if (!isLoaded)
                    {
                        foreach (var fi in folderList)
                        {
                            LoadFilesRecursively(await fi.GetStorageFolder(true), AddAllVideoJumpList);
                        }

                        isLoaded = true;
                    }
                }

                if (isLoaded)
                {
                    //화면 로딩 상태 제거 (캐시로딩 또는 캐시로딩은 아니지만, 로딩할 폴더 목록이 없는 경우)
                    await DispatcherHelper.RunAsync(() =>
                    {
                        //진행바 및 현재 탐색 폴더 표시 삭제
                        SearchFolderPath = string.Empty;
                        //우측 상단 버튼 그룹 제어
                        EnableButtons(true);
                        //시크 데이터 정리
                        //fileDAO.DeleteSeekingData();
                        //재생 목록 정리
                        fileDAO.CleanPlayList();
                    });
                }

                if (Debugger.IsAttached)
                {
                    Debug.WriteLine("전체 비디오 로딩 완료 : " + st.Elapsed);
                }

                //전체 로딩 후 생성 요청...
                MessengerInstance.Send <Message>(new Message("CheckSearchElement", null), MainViewModel.NAME);
            });
        }
Пример #2
0
        /// <summary>
        /// 다른 뷰모델들로 부터 수신된 메세지를 처리한다.
        /// </summary>
        private void RegisterMessages()
        {
            //재생목록 메세지 수신
            MessengerInstance.Register <Message>(this, NAME, (msg) =>
            {
                switch (msg.Key)
                {
                case "Activated":
                    if (loadingModel != LoadingMode.None)
                    {
                        PlaylistSource.Clear();
                        LoadFiles();
                    }
                    break;

                case "MoveToSection":
                    //재생목록 섹션으로 이동
                    MoveToSection(msg.GetValue <HubSection>());
                    break;

                case "BackPressed":
                    msg.GetValue <BackPressedEventArgs>().Handled = true;
                    if (SelectionMode != ListViewSelectionMode.None)
                    {
                        //선택 모드 변경
                        SelectionMode               = ListViewSelectionMode.None;
                        MainButtonGroupVisible      = true;
                        CheckListButtonGroupVisible = false;
                        ReorderButtonGroupVisible   = false;
                    }
                    else
                    {
                        //종료 확인
                        MessengerInstance.Send <Message>(new Message("ConfirmTermination", null), MainViewModel.NAME);
                    }
                    break;

                case "FolderDeleted":
                    //허브섹션을 반대 방향으로 들어오는 경우, 모든 비디오 DB가 초기화 되어 있지 않으면 초기화를 시킨다.
                    MessengerInstance.Send <Message>(new Message("CheckFolderSyncForPlaylist", null), AllVideoViewModel.NAME);
                    //탐색기에서 삭제된 폴더 삭제 Trigger
                    //재생 목록 생성전 모든 비디오 파일과 재생 목록을 동기화하여 존재하지 않는 파일을 재생목록에서 제거
                    fileDAO.CleanPlayList();
                    //로딩 요청 상태 변경
                    loadingModel = LoadingMode.Caching;
                    break;

                case "PlayItem":
                    PlayItem(msg.GetValue <MediaInfo>());
                    break;

                case "PlayList":
                    loadingModel = LoadingMode.Caching;
                    var list     = msg.GetValue <IEnumerable <MediaInfo> >();
                    MessengerInstance.Send <Message>(new Message("MoveToPlaylistSection", list.Count() > 1), CCPlayerViewModel.NAME);
                    //재생 목록 생성전 모든 비디오 파일과 재생 목록을 동기화하여 존재하지 않는 파일을 재생목록에서 제거
                    fileDAO.CleanPlayList();
                    //재생 목록 생성
                    MakePlaylist(list);
                    break;

                case "UpdatePausedTime":
                    var source = msg.GetValue <MediaInfo>();
                    fileDAO.UpdatePlayList(new MediaInfo[] { source });
                    //화면 업데이트 처리
                    var item = PlaylistSource.FirstOrDefault(x => x.Path == source.Path);
                    if (item != null)
                    {
                        item.RunningTime = source.RunningTime;
                        item.PausedTime  = source.PausedTime;
                    }
//                        System.Diagnostics.Debug.WriteLine(string.Format("재생시간 업데이트 : {0}", TimeSpan.FromSeconds(source.PausedTime)));
                    break;

                case "FileAssociation":
                    var value = msg.GetValue <FileActivatedEventArgs>();
                    if (value.Files != null && value.Files.Count > 0)
                    {
                        var file = value.Files.FirstOrDefault();

                        if (file != null && file.IsOfType(Windows.Storage.StorageItemTypes.File))
                        {
                            var mi = new MediaInfo((StorageFile)file);

                            //로딩 패널 표시
                            var loader     = ResourceLoader.GetForCurrentView();
                            var loadingMsg = string.Format(loader.GetString("Loading"), loader.GetString("Video"));
                            MessengerInstance.Send(new Message("ShowLoadingPanel", new KeyValuePair <string, bool>(loadingMsg, true)), MainViewModel.NAME);

                            DispatcherHelper.CheckBeginInvokeOnUI(async() =>
                            {
                                try
                                {
                                    StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(mi.ParentFolderPath);
                                    IReadOnlyList <StorageFile> fileStorageList = await folder.GetFilesAsync();
                                    List <StorageFile> subtitleList             = fileStorageList.Where(x => x.IsSubtitleFile()).ToList();

                                    var pathName = mi.Path.Remove(mi.Path.Length - Path.GetExtension(mi.Path).Length);
                                    //자막 검색
                                    foreach (var ext in CCPlayerConstant.SUBTITLE_FILE_SUFFIX)
                                    {
                                        StorageFile subtitleFile = null;
                                        try
                                        {
                                            subtitleFile = new List <StorageFile>(subtitleList).FirstOrDefault(x => Path.GetExtension(x.Path).ToUpper() == ext.ToUpper() &&
                                                                                                               x.Path.Length > ext.Length && x.Path.Remove(x.Path.Length - ext.Length).ToUpper().Contains(pathName.ToUpper()));
                                        }
                                        catch (Exception) { }

                                        if (subtitleFile != null)
                                        {
                                            subtitleList.Remove(subtitleFile);

                                            //자막을 미디어 파일에 연결
                                            mi.AddSubtitle(new SubtitleInfo(subtitleFile));
                                        }
                                    }
                                }
                                catch (System.UnauthorizedAccessException)
                                { }

                                //재생 처리
                                MessengerInstance.Send <Message>(new Message("Play", mi), CCPlayerViewModel.NAME);
                            });
                        }
                    }
                    break;

                case "ShowErrorFile":
                    if (PlaylistSource.Any())
                    {
                        var kv = msg.GetValue <KeyValuePair <string, MediaInfo> >();
                        var mi = PlaylistSource.FirstOrDefault(f => f.Path == kv.Value.Path);
                        if (mi != null)
                        {
                            mi.OccuredError = kv.Key + "\n";
                        }
                    }
                    break;

                case "RemovePlayList":
                    OnRemovePlayList(msg.GetValue <MediaInfo>());
                    break;
                }
            });
        }