Mihon

Mihon is a full-featured reader for Android designed to discover and read manga, webtoons, comics, and more. It provides local reading capabilities, a highly configurable reader engine, and integration with various tracking services.

Key Features

• Local Content Reading: Read your downloaded content directly on your device.
• Configurable Reader: Multiple viewers, reading directions, and various display settings.
• Tracker Support: Integration with services like MangaBaka, MyAnimeList, AniList, Kitsu, MangaUpdates, Shikimori, Bangumi, and Hikka.
• Library Management: Organize content using categories and schedule automatic updates for new chapters.
• Backups: Create local backups or sync to your preferred cloud service for offline reading or data portability.
• Customization: Support for light and dark themes.

LibraryUpdateNotifier is a class used to handle various types of Android notifications related to library updates, such as progress tracking, error reporting, and new chapter alerts. It respects user privacy settings via securityPreferences.hideNotificationContent.

Key functionalities include:

• Progress Tracking: Showing a persistent notification with a progress bar while updating manga.
• Error Reporting: Notifying the user when updates fail and providing a link to an error log.
• New Chapter Alerts: Grouping notifications for new chapters and providing per-manga notifications with actions like 'Mark as read' or 'Download'.
• Warning Notifications: Warning users when a single source is being checked excessively (bulk updates).

val notifier = LibraryUpdateNotifier(context)

// Show progress
notifier.showProgressNotification(mangaList, current, total)

// Show errors
notifier.showUpdateErrorNotification(failedCount, errorLogUri)

// Show new chapter updates
notifier.showUpdateNotifications(updatesList)

The App class overrides getPackageName() to provide a spoofed package name to Chromium-based WebView requests. This is done by inspecting the current thread's stack trace to detect if the call originates from Chromium's internal package info logic. If a Chromium call is detected, WebViewUtil.spoofedPackageName(applicationContext) is returned instead of the actual application package name.

override fun getPackageName(): String {
    try {
        val stackTrace = Thread.currentThread().stackTrace
        val isChromiumCall = stackTrace.any { trace ->
            trace.className.lowercase() in setOf("org.chromium.base.buildinfo", "org.chromium.base.apkinfo") &&
                trace.methodName.lowercase() in setOf("getall", "getpackagename", "<init>")
        }

        if (isChromiumCall) return WebViewUtil.spoofedPackageName(applicationContext)
    } catch (_: Exception) {
    }

    return super.getPackageName()
}

The ChapterCache class provides a mechanism for caching both chapter metadata (page lists) and individual images to disk using an LRU (Least Recently Used) strategy. It uses a DiskLruCache stored in the application's cache directory under chapter_disk_cache.

Key Capabilities:

• Chapter Metadata: Stores and retrieves a list of Page objects for a given Chapter by serializing them to JSON.
• Image Caching: Stores image files derived from URLs and provides methods to check for existence or retrieve the local File object.
• Cache Maintenance: Provides a clear() method to wipe the cache contents.

Implementation Details:

• Storage Format: Files are stored using an MD5 hash of their keys (either the chapter's manga ID + URL or the image URL) with a .0 extension.
• Cache Size: The cache is limited to 100 MB (100L * 1024 * 1024 bytes).

val cache = ChapterCache(context, json)

// Caching chapter pages
val pages: List<Page> = cache.getPageListFromCache(chapter)
cache.putPageListToCache(chapter, pages)

// Caching an image from a network response
cache.putImageToCache(imageUrl, response)

// Checking image status
if (cache.isImageInCache(imageUrl)) {
    val file = cache.getImageFile(imageUrl)
}

The DownloadCache class provides a high-performance way to query the state of downloaded content (manga, chapters, and sources) without performing expensive filesystem operations every time. It maintains an in-memory representation of the downloads directory and periodically synchronizes with the disk.

Key Features

• Fast Queries: Check if a chapter is downloaded using isChapterDownloaded.
• Download Statistics: Retrieve total download counts or counts for a specific Manga using getTotalDownloadCount and getDownloadCount.
• Reactive Updates: Observe changes to the download state via the changes Flow.
• Cache Invalidation: The cache is automatically invalidated and renewed every hour or when StorageManager signals changes.

Observing Changes

You can collect from the changes Flow to react whenever the cache is updated (e.g., after adding or removing chapters/manga).

downloadCache.changes.collect { 
    // The cache has changed, refresh your UI
}