Exemplo n.º 1
0
 /// <summary>
 /// 加载自定义视图(通常用于在线阅读)
 /// </summary>
 /// <param name="chapters">目录列表</param>
 /// <param name="style">视图样式</param>
 /// <param name="details">目录详情列表(其中包含单个章节的内容)</param>
 public void LoadCustomView(List <Chapter> chapters, ReaderStyle style, List <ChapterDetail> details = null)
 {
     if (chapters == null || chapters.Count == 0 || style == null)
     {
         throw new ArgumentNullException();
     }
     OpenStarting?.Invoke(this, EventArgs.Empty);
     if (_tempSpeechStream != null)
     {
         _tempSpeechStream.Dispose();
         _tempSpeechStream = null;
     }
     ReaderType = _readerView.ReaderType = ReaderType.Custom;
     Chapters   = chapters;
     ChapterLoaded?.Invoke(this, Chapters);
     _readerView.ViewStyle = style;
     UpdateBackground(style);
     if (details != null)
     {
         CustomChapterDetailList = details;
     }
     else
     {
         CustomChapterDetailList = new List <ChapterDetail>();
     }
     OpenCompleted?.Invoke(this, EventArgs.Empty);
 }
Exemplo n.º 2
0
        /// <summary>
        /// 打开书籍文件
        /// </summary>
        /// <param name="bookFile">书籍文件</param>
        /// <param name="style">阅读器样式</param>
        /// <param name="chapters">外部导入的目录(通常是前一次生成的目录,以避免重复生成目录),为<c>null</c>或空列表将重新生成目录</param>
        /// <returns></returns>
        public async Task OpenAsync(StorageFile bookFile, ReaderStyle style, List <Chapter> chapters = null)
        {
            if (bookFile == null)
            {
                throw new ArgumentNullException();
            }

            string extension = Path.GetExtension(bookFile.Path).ToLower();

            if (extension != ".epub" && extension != ".txt")
            {
                throw new NotSupportedException("File type not support (Currently only support txt and epub file)");
            }
            OpenStarting?.Invoke(this, EventArgs.Empty);
            if (_tempSpeechStream != null)
            {
                _tempSpeechStream.Dispose();
                _tempSpeechStream = null;
            }
            bool hasExternalChapters = chapters != null && chapters.Count > 0;

            if (hasExternalChapters)
            {
                Chapters = chapters;
                ChapterLoaded?.Invoke(this, Chapters);
            }
            _readerView.ViewStyle = style;
            UpdateBackground(style);
            if (extension.ToLower() == ".txt")
            {
                ReaderType = _readerView.ReaderType = ReaderType.Txt;
                _readerView.SetVirtualMode(true);
                if (!hasExternalChapters)
                {
                    Chapters = await GetTxtChapters(bookFile);

                    ChapterLoaded?.Invoke(this, Chapters);
                }
                _txtContent = await GetTxtContent(bookFile);
            }
            else
            {
                _readerView.SetVirtualMode(false);
                ReaderType   = _readerView.ReaderType = ReaderType.Epub;
                _epubContent = await EpubReader.Read(bookFile, Encoding.Default);

                if (!hasExternalChapters)
                {
                    Chapters = GetEpubChapters(_epubContent);
                    ChapterLoaded?.Invoke(this, Chapters);
                }
                _readerView.EpubInit(_epubContent, style);
            }

            OpenCompleted?.Invoke(this, EventArgs.Empty);
        }
Exemplo n.º 3
0
        /// <summary>
        /// 打开书籍文件
        /// </summary>
        /// <param name="bookFile">书籍文件</param>
        /// <param name="style">阅读器样式</param>
        /// <returns></returns>
        public async Task OpenAsync(StorageFile bookFile, ReaderStyle style)
        {
            if (bookFile == null)
            {
                throw new ArgumentNullException();
            }

            string extension = Path.GetExtension(bookFile.Path).ToLower();

            if (extension != ".epub" && extension != ".txt")
            {
                throw new NotSupportedException("File type not support (Currently only support txt and epub file)");
            }
            OpenStarting?.Invoke(this, EventArgs.Empty);
            if (extension == ".txt")
            {
                if (!(style is TxtViewStyle))
                {
                    throw new ArgumentException("Open txt file need TxtViewStyle argument");
                }
                ReaderType = Enums.ReaderType.Txt;
                Chapters   = await GetTxtChapters(bookFile);

                ChapterLoaded?.Invoke(this, Chapters);
                if (_mainPresenter.Content == null || !(_mainPresenter.Content is TxtView))
                {
                    if (_txtView == null)
                    {
                        _txtView = new TxtView();
                        _txtView.PrevPageSelected     += OnPrevPageSelected;
                        _txtView.NextPageSelected     += OnNextPageSelected;
                        _txtView.LoadingStatusChanged += OnLoad;
                        _txtView.ProgressChanged      += OnProgressChanged;
                        _txtView.TouchHolding         += OnTouchHolding;
                        _txtView.TouchTapped          += (_s, _e) => { TouchTapped?.Invoke(_s, _e); };
                        _txtView.Loaded += (_s, _e) =>
                        {
                            _txtView.SingleColumnMaxWidth = SingleColumnMaxWidth;
                            _txtView.ReaderFlyout         = ReaderFlyout;
                            ViewLoaded?.Invoke(this, EventArgs.Empty);
                        };
                    }
                    _mainPresenter.Content = _txtView;
                }
                _txtContent = await GetTxtContent(bookFile);

                _txtView.ViewStyle = style as TxtViewStyle;
            }
            else
            {
                if (!(style is EpubViewStyle))
                {
                    throw new ArgumentException("Open epub file need EpubViewStyle argument");
                }
                ReaderType   = Enums.ReaderType.Epub;
                _epubContent = await EpubReader.Read(bookFile, Encoding.Default);

                Chapters = GetEpubChapters(_epubContent);
                ChapterLoaded?.Invoke(this, Chapters);
                if (_mainPresenter.Content == null || !(_mainPresenter.Content is EpubView))
                {
                    if (_epubView == null)
                    {
                        _epubView = new EpubView();
                        _epubView.PrevPageSelected     += OnPrevPageSelected;
                        _epubView.NextPageSelected     += OnNextPageSelected;
                        _epubView.LoadingStatusChanged += OnLoad;
                        _epubView.ProgressChanged      += OnProgressChanged;
                        _epubView.TouchHolding         += OnTouchHolding;
                        _epubView.TouchTapped          += (_s, _e) => { TouchTapped?.Invoke(_s, _e); };
                        _epubView.Loaded += (_s, _e) =>
                        {
                            _epubView.SingleColumnMaxWidth = SingleColumnMaxWidth;
                            _epubView.ReaderFlyout         = ReaderFlyout;
                            ViewLoaded?.Invoke(this, EventArgs.Empty);
                        };
                        _epubView.LinkTapped  += (_s, _e) => { LinkTapped?.Invoke(this, _e); };
                        _epubView.ImageTapped += (_s, _e) => { ImageTapped?.Invoke(this, _e); };
                    }

                    _mainPresenter.Content = _epubView;
                }
                _epubView.Init(_epubContent, style as EpubViewStyle);
            }
            OpenCompleted?.Invoke(this, EventArgs.Empty);
        }
Exemplo n.º 4
0
        private void ParsCommand(XfsCommandBase <object> commandBase)
        {
            switch (commandBase.CommandType)
            {
            case CommandType.Execute:
            {
                blockingQueue.Clear();
                var cmnd = JsonConvert.DeserializeObject <ExecuteCommand>(JsonConvert.SerializeObject(commandBase.XfsCommand));
                if (commandBase.IsExecuteSuccessfully)
                {
                    if (cmnd.CommandCode == BCRDefinition.WFS_CMD_BCR_READ)
                    {
                        blockingQueue.Clear();
                        try
                        {
                            var data = XFSUtil.Cast <BarcodeData[]>(cmnd.ResultModel)[0].Value;
                            ReadDataCompleted?.Invoke(data);
                        }
                        catch (Exception ex)
                        {
                            L4Logger.Error(ex);
                            //MediaError.Invoke();
                        }
                    }
                }
                else
                {
                    if (commandBase.ErrorCode == XFSDefinition.WFS_ERR_CANCELED)
                    {
                        return;
                    }
                    if (cmnd.CommandCode == BCRDefinition.WFS_CMD_BCR_READ)
                    {
                        ReadDataError?.Invoke("BCR", commandBase.ErrorCode, commandBase.ErrorCode.ToString());
                        //if (workingMode == WorkingMode.None || workingMode == WorkingMode.EjectCard)
                        //    return;
                        //else
                        //    ReadRawDataError?.Invoke("IDC", commandBase.ErrorCode, commandBase.ErrorCode.ToString());

                        //workingMode = WorkingMode.None;
                    }
                }
                break;
            }

            case CommandType.Open:
            {
                var cmnd = JsonConvert.DeserializeObject <OpenCommand>(JsonConvert.SerializeObject(commandBase.XfsCommand));
                if (commandBase.IsExecuteSuccessfully)
                {
                    if (commandBase.Detail.Equals("XFSDevice_OpenComplete"))
                    {
                        IsOpenned = true;
                        OpenCompleted?.Invoke();
                    }
                    if (commandBase.Detail.Equals("XFSDevice_RegisterComplete"))
                    {
                        RegisterCompleted?.Invoke();
                    }
                }
                else
                {
                    if (commandBase.Detail.Equals("XFSDevice_OpenError"))
                    {
                        IsOpenned = false;
                        OpenError?.Invoke(commandBase.ErrorCode);
                    }
                    if (commandBase.Detail.Equals("XFSDevice_RegisterError"))
                    {
                        RegisterError?.Invoke(commandBase.ErrorCode);
                    }
                }
                break;
            }

            case CommandType.Getinfo:
            {
                var cmnd = JsonConvert.DeserializeObject <GetInfoCommand>(JsonConvert.SerializeObject(commandBase.XfsCommand));
                GetInfoResponse?.Invoke(XFSUtil.Cast <WFSBCRSTATUS>(cmnd.Status), null);
                break;
            }
            }
        }