EPUB SDK
for EPUB Reader Development

init {
   val config = EpubearConfig(companyName, appName, licenseKey, ApplicationProvider.getAppContext().filesDir)
   epubear = EpubearSdk(ApplicationProvider.getAppContext(), config).apply {
       setEventListener(this)
       setCfiListener(this)
       setAppearanceMode(EpubearSdk.EPUBAppearanceMode.EPUBAppearanceModeNormal)
       setFontSize(0, false)
   }
}

guard let cachesDirectory = FileManager.default.urls(
    for: .cachesDirectory,
    in: .userDomainMask
).first else { return nil }
let config = EPUBearFrameworkConfig(username: companyName,
                                    withUserApp: appName,
                                    withUserKey: licenseKey,
                                    withDataPath: cachesDirectory.path)
config.alwaysSinglePage = false
epubear = EPUBearFramework(config: config)
epubear.delegate = self

// This should be called separately for both Platforms - Android and iOS
var config = new EpuBearConfig(companyName, appName, licenseKey);
IEpuBearSDK epubear = new EpuBearSDK(config);
// Further code is called in common MAUI code after IEpuBearSDK was received through DependencyService or any other DI way
epubear.SetFontSize(16, false);
epubear.Callbacks.ContentUpdated = OnContentUpdate;
epubear.Callbacks.PagesCounted = OnPageCountChange;
epubear.Callbacks.LoadedChapterWithIndex = LoadedChapterWithIndex;
epubear.Callbacks.ChapterLoadingStarted = OnChapterLoadingStarted;
string masterPath = DependencyService
    .Get<IGetResource>()
    .GetPathForResource("master.css");
if (File.Exists(masterPath))
{
    string masterCss = File.ReadAllText(masterPath);
    epubear.SetDefaultStyles(masterCss, false);
}

final dpi = MediaQuery.of(context).devicePixelRatio * 160;
final config = EpubConfig(
  user: companyName,
  info: appName,
  key: licenseKey,
  dpi: dpi,
  fontsPackagePath: 'fonts.pkg',
);
final epubear = await EpubearSdk.create(config);
final cachePath = '${(await Directory.systemTemp.create()).parent.path}/files';
await Directory(cachePath).create(recursive: true);
epubear.setCachePath(path);
epubear.eventsListener = this;

epubear.usePreprocessing(true)
epubear.openDocument(filePath)

epubear.openDocument(path: filePath)

epubear.OpenDocument(filePath);

await setEntity(epubear.getEntity());
epubear.setPreprocessingEnabled(true);
epubear.updateImageCallback();
epubear.openDocumentFile(filePath);

val name = epubear.getMetadata(EpubearSdk.EPUBMetadata.Title)
val author = epubear.getMetadata(EpubearSdk.EPUBMetadata.Creator)

guard let documentDirectory = NSSearchPathForDirectoriesInDomains(
    .documentDirectory,
    .userDomainMask, true
).first else { return }
epubear.getMetaData(
    withPath: filePath,
    currentAppPath: documentDirectory
) { metaData, _ in
    // Get data from metaData object
}

var name = epubear.GetDataMeta(EPUBMetadata.Title);
var author = epubear.GetDataMeta(EPUBMetadata.Creator);

final name = epubear.getMetadata(Metadata.title);
final author = epubear.getMetadata(Metadata.creator);

init {
   val imageCacheParams = ImageCache.ImageCacheParams().apply {
       setMemCacheContainerSize(ImageCache.DEFAULT_MEM_CACHE_CONTAINER_SIZE)
   }
   imageCache = ImageCache(imageCacheParams)
}


override fun doRegisterBitmaps() {
   for (i in 0 until 3) {
       val bitmapOptions: BitmapFactory.Options = BitmapFactory.Options().apply {
           inSampleSize = 1
           outWidth = pageWidth
           outHeight = pageHeight
       }


       val pageBitmap = imageCache.getBitmapFromReusableSet(bitmapOptions)
               ?: Bitmap.createBitmap(pageWidth, pageHeight, Bitmap.Config.ARGB_8888)


       imageCache.addBitmapToCache(pageBitmap.toString(), pageBitmap)


       clearBitmap(pageBitmap)
       replaceBitmap(EpubearSdk.EPUBBitmapPosition.values()[i + 1], pageBitmap)
   }
}


override fun onSizeChanged(width: Int, height: Int) {
   if ((width > 0 && height > 0) && 
       (width != epubViewWidth || height != epubViewHeight)) {
       epubViewWidth = width
       epubViewHeight = height
       epubear.apply {
           updateBitmapSize(width, height)
       }
   }
}

func viewDidLayout(_ newSize: CGSize) {
    guard newSize != viewSize else { return }
    epubear.updateBitmapSize(newSize)
}


​​func contentUpdated(_ position: EPUBPagePosition) {
    switch position {
    case pagePositionLeft:
        if let leftImage = epubear.leftImage() {
            leftImageView.image = leftImage
        }
    case pagePositionCenter:
        if let centerImage = epubear.centerImage() {
            centerImageView.image = centerImage
        }
    case pagePositionRight:
        if let rightImage = epubear.rightImage() {
            rightImageView.image = rightImage
        }
    default:
        break
    }
}

ImageSource _leftImageSource;
public ImageSource LeftImageSource
{
    get { return _leftImageSource; }
    set
    {
        _leftImageSource = value;
        RaisePropertyChanged(nameof(LeftImageSource));
    }
}

class _MyReaderState extends State<MyReader> with EventsListener {
  @override
  Widget build(BuildContext context) {
    epubear.eventsListener = this;
    return Expanded(
      child: LayoutBuilder(builder: (context, constraints) {
       final size = Size(constraints.maxWidth, constraints.maxHeight);
       return FutureBuilder(
         future: Future(() async {
           if (!documentLoaded) {
             // open epub file here
           }
           if (needsTextures) {
             int width = size.width.toInt();
             int height = size.height.toInt();
             epubear.updateViewSize(width, height, false);
             needsTextures = false;
           }
         }),
         builder: (context, snapshot) {
           if (needsTextures) {
             return Container();
           } else {
             return Texture(
               textureId: epubear.textureId,
               filterQuality: FilterQuality.none,
             );
           }
         },
       );
     }),
    );
  }

Out of box on all platforms.

Out of box on all platforms.

Out of box on all platforms.

Out of box on all platforms.

epubear.openNextPage()
epubear.openPreviousPage()
epubear.openPage(pageNumber)

epubear.openNextPage()
epubear.openPreviousPage()
epubear.openPage(UInt(pageNumber))

epubear.OpenNextPage();
epubear.OpenPreviousPage();
epubear.OpenPage(pageNumber);

epubear.nextPage();
epubear.previousPage();
epubear.setPage(pageNumber);

epubear.increaseFont()
epubear.decreaseFont()
// size - is a difference from epub file original font sizes
epubear.setFontSize(size, doRefreshPage)
epubear.setCustomLineSpacing(1.5f, doRefreshPage)

epubear.increaseFont()
epubear.decreaseFont()
// size - is a difference from epub file original font sizes
epubear.setFontSize(Int32(fontSize), withInvalidate: doRefreshPage)
epubear.setCustomLineSpacing(1.5, withInvalidate: doRefreshPage)

epubear.IncreaseFont();
epubear.DecreaseFont();
// size - is a difference from epub file original font sizes
epubear.SetFontSize(fontSize);
epubear.SetCustomLineSpacing(1.5f, doRefreshPage);

epubear.increaseFont(step);
epubear.decreaseFont(step);
// size - is a difference from epub file original font sizes
epubear.setCurrentFontSize(size, doRefreshPage);
epubear.setCustomLineSpacing(1.5, reload: doRefreshPage);

epubear.setBookmarkListener(this)
val bookmark = epubear.createBookmark()
val bookmark = epubear.createBookmark(chapterIndex, pageNumber)
epubear.openBookmark(bookmark)
val (chapterIndex, pageNumber) = epubear.getBookmarkChapterPage(bookmark)
val list = epubear.getBookmarks()
val deleted = epubear.deleteBookmark(bookmark)

let bookmark = epubear.createBookmark() ?? ""
let bookmark = epubear.createBookmark(chapterIndex, pageNumber)
epubear.openBookmark(bookmark)
let chapterAndPage = epubear.getBookmarkChapterPage(bookmark)
let list = epubear.getBookmarks()
let deleted = epubear.deleteBookmark(bookmark)

var bookmark = epubear.CreateBookmark();
var bookmark = epubear.CreateBookmark(chapterIndex, pageNumber);
epubear.OpenBookmark(bookmark);
var (chapter, page) = epubear.GetBookmarkChapterPage(bookmark);
var list = epubear.GetBookmarks();
epubear.DeleteBookmark(bookmark);

epubear.bookmarkListener = this;
final bookmark = epubear.createBookmark();
epubear.openBookmark(bookmark);
epubear.deleteBookmark(bookmark);

epubear.setSearchListener(this)
epubear.searchTextInChapter(text)
epubear.searchTextInAllChapters(text)
epubear.cancelSearch()

epubear.searchText(inChapter: text)
epubear.searchText(text)
epubear.stopSearchInBook()

epubear.SearchTextInChapter(text);
epubear.SearchText(text);
epubear.CancelSearch();

epubear.searchListener = this;
epubear.searchCurrentChapter(text);
epubear.searchAllChapters(text);
epubear.searchCancel();

epubear.setCfiListener(this)
val symbolRects = epubear.getCurrentPageSymbols(isFullTextFromPage = false)
val cfi = epubear.createCfiSelectedText(firstRect, lastRect)
val highlightBoxes = epubear.getCfiHighlightBoxes(cfi)
epubear.cfiesHighlighting(highlightBoxes)
epubear.removeCfi(arrayOf(cfi))

guard let symbolRects = epubear.getCurrentPageSymbols() else { return }
guard let cfi = epubear.selectedText(from: symbolRects) else { return }
let highlightBoxes = epubear.getCFIBoxes([cfi])
epubear.removeCFIList([cfi])
epubear.removeAllCFIs()

var symbolRects = epubear.GetPageSymbols(true);
var cfi = epubear.CreateCfiSelectedText(symbolRects.First(), symbolRects.Last());
epubear.RemoveCfi([cfi]);
epubear.RemoveAllReceivedCfi();

epubear.cfiListener = this;
final symbolRects = epubear.getTextSymbols();
final borders = [
  selectionRect.left.toInt(),
  selectionRect.top.toInt(),
  selectionRect.right.toInt(),
  selectionRect.bottom.toInt(),
];
final cfi = epubear.createCfiSelectedText(borders);
final highlightBoxes = epubear.getCfiHighlightRects(cfi);
epubear.removeCfi([cfi]);
epubear.removeAllReceivedCfi();

Coming soon

Coming soon

Coming soon

Coming soon

val textToSpeech = TextToSpeech(context, this)
textToSpeech.setOnUtteranceProgressListener(this)
val speech = epubear.getCurrentPageText(isFullTextFromPage = true)
textToSpeech.speak(speech, TextToSpeech.QUEUE_FLUSH, null, "")

let synthesizer = AVSpeechSynthesizer()
synthesizer.delegate = self
guard let voice = AVSpeechSynthesisVoice(language: "en") else { return }
guard let speech = epubear.getCurrentPageText() else { return }
let utterance = AVSpeechUtterance(string: speech)
utterance.rate = AVSpeechUtteranceDefaultSpeechRate
utterance.voice = voice
synthesizer.speak(utterance)

var speech = epubear.GetPageText(EPUBBitmapPosition.Center, withControlChars: true);
await TextToSpeech.Default.SpeakAsync(speech);

final tts = FlutterTts();
final speech = epubear.getText(chapterIndex);
await tts.speak(speech);

init {
   // other init code
   epubear.setMediaListener(this)
}

override fun onVideoFound(videoMap: Map<Int, Array<VideoContent>>) {
   // Play video with standard system media player
}
override fun onAudioFound(audioMap: Map<Int, Array<AudioContent>>) {
   // Play audio with standard system media player
}

func videoContentFound(_ legacyContent: [NSNumber: [EPUBear.VideoContent]]) {
    // Play video with standard system media player
}

func audioContentFound(_ legacyContent: [NSNumber: [EPUBear.AudioContent]]) {
    // Play audio with standard system media player
}

func videoSize(atURL fileUrl: String) -> CGSize {
    let url = URL(fileURLWithPath: url)
    let asset = AVAsset(url: url)
    guard let video = asset.tracks(withMediaType: .video).first else {
        return .zero
    }
    return video.naturalSize
}

epubear.MediaCallbacks.AudioContentFound = OnAudioFound;
epubear.MediaCallbacks.VideoContentFound = OnVideoFound;

void OnAudioFound(Dictionary<int, List<AudioContent>> audioDictionary)
{
    // Play audio with any media player
}

public void OnVideoFound(Dictionary<int, List<VideoContent>> videoDictionary)
{
    // Play video with any media player
}

epubear.mediaListener = this;

@override
void onAudioFound(Map<int, List<AudioContent>> audioMap) {
  // Play audio with any media player
}

@override
void onVideoFound(Map<int, List<VideoContent>> videoMap) {
  // Play video with any media player
}

init {
   // other init code
   epubear.setImageListener(this)
}

override fun onImageClicked(image: Bitmap, isBackground: Boolean) {
   // Process image any way required
}

func imageClicked(_ image: UIImage) {
    // Process image any way required
}

epubear.Callbacks.ImageClick = OnImageClick;

void OnImageClick(object bitmap, bool isBackground)
{
    // Process bitmap any way required
}

epubear.imageListener = this;

@override
void onImageClicked(Image image, bool isBackground) {
  // Process image any way required
}