A 7-step tour of how a small Code on the Go plugin is
+built end-to-end. Each step adds one capability and teaches one
+plugin-platform concept. The whole plugin is under 300 lines of
+Kotlin — small enough to read top-to-bottom in an evening.
+
+
+ What you'll build. An "XKCD" tab in CoGo's editor bottom
+ sheet. A 5-button row above the comic
+ (|< · Prev · Random · Next · >|) mirrors
+ xkcd.com's own navigation bar; the panel defaults to the latest
+ comic. Single-tap on the comic copies the URL; double-tap copies
+ the image. Long-press the tab for in-IDE help.
+
+
+
+ Prerequisites. Kotlin + Android fragments + Gradle + basic
+ `kotlinx.coroutines`. You don't need prior plugin experience —
+ every plugin-specific concept is called out where it shows up.
+
+
+
1. Plugin entry point
+
+
Why you care: every plugin starts with an
+IPlugin class. The host loads it via
+DexClassLoader, reflectively instantiates it from
+plugin.main_class, and drives the
+initialize → activate → deactivate → dispose lifecycle.
+Get this right and the rest is opt-in.
Plugin concept — wrap initialize
+in try/catch. A stray exception here crashes the host IDE on plugin
+load. Return false on failure; the host then skips
+activate() for this plugin and keeps the rest of the IDE
+alive.
+
+
Plugin concept — PluginContext
+is your handle to the host. It exposes a per-plugin
+logger, a services registry (look up
+IdeEditorTabService, IdeTooltipService, etc.),
+and resource access. Stash the reference in initialize and
+use it from every other method.
+
+
2. Manifest + permissions
+
+
Why you care: the manifest tells the host how
+to find your plugin and what host resources you're allowed to touch.
Plugin permissions are comma-separated values inside one
+<meta-data> entry — not the
+<uses-permission> system Android apps use. Available
+permissions:
+
+
+
Permission
What it gates
+
network.access
Required by the validator for any plugin that contacts the network. (Today the runtime gate is wired in, advisory for plugins — declare it anyway; it's forward-compatible.)
+
filesystem.read
Read access to the user's project via IdeFileService, IdeEditorService, etc.
+
filesystem.write
Write access to the user's project. Same gate as above.
+
system.commands
Runtime.exec, process spawning.
+
ide.settings
Read/write IDE preferences.
+
project.structure
Walk the user's open project.
+
native.code
Execute native machine code.
+
ide.environment.write
Write to IDE-managed dirs (SDK, NDK, cache).
+
+
+
Plugin concept — permissions gate the host's
+resources, not your own. Your context.filesDir and
+context.cacheDir belong to the host APK's Android
+sandbox and are yours to use freely. The system clipboard is
+reachable directly via ClipboardManager. So even though
+this plugin writes to filesDir (the copy-image
+clipboard hop in Step 6) and writes to the clipboard, the
+only permission it needs is network.access. Declare
+permissions to mean "I touch what the host mediates" — nothing
+else.
+
+
3. The bottom-sheet tab UI
+
+
Why you care: bottom-sheet tabs are the primary
+place small plugins live in CoGo. They appear alongside Build Output,
+App Logs, IDE Logs, etc. — visible without leaving the editor. You
+register one with UIExtension.getEditorTabs() and
+provide a Fragment factory.
+
+
class XkcdRandomPlugin : IPlugin, UIExtension {
+
+ override fun getEditorTabs(): List<TabItem> = listOf(
+ TabItem(
+ id = "xkcd_bottom_tab",
+ title = "XKCD",
+ fragmentFactory = { XkcdPanelFragment() },
+ order = 200,
+ tooltipTag = "xkcd.tab"
+ )
+ )
+}
+
+
tooltipTag connects this tab to the help entry from
+DocumentationExtension (Step 7). Omit it and the host
+falls back to "<pluginId>.<tabId>".
+
+
The Fragment needs one non-obvious override:
+
+
override fun onGetLayoutInflater(savedInstanceState: Bundle?): LayoutInflater {
+ val inflater = super.onGetLayoutInflater(savedInstanceState)
+ return PluginFragmentHelper.getPluginInflater(XkcdRandomPlugin.PLUGIN_ID, inflater)
+}
+
+
Plugin concept — plugin Fragments must wrap
+their LayoutInflater. Plugins load via
+DexClassLoader. The inflater the host hands you defaults
+to resolving R.layout.* against the host IDE's
+resources, not yours. Skip the wrap and you crash with
+Resources$NotFoundException the first time the Fragment
+shows. PluginFragmentHelper.getPluginInflater(pluginId, parent)
+wraps the inflater with a Resources instance backed by
+your plugin's APK.
+
+
Plugin concept —
+fragmentFactory returns a fresh instance every time.
+Never cache a singleton Fragment; the host calls the factory whenever
+the tab is shown, and Fragment lifecycle expectations require a clean
+instance each time.
+
+
4. UI interactions: navigation buttons + gestures
+
+
Why you care: the canonical surface for plugin
+actions is buttons in the layout — they're discoverable, accessible,
+and easy to test. Gestures on top of that are optional convenience.
+Android's GestureDetector.SimpleOnGestureListener handles
+single + double tap with two callbacks. Don't reach for a custom tap
+state machine if your model fits this pattern.
+
+
The XKCD plugin's button row mirrors the
+xkcd.com navigation bar — five
+buttons, left-to-right: |< · Prev · Random · Next · >|.
+Each is a normal Button wired with
+setOnClickListener; all five route through one
+loadComic(nav) helper that fetches + renders:
Plugin-friendly UX detail —
+default to Last. On first show the fragment calls
+loadComic(Navigation.Last) so the user lands on the
+newest comic, exactly like opening xkcd.com in a browser. Prev / Next
+are disabled until we know the current cursor + the high-water mark,
+so the buttons never lie about what they can do.
+
+
Edge case — comic #404. xkcd #404
+is a deliberate joke: its JSON endpoint returns HTTP 404. The
+fetch handler steps past it in the same direction the user requested
+(Prev to #403, Next to #405), so the user never sees a "failed to
+load" toast for a quirk of the source data.
+
+
Gesture shortcuts on the image itself are pure
+GestureDetector:
The detector is attached to the ImageView only —
+the rest of the panel scrolls normally. onSingleTapConfirmed
+fires after Android's double-tap window expires, so it doesn't
+preempt double-tap.
+
+
5. Network fetch over HTTPS
+
+
Why you care: most plugins talk to a network
+eventually. The XKCD client is the smallest realistic example:
+OkHttp + the org.json reader that ships with Android, no
+auth, two endpoints. It also shows the offline-failure contract —
+returning null rather than throwing keeps the caller's
+empty-state branch reachable on a flaky network.
+
+
class XkcdApiClient(private val client: OkHttpClient = defaultClient()) {
+
+ fun fetchRandom(): XkcdComic? {
+ val latest = fetchLatest() ?: return null
+ while (true) {
+ val pick = Random.nextInt(1, latest.num + 1)
+ if (pick == 404) continue
+ fetchByNumber(pick)?.let { return it }
+ // null = transient blip; just pick again
+ }
+ }
+
+ fun fetchLatest(): XkcdComic? = getJson(LATEST_URL)?.let(::parseComic)
+ fun fetchByNumber(num: Int): XkcdComic? = getJson(numUrl(num))?.let(::parseComic)
+}
+
+
Why the loop is unbounded: xkcd #404
+is a joke comic that returns HTTP 404 on its JSON endpoint. A
+bounded retry can still land on the same dud. Looping until success
+is simpler and converges in 1-2 picks on a healthy network. The only
+way fetchRandom returns null is if the
+initial probe fails — i.e. the network is down.
+
+
The Fragment wires this into a coroutine + bitmap decode on
+Dispatchers.IO so the UI stays responsive:
+
+
private fun loadRandomComic() {
+ if (loadJob?.isActive == true) return
+ if (currentComic == null) showLoading()
+ loadJob = viewLifecycleOwner.lifecycleScope.launch {
+ val result = withContext(Dispatchers.IO) { fetchAndDecode() }
+ // … render or show empty state
+ }
+}
+
+
For production use on low-end devices, prefer
+Android's bounded
+bitmap decoding pattern. This plugin keeps it simple:
+BitmapFactory.decodeByteArray(...) with a 5 MB
+network-read cap.
+
+
6. Clipboard support
+
+
Why you care: moving things to the clipboard is
+how plugins integrate with the rest of the user's workflow. Text
+clipboard is trivial; image clipboard takes one detour through the
+host's FileProvider because of how Android's content URIs
+work in the plugin sandbox.
+
+
6a. Text — the easy path
+
+
private fun copyUrlToClipboard() {
+ val comic = currentComic ?: return
+ val cm = requireContext().getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
+ cm.setPrimaryClip(ClipData.newPlainText("xkcd-url", comic.pageUrl))
+ toast(getString(R.string.toast_url_copied, comic.pageUrl))
+}
+
+
No permission needed. Android doesn't
+have a <uses-permission> for clipboard access either
+— clipboard write is implicitly allowed for foreground apps (which
+your plugin always is, because its tab is in the foreground IDE).
+Android 12+ adds a system toast on clipboard reads, but
+writes pass freely.
+
+
6b. Image — the FileProvider hop
+
+
private fun copyImageToClipboard() {
+ val bytes = lastBytes ?: run { toast(/* failed */); return }
+ val ctx = requireContext()
+ viewLifecycleOwner.lifecycleScope.launch {
+ val target = withContext(Dispatchers.IO) {
+ val shareDir = File(ctx.filesDir, "xkcd_share").apply { mkdirs() }
+ val out = File(shareDir, "last.png")
+ try { out.writeBytes(bytes); out } catch (_: Exception) { null }
+ } ?: run { toast(/* failed */); return@launch }
+
+ val authority = "${ctx.packageName}.providers.fileprovider"
+ val uri = FileProvider.getUriForFile(ctx, authority, target)
+ val clip = ClipData.newUri(ctx.contentResolver, "xkcd-image", uri)
+ (ctx.getSystemService(CLIPBOARD_SERVICE) as ClipboardManager).setPrimaryClip(clip)
+ toast(/* image copied */)
+ }
+}
+
+
Plugin concept — <provider>
+declarations in a plugin manifest are dead code. Plugins are
+loaded via DexClassLoader, not installed as Android
+apps. Android's PackageManager never sees the plugin's
+manifest, so it never registers your <activity>,
+<service>, or <provider>.
+Anything that requires OS-side registration must go through the host.
+
+
The escape valve: route through the host IDE's
+FileProvider authority. The host ships its own
+FileProvider with authority
+${packageName}.providers.fileprovider and a
+file_provider_paths.xml that exposes
+filesDir. Any file we drop under
+ctx.filesDir/... can be served from that authority.
+
+
ctx.packageName is the host's package name (because
+ctx is the host's Context), so this composes
+to the right authority without hard-coding it. And because
+filesDir is your plugin's own sandbox storage, writing
+to it doesn't need filesystem.write.
+
+
ClipData.newUri queries the ContentResolver
+for the URI's MIME type. The host's FileProvider resolves
+.png to image/png, so the clip advertises
+image/* to paste targets. Paste into Messages, Gmail, any
+image-aware app — it pastes the image, not the URL.
+
+
7. Three-tier tooltip for plugin help
+
+
Why you care: CoGo has a per-plugin help API.
+A user long-presses your plugin's tab and gets in-IDE help that you
+provide. Three tiers, progressively-detailed: a one-liner, then an
+HTML detail panel, then a full HTML walkthrough page (this page).
+Implementing DocumentationExtension is how a plugin
+provides help users can discover without leaving the IDE.
+
+
class XkcdRandomPlugin : IPlugin, UIExtension, DocumentationExtension {
+
+ override fun getTooltipCategory(): String = "plugin_xkcd"
+
+ override fun getTooltipEntries(): List<PluginTooltipEntry> = listOf(
+ PluginTooltipEntry(
+ tag = "xkcd.tab",
+ summary = "Browse xkcd. Buttons navigate · tap = copy URL · double-tap = copy image.",
+ detail = """
+ <p>Defaults to the latest comic. Navigate with
+ <b>|< · Prev · Random · Next · >|</b>.</p>
+ <ul>
+ <li><b>Tap image</b> — copy URL.</li>
+ <li><b>Double-tap image</b> — copy image.</li>
+ </ul>
+ """.trimIndent(),
+ buttons = listOf(
+ PluginTooltipButton(
+ description = "Code walkthrough",
+ uri = "index.html",
+ order = 0
+ )
+ )
+ )
+ )
+
+ override fun getTier3DocsAssetPath(): String? = "docs"
+}
+
+
+
Tier
Field
What the user sees
+
1
summary
Short string shown when long-pressing your tab.
+
2
detail
HTML rendered inside the tooltip after tapping "See More".
+
3
buttons[].uri
A button labeled description. Tapping it opens an HTML page (this one) served at http://localhost:6174/plugin/<pluginId>/<uri>.
+
+
+
tag here is the same string you put on
+TabItem.tooltipTag (Step 3) — that's the wire that
+connects the long-press on the tab to this entry.
+
+
getTier3DocsAssetPath() = "docs" says: "my Tier 3
+walkthrough lives under src/main/assets/docs/." At
+install time the host's Tier3AssetWalker indexes
+everything under that directory and serves each file at the URL
+above. Files reference each other with relative paths — so this
+page's <link rel="stylesheet" href="css/walkthrough.css">
+just works.
+
+
To preview the Tier 3 page outside the
+IDE: just open random-xkcd/src/main/assets/docs/index.html
+in any browser. It renders identically; the localhost:6174 URL is
+only used when the host serves it inside CoGo.
+
+
The sandbox model in one screen
+
+
Three rules to remember:
+
+
Manifest <provider>, <activity>,
+ <service>, <receiver> are dead code —
+ route via host extensions or its FileProvider.
+
R.* resolves against whichever Resources
+ your code is using — wrap the inflater.
+
Permissions gate the host's resources only — your
+ filesDir, cacheDir, and the clipboard
+ need no declaration.
Plugin Development Guide (wiki) — the full API
+ reference for every extension interface and host service.
+
Sibling demo plugins — forms-plugin and
+ maps-plugin show plugins with more complex UI and
+ persistent state.
+
This plugin's source — under 250 lines of Kotlin.
+ Read it top-to-bottom: XkcdRandomPlugin.kt →
+ XkcdPanelFragment.kt → XkcdApiClient.kt.
+
+
+
+
diff --git a/random-xkcd/src/main/assets/icon_day.png b/random-xkcd/src/main/assets/icon_day.png
new file mode 100644
index 0000000..0e432bb
Binary files /dev/null and b/random-xkcd/src/main/assets/icon_day.png differ
diff --git a/random-xkcd/src/main/assets/icon_night.png b/random-xkcd/src/main/assets/icon_night.png
new file mode 100644
index 0000000..1e38d87
Binary files /dev/null and b/random-xkcd/src/main/assets/icon_night.png differ
diff --git a/random-xkcd/src/main/kotlin/org/appdevforall/randomxkcd/XkcdRandomPlugin.kt b/random-xkcd/src/main/kotlin/org/appdevforall/randomxkcd/XkcdRandomPlugin.kt
new file mode 100644
index 0000000..9ad32fb
--- /dev/null
+++ b/random-xkcd/src/main/kotlin/org/appdevforall/randomxkcd/XkcdRandomPlugin.kt
@@ -0,0 +1,140 @@
+package org.appdevforall.randomxkcd
+
+import org.appdevforall.randomxkcd.fragments.XkcdPanelFragment
+import com.itsaky.androidide.plugins.IPlugin
+import com.itsaky.androidide.plugins.PluginContext
+import com.itsaky.androidide.plugins.extensions.DocumentationExtension
+import com.itsaky.androidide.plugins.extensions.PluginTooltipButton
+import com.itsaky.androidide.plugins.extensions.PluginTooltipEntry
+import com.itsaky.androidide.plugins.extensions.TabItem
+import com.itsaky.androidide.plugins.extensions.UIExtension
+
+/**
+ * Random-xkcd demo plugin. Three goals:
+ * 1. Show a random xkcd comic in the bottom-sheet "XKCD" tab.
+ * 2. Demonstrate the canonical UI surface — buttons above the comic
+ * plus Android's standard single/double-tap gestures on the image.
+ * 3. Be a small, readable "how to write a CoGo plugin" example.
+ *
+ * Reading order:
+ * - this file: lifecycle + tab registration + tooltip / docs wiring
+ * - [XkcdPanelFragment]: the bottom-sheet UI + button wiring + gestures
+ * - [org.appdevforall.randomxkcd.net.XkcdApiClient]: HTTP, single file
+ */
+class XkcdRandomPlugin : IPlugin, UIExtension, DocumentationExtension {
+
+ private lateinit var context: PluginContext
+
+ companion object {
+ const val PLUGIN_ID = "org.appdevforall.randomxkcd"
+ const val TAB_ID = "xkcd_bottom_tab"
+ const val TOOLTIP_TAG_TAB = "xkcd.tab"
+ }
+
+ override fun initialize(context: PluginContext): Boolean {
+ // initialize() returns Boolean — the IDE skips activate() if this
+ // returns false. Wrap in try/catch so a stray exception in our
+ // setup can't crash the host IDE.
+ return try {
+ this.context = context
+ context.logger.info("XkcdRandomPlugin initialized")
+ true
+ } catch (t: Throwable) {
+ context.logger.error("XkcdRandomPlugin initialization failed", t)
+ false
+ }
+ }
+
+ override fun activate(): Boolean {
+ context.logger.info("XkcdRandomPlugin activated")
+ return true
+ }
+
+ override fun deactivate(): Boolean {
+ context.logger.info("XkcdRandomPlugin deactivated")
+ return true
+ }
+
+ override fun dispose() {
+ context.logger.info("XkcdRandomPlugin disposed")
+ }
+
+ // --- UIExtension: register the bottom-sheet tab ---
+
+ /**
+ * Register one bottom-sheet tab. The IDE shows it next to the eight
+ * built-in tabs (Build Output, App Logs, …) plus tabs from other
+ * plugins. `order` controls our position among plugin tabs only.
+ *
+ * The fragmentFactory returns a *new* fragment each time the tab is
+ * shown — never reuse a single Fragment instance, fragments have
+ * lifecycle expectations the IDE manages.
+ */
+ override fun getEditorTabs(): List = listOf(
+ TabItem(
+ id = TAB_ID,
+ title = "XKCD",
+ fragmentFactory = { XkcdPanelFragment() },
+ order = 200,
+ tooltipTag = TOOLTIP_TAG_TAB
+ )
+ )
+
+ // --- DocumentationExtension: three-tier tooltip on the tab ---
+ //
+ // CoGo's per-plugin help API. Long-pressing the bottom-sheet tab
+ // shows Tier 1; the tooltip's "See More" button reveals Tier 2;
+ // a button inside Tier 2 opens Tier 3 as a full HTML page.
+ //
+ // Tier 1 = `summary` (one-liner)
+ // Tier 2 = `detail` (HTML paragraph)
+ // Tier 3 = `buttons[].uri` (HTML page the IDE serves at
+ // http://localhost:6174/plugin//)
+ //
+ // The Tier 3 source lives under src/main/assets/docs/ and is
+ // indexed at install time by the host's Tier3AssetWalker.
+
+ override fun getTooltipCategory(): String = "plugin_xkcd"
+
+ override fun getTooltipEntries(): List = listOf(
+ PluginTooltipEntry(
+ tag = TOOLTIP_TAG_TAB,
+ summary = "Browse xkcd. Buttons navigate · tap = copy URL · double-tap = copy image.",
+ detail = """
+
This panel browses xkcd.com. Defaults to the
+ latest comic.
+
Navigation row above the comic (left to right):
+
+
|< — first comic.
+
Prev — previous comic.
+
Random — a random comic.
+
Next — next comic.
+
>| — latest comic.
+
+
Gesture shortcuts on the image:
+
+
Tap — copy the comic's URL.
+
Double-tap — copy the comic image.
+
+
Fetches use HTTPS only.
+ """.trimIndent(),
+ buttons = listOf(
+ PluginTooltipButton(
+ description = "Code walkthrough",
+ uri = "index.html", // resolves to plugin//index.html
+ order = 0
+ )
+ )
+ )
+ )
+
+ /**
+ * Subdirectory under src/main/assets/ that holds the Tier 3 walkthrough.
+ * Every file under assets/docs/ is indexed by Tier3AssetWalker at
+ * install time and served from
+ * http://localhost:6174/plugin/org.appdevforall.randomxkcd/
+ *
+ * Files reference each other with relative paths (e.g. css/walkthrough.css).
+ */
+ override fun getTier3DocsAssetPath(): String? = "docs"
+}
diff --git a/random-xkcd/src/main/kotlin/org/appdevforall/randomxkcd/fragments/XkcdPanelFragment.kt b/random-xkcd/src/main/kotlin/org/appdevforall/randomxkcd/fragments/XkcdPanelFragment.kt
new file mode 100644
index 0000000..ea34ac3
--- /dev/null
+++ b/random-xkcd/src/main/kotlin/org/appdevforall/randomxkcd/fragments/XkcdPanelFragment.kt
@@ -0,0 +1,444 @@
+package org.appdevforall.randomxkcd.fragments
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.graphics.BitmapFactory
+import android.os.Build
+import android.os.Bundle
+import android.view.GestureDetector
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.ProgressBar
+import android.widget.TextView
+import android.widget.Toast
+import androidx.core.content.FileProvider
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.lifecycleScope
+import org.appdevforall.randomxkcd.R
+import org.appdevforall.randomxkcd.XkcdRandomPlugin
+import org.appdevforall.randomxkcd.net.XkcdApiClient
+import org.appdevforall.randomxkcd.net.XkcdComic
+import com.itsaky.androidide.plugins.base.PluginFragmentHelper
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.coroutineContext
+import java.io.ByteArrayOutputStream
+import java.io.File
+
+/**
+ * The "XKCD" tab body.
+ *
+ * Reading order:
+ * - onCreateView / onViewCreated: standard fragment setup, with the
+ * PluginFragmentHelper-wrapped inflater that lets us resolve our
+ * own R.layout.* against the plugin's APK.
+ * - the button-row wiring + image gesture detector: xkcd.com-style
+ * 5-button navigation (|< · < Prev · Random · Next > · >|) above
+ * the comic, plus single/double-tap shortcuts on the image itself.
+ * - the navigation handlers (goFirst / goPrev / goRandom / goNext /
+ * goLast) all go through [loadComic], which dispatches the right
+ * fetch and re-renders.
+ *
+ * Navigation state:
+ * - [currentComicNum] — the number we're displaying right now.
+ * - [latestComicNum] — the high-water mark from xkcd's latest-comic
+ * probe. Used to disable Next at the upper edge and to validate
+ * range; refreshed on every Last-button tap.
+ *
+ * Edge handling:
+ * - Comic #404 is xkcd's joke comic: its JSON endpoint returns HTTP
+ * 404 deliberately. When a Prev / Next step would land on #404,
+ * the fetch handler keeps stepping in the same direction (Prev
+ * → 403; Next → 405) so the user never sees a "failed to load"
+ * toast for a quirk of the source data.
+ */
+class XkcdPanelFragment : Fragment() {
+
+ private val api = XkcdApiClient()
+
+ // Bound view references — populated in onViewCreated, cleared in
+ // onDestroyView so we don't leak views across configuration changes.
+ private var imageCard: FrameLayout? = null
+ private var imageView: ImageView? = null
+ private var captionView: TextView? = null
+ private var altView: TextView? = null
+ private var progressView: ProgressBar? = null
+ private var emptyView: TextView? = null
+ private var btnFirst: Button? = null
+ private var btnPrev: Button? = null
+ private var btnNext: Button? = null
+ private var btnLast: Button? = null
+
+ /** The comic we're currently displaying — used by the clipboard handlers. */
+ private var currentComic: XkcdComic? = null
+
+ /** Number of the comic currently displayed. Drives Prev/Next disable logic. */
+ private var currentComicNum: Int? = null
+
+ /**
+ * High-water mark — the latest comic number known to exist on
+ * xkcd.com. Set on the first successful Latest fetch (or after Last).
+ * Used to disable Next at the upper edge and to bound Random.
+ */
+ private var latestComicNum: Int? = null
+
+ /**
+ * Raw PNG bytes of the currently-displayed comic. Kept in memory so a
+ * "copy image" tap can hit the clipboard without re-downloading or
+ * re-encoding the rendered Bitmap.
+ */
+ private var lastBytes: ByteArray? = null
+
+ /** In-flight fetch, so rapid button presses don't fan out into N parallel fetches. */
+ private var loadJob: Job? = null
+
+ override fun onGetLayoutInflater(savedInstanceState: Bundle?): LayoutInflater {
+ // Plugins must wrap the inflater so R.layout.* resolves against
+ // the plugin's APK resources, not the host IDE's. Without this
+ // you get a Resources$NotFoundException at inflate time.
+ val inflater = super.onGetLayoutInflater(savedInstanceState)
+ return PluginFragmentHelper.getPluginInflater(XkcdRandomPlugin.PLUGIN_ID, inflater)
+ }
+
+ override fun onCreateView(
+ inflater: LayoutInflater,
+ container: ViewGroup?,
+ savedInstanceState: Bundle?
+ ): View? = inflater.inflate(R.layout.fragment_xkcd_panel, container, false)
+
+ override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+ super.onViewCreated(view, savedInstanceState)
+
+ imageCard = view.findViewById(R.id.xkcd_image_card)
+ imageView = view.findViewById(R.id.xkcd_image)
+ captionView = view.findViewById(R.id.xkcd_caption)
+ altView = view.findViewById(R.id.xkcd_alt)
+ progressView = view.findViewById(R.id.xkcd_progress)
+ emptyView = view.findViewById(R.id.xkcd_empty)
+ btnFirst = view.findViewById(R.id.xkcd_btn_first)
+ btnPrev = view.findViewById(R.id.xkcd_btn_prev)
+ btnNext = view.findViewById(R.id.xkcd_btn_next)
+ btnLast = view.findViewById(R.id.xkcd_btn_last)
+ val btnRandom = view.findViewById