chore: Move API project from separate repo to this

Set up CI to publish the API library package as well as release the app.

api/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

api/src/main/aidl/app/revanced/manager/plugin/downloader/webview/IWebView.aidl

@@ -0,0 +1,8 @@
+// IWebView.aidl
+package app.revanced.manager.plugin.downloader.webview;
+
+@JavaPassthrough(annotation="@app.revanced.manager.plugin.downloader.PluginHostApi")
+oneway interface IWebView {
+    void load(String url);
+    void finish();
+}

api/src/main/aidl/app/revanced/manager/plugin/downloader/webview/IWebViewEvents.aidl

@@ -0,0 +1,11 @@
+// IWebViewEvents.aidl
+package app.revanced.manager.plugin.downloader.webview;
+
+import app.revanced.manager.plugin.downloader.webview.IWebView;
+
+@JavaPassthrough(annotation="@app.revanced.manager.plugin.downloader.PluginHostApi")
+oneway interface IWebViewEvents {
+    void ready(IWebView iface);
+    void pageLoad(String url);
+    void download(String url, String mimetype, String userAgent);
+}

api/src/main/kotlin/app/revanced/manager/plugin/downloader/Constants.kt

@@ -0,0 +1,7 @@
+package app.revanced.manager.plugin.downloader
+
+/**
+ * The permission ID of the special plugin host permission. Only ReVanced Manager will have this permission.
+ * Plugin UI activities and internal services can be protected using this permission.
+ */
+const val PLUGIN_HOST_PERMISSION = "app.revanced.manager.permission.PLUGIN_HOST"

api/src/main/kotlin/app/revanced/manager/plugin/downloader/Downloader.kt

@@ -0,0 +1,165 @@
+package app.revanced.manager.plugin.downloader
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import android.app.Activity
+import android.os.Parcelable
+import kotlinx.coroutines.withTimeout
+import java.io.InputStream
+import java.io.OutputStream
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+@RequiresOptIn(
+    level = RequiresOptIn.Level.ERROR,
+    message = "This API is only intended for plugin hosts, don't use it in a plugin.",
+)
+@Retention(AnnotationRetention.BINARY)
+annotation class PluginHostApi
+
+/**
+ * The base interface for all DSL scopes.
+ */
+interface Scope {
+    /**
+     * The package name of ReVanced Manager.
+     */
+    val hostPackageName: String
+
+    /**
+     * The package name of the plugin.
+     */
+    val pluginPackageName: String
+}
+
+/**
+ * The scope of [DownloaderScope.get].
+ */
+interface GetScope : Scope {
+    /**
+     * Ask the user to perform some required interaction in the activity specified by the provided [Intent].
+     * This function returns normally with the resulting [Intent] when the activity finishes with code [Activity.RESULT_OK].
+     *
+     * @throws UserInteractionException.RequestDenied User decided to skip this plugin.
+     * @throws UserInteractionException.Activity.Cancelled The activity was cancelled.
+     * @throws UserInteractionException.Activity.NotCompleted The activity finished with an unknown result code.
+     */
+    suspend fun requestStartActivity(intent: Intent): Intent?
+}
+
+interface BaseDownloadScope : Scope
+
+/**
+ * The scope for [DownloaderScope.download].
+ */
+interface InputDownloadScope : BaseDownloadScope
+
+typealias Size = Long
+typealias DownloadResult = Pair<InputStream, Size?>
+
+typealias Version = String
+typealias GetResult<T> = Pair<T, Version?>
+
+class DownloaderScope<T : Parcelable> internal constructor(
+    private val scopeImpl: Scope,
+    internal val context: Context
+) : Scope by scopeImpl {
+    // Returning an InputStream is the primary way for plugins to implement the download function, but we also want to offer an OutputStream API since using InputStream might not be convenient in all cases.
+    // It is much easier to implement the main InputStream API on top of OutputStreams compared to doing it the other way around, which is why we are using OutputStream here. This detail is not visible to plugins.
+    internal var download: (suspend OutputDownloadScope.(T, OutputStream) -> Unit)? = null
+    internal var get: (suspend GetScope.(String, String?) -> GetResult<T>?)? = null
+    private val inputDownloadScopeImpl = object : InputDownloadScope, Scope by scopeImpl {}
+
+    /**
+     * Define the download block of the plugin.
+     */
+    fun download(block: suspend InputDownloadScope.(data: T) -> DownloadResult) {
+        download = { app, outputStream ->
+            val (inputStream, size) = inputDownloadScopeImpl.block(app)
+
+            inputStream.use {
+                if (size != null) reportSize(size)
+                it.copyTo(outputStream)
+            }
+        }
+    }
+
+    /**
+     * Define the get block of the plugin.
+     * The block should return null if the app cannot be found. The version in the result must match the version argument unless it is null.
+     */
+    fun get(block: suspend GetScope.(packageName: String, version: String?) -> GetResult<T>?) {
+        get = block
+    }
+
+    /**
+     * Utilize the service specified by the provided [Intent]. The service will be unbound when the scope ends.
+     */
+    suspend fun <R : Any?> useService(intent: Intent, block: suspend (IBinder) -> R): R {
+        var onBind: ((IBinder) -> Unit)? = null
+        val serviceConn = object : ServiceConnection {
+            override fun onServiceConnected(name: ComponentName?, service: IBinder?) =
+                onBind!!(service!!)
+
+            override fun onServiceDisconnected(name: ComponentName?) {}
+        }
+
+        return try {
+            val binder = withTimeout(10000L) {
+                suspendCoroutine { continuation ->
+                    onBind = continuation::resume
+                    context.bindService(intent, serviceConn, Context.BIND_AUTO_CREATE)
+                }
+            }
+            block(binder)
+        } finally {
+            onBind = null
+            context.unbindService(serviceConn)
+        }
+    }
+}
+
+class DownloaderBuilder<T : Parcelable> internal constructor(private val block: DownloaderScope<T>.() -> Unit) {
+    @PluginHostApi
+    fun build(scopeImpl: Scope, context: Context) =
+        with(DownloaderScope<T>(scopeImpl, context)) {
+            block()
+
+            Downloader(
+                download = download!!,
+                get = get!!
+            )
+        }
+}
+
+class Downloader<T : Parcelable> internal constructor(
+    @property:PluginHostApi val get: suspend GetScope.(packageName: String, version: String?) -> GetResult<T>?,
+    @property:PluginHostApi val download: suspend OutputDownloadScope.(data: T, outputStream: OutputStream) -> Unit
+)
+
+/**
+ * Define a downloader plugin.
+ */
+fun <T : Parcelable> Downloader(block: DownloaderScope<T>.() -> Unit) = DownloaderBuilder(block)
+
+/**
+ * @see GetScope.requestStartActivity
+ */
+sealed class UserInteractionException(message: String) : Exception(message) {
+    class RequestDenied @PluginHostApi constructor() :
+        UserInteractionException("Request denied by user")
+
+    sealed class Activity(message: String) : UserInteractionException(message) {
+        class Cancelled @PluginHostApi constructor() : Activity("Interaction cancelled")
+
+        /**
+         * @param resultCode The result code of the activity.
+         * @param intent The [Intent] of the activity.
+         */
+        class NotCompleted @PluginHostApi constructor(val resultCode: Int, val intent: Intent?) :
+            Activity("Unexpected activity result code: $resultCode")
+    }
+}

api/src/main/kotlin/app/revanced/manager/plugin/downloader/Extensions.kt

@@ -0,0 +1,42 @@
+package app.revanced.manager.plugin.downloader
+
+import android.app.Activity
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import android.os.Parcelable
+import java.io.OutputStream
+
+/**
+ * The scope of the [OutputStream] version of [DownloaderScope.download].
+ */
+interface OutputDownloadScope : BaseDownloadScope {
+    suspend fun reportSize(size: Long)
+}
+
+/**
+ * A replacement for [DownloaderScope.download] that uses [OutputStream].
+ * The provided [OutputStream] does not need to be closed manually.
+ */
+fun <T : Parcelable> DownloaderScope<T>.download(block: suspend OutputDownloadScope.(T, OutputStream) -> Unit) {
+    download = block
+}
+
+/**
+ * Performs [GetScope.requestStartActivity] with an [Intent] created using the type information of [ACTIVITY].
+ * @see [GetScope.requestStartActivity]
+ */
+suspend inline fun <reified ACTIVITY : Activity> GetScope.requestStartActivity() =
+    requestStartActivity(
+        Intent().apply { setClassName(pluginPackageName, ACTIVITY::class.qualifiedName!!) }
+    )
+
+/**
+ * Performs [DownloaderScope.useService] with an [Intent] created using the type information of [SERVICE].
+ * @see [DownloaderScope.useService]
+ */
+suspend inline fun <reified SERVICE : Service, R : Any?> DownloaderScope<*>.useService(
+    noinline block: suspend (IBinder) -> R
+) = useService(
+    Intent().apply { setClassName(pluginPackageName, SERVICE::class.qualifiedName!!) }, block
+)

api/src/main/kotlin/app/revanced/manager/plugin/downloader/Parcelables.kt

@@ -0,0 +1,39 @@
+package app.revanced.manager.plugin.downloader
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+import java.net.HttpURLConnection
+import java.net.URI
+
+/**
+ * A simple parcelable data class for storing a package name and version.
+ * This can be used as the data type for plugins that only need a name and version to implement their [DownloaderScope.download] function.
+ *
+ * @param name The package name.
+ * @param version The version.
+ */
+@Parcelize
+data class Package(val name: String, val version: String) : Parcelable
+
+/**
+ * A data class for storing a download URL.
+ *
+ * @param url The download URL.
+ * @param headers The headers to use for the request.
+ */
+@Parcelize
+data class DownloadUrl(val url: String, val headers: Map<String, String> = emptyMap()) : Parcelable {
+    /**
+     * Converts this into a [DownloadResult].
+     */
+    fun toDownloadResult(): DownloadResult = with(URI.create(url).toURL().openConnection() as HttpURLConnection) {
+        useCaches = false
+        allowUserInteraction = false
+        headers.forEach(::setRequestProperty)
+
+        connectTimeout = 10_000
+        connect()
+
+        inputStream to getHeaderField("Content-Length").toLong()
+    }
+}

api/src/main/kotlin/app/revanced/manager/plugin/downloader/webview/API.kt

@@ -0,0 +1,176 @@
+package app.revanced.manager.plugin.downloader.webview
+
+import android.content.Intent
+import app.revanced.manager.plugin.downloader.DownloadUrl
+import app.revanced.manager.plugin.downloader.DownloaderScope
+import app.revanced.manager.plugin.downloader.GetScope
+import app.revanced.manager.plugin.downloader.Scope
+import app.revanced.manager.plugin.downloader.Downloader
+import app.revanced.manager.plugin.downloader.PluginHostApi
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.supervisorScope
+import kotlinx.coroutines.withContext
+import kotlin.properties.Delegates
+
+typealias InitialUrl = String
+typealias PageLoadCallback<T> = suspend WebViewCallbackScope<T>.(url: String) -> Unit
+typealias DownloadCallback<T> = suspend WebViewCallbackScope<T>.(url: String, mimeType: String, userAgent: String) -> Unit
+
+interface WebViewCallbackScope<T> : Scope {
+    /**
+     * Finishes the activity and returns the [result].
+     */
+    suspend fun finish(result: T)
+
+    /**
+     * Tells the WebView to load the specified [url].
+     */
+    suspend fun load(url: String)
+}
+
+@OptIn(PluginHostApi::class)
+class WebViewScope<T> internal constructor(
+    coroutineScope: CoroutineScope,
+    private val scopeImpl: Scope,
+    setResult: (T) -> Unit
+) : Scope by scopeImpl {
+    private var onPageLoadCallback: PageLoadCallback<T> = {}
+    private var onDownloadCallback: DownloadCallback<T> = { _, _, _ -> }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val dispatcher = Dispatchers.Default.limitedParallelism(1)
+    private lateinit var webView: IWebView
+    internal lateinit var initialUrl: String
+
+    internal val binder = object : IWebViewEvents.Stub() {
+        override fun ready(iface: IWebView?) {
+            coroutineScope.launch(dispatcher) {
+                webView = iface!!.also {
+                    it.load(initialUrl)
+                }
+            }
+        }
+
+        override fun pageLoad(url: String?) {
+            coroutineScope.launch(dispatcher) { onPageLoadCallback(callbackScope, url!!) }
+        }
+
+        override fun download(url: String?, mimetype: String?, userAgent: String?) {
+            coroutineScope.launch(dispatcher) {
+                onDownloadCallback(
+                    callbackScope,
+                    url!!,
+                    mimetype!!,
+                    userAgent!!
+                )
+            }
+        }
+    }
+
+    private val callbackScope = object : WebViewCallbackScope<T>, Scope by scopeImpl {
+        override suspend fun finish(result: T) {
+            setResult(result)
+            // Tell the WebViewActivity to finish
+            webView.let { withContext(Dispatchers.IO) { it.finish() } }
+        }
+
+        override suspend fun load(url: String) {
+            webView.let { withContext(Dispatchers.IO) { it.load(url) } }
+        }
+
+    }
+
+    /**
+     * Called when the WebView attempts to download a file to disk.
+     */
+    fun download(block: DownloadCallback<T>) {
+        onDownloadCallback = block
+    }
+
+    /**
+     * Called when the WebView finishes loading a page.
+     */
+    fun pageLoad(block: PageLoadCallback<T>) {
+        onPageLoadCallback = block
+    }
+}
+
+@JvmInline
+private value class Container<U>(val value: U)
+
+/**
+ * Run a [android.webkit.WebView] Activity controlled by the provided code block.
+ * The activity will keep running until it is cancelled or an event handler calls [WebViewCallbackScope.finish].
+ * The [block] defines the event handlers and returns the initial URL.
+ *
+ * @param title The string displayed in the action bar.
+ * @param block The control block.
+ */
+@OptIn(PluginHostApi::class)
+suspend fun <T> GetScope.runWebView(
+    title: String,
+    block: suspend WebViewScope<T>.() -> InitialUrl
+) = supervisorScope {
+    var result by Delegates.notNull<Container<T>>()
+
+    val scope = WebViewScope<T>(this@supervisorScope, this@runWebView) { result = Container(it) }
+    scope.initialUrl = scope.block()
+
+    // Start the webview activity and wait until it finishes.
+    requestStartActivity(Intent().apply {
+        putExtra(
+            WebViewActivity.KEY,
+            WebViewActivity.Parameters(title, scope.binder)
+        )
+        setClassName(
+            hostPackageName,
+            WebViewActivity::class.qualifiedName!!
+        )
+    })
+
+    // Return the result and cancel any leftover coroutines.
+    coroutineContext.cancelChildren()
+    result.value
+}
+
+/**
+ * Implement a downloader using [runWebView] and [DownloadUrl]. This function will automatically define a handler for download events unlike [runWebView].
+ * Returning null inside the [block] is equivalent to returning null inside [DownloaderScope.get].
+ *
+ * @see runWebView
+ */
+fun WebViewDownloader(block: suspend WebViewScope<DownloadUrl>.(packageName: String, version: String?) -> InitialUrl?) =
+    Downloader<DownloadUrl> {
+        val label = context.applicationInfo.loadLabel(
+            context.packageManager
+        ).toString()
+
+        get { packageName, version ->
+            class ReturnNull : Exception()
+
+            try {
+                runWebView(label) {
+                    download { url, _, userAgent ->
+                        finish(
+                            DownloadUrl(
+                                url,
+                                mapOf("User-Agent" to userAgent)
+                            )
+                        )
+                    }
+
+                    block(this@runWebView, packageName, version) ?: throw ReturnNull()
+                } to version
+            } catch (_: ReturnNull) {
+                null
+            }
+        }
+
+        download {
+            it.toDownloadResult()
+        }
+    }

api/src/main/kotlin/app/revanced/manager/plugin/downloader/webview/WebViewActivity.kt

@@ -0,0 +1,161 @@
+package app.revanced.manager.plugin.downloader.webview
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.os.IBinder
+import android.os.Parcelable
+import android.view.MenuItem
+import android.webkit.CookieManager
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.activity.ComponentActivity
+import androidx.activity.addCallback
+import androidx.activity.enableEdgeToEdge
+import androidx.activity.viewModels
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.lifecycle.viewModelScope
+import app.revanced.manager.plugin.downloader.PluginHostApi
+import app.revanced.manager.plugin.downloader.R
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.launch
+import kotlinx.parcelize.Parcelize
+
+@OptIn(PluginHostApi::class)
+@PluginHostApi
+class WebViewActivity : ComponentActivity() {
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val vm by viewModels<WebViewModel>()
+        enableEdgeToEdge()
+        setContentView(R.layout.activity_webview)
+
+        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
+            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
+            insets
+        }
+        val webView = findViewById<WebView>(R.id.webview)
+        onBackPressedDispatcher.addCallback {
+            if (webView.canGoBack()) webView.goBack()
+            else cancelActivity()
+        }
+
+        val params = intent.getParcelableExtra<Parameters>(KEY)!!
+        actionBar?.apply {
+            title = params.title
+            setHomeAsUpIndicator(android.R.drawable.ic_menu_close_clear_cancel)
+            setDisplayHomeAsUpEnabled(true)
+        }
+
+        val events = IWebViewEvents.Stub.asInterface(params.events)!!
+        vm.setup(events)
+
+        webView.apply {
+            settings.apply {
+                cacheMode = WebSettings.LOAD_NO_CACHE
+                allowContentAccess = false
+                domStorageEnabled = true
+                javaScriptEnabled = true
+            }
+
+            webViewClient = vm.webViewClient
+            setDownloadListener { url, userAgent, _, mimetype, _ ->
+                vm.onDownload(url, mimetype, userAgent)
+            }
+        }
+
+        lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.STARTED) {
+                vm.commands.collect {
+                    when (it) {
+                        is WebViewModel.Command.Finish -> {
+                            setResult(RESULT_OK)
+                            finish()
+                        }
+
+                        is WebViewModel.Command.Load -> webView.loadUrl(it.url)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun cancelActivity() {
+        setResult(RESULT_CANCELED)
+        finish()
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = if (item.itemId == android.R.id.home) {
+        cancelActivity()
+
+        true
+    } else super.onOptionsItemSelected(item)
+
+    @Parcelize
+    internal class Parameters(
+        val title: String, val events: IBinder
+    ) : Parcelable
+
+    internal companion object {
+        const val KEY = "params"
+    }
+}
+
+@OptIn(PluginHostApi::class)
+internal class WebViewModel : ViewModel() {
+    init {
+        CookieManager.getInstance().apply {
+            removeAllCookies(null)
+            setAcceptCookie(true)
+        }
+    }
+
+    private val commandChannel = Channel<Command>()
+    val commands = commandChannel.receiveAsFlow()
+
+    private var eventBinder: IWebViewEvents? = null
+    private val ctrlBinder = object : IWebView.Stub() {
+        override fun load(url: String?) {
+            viewModelScope.launch {
+                commandChannel.send(Command.Load(url!!))
+            }
+        }
+
+        override fun finish() {
+            viewModelScope.launch {
+                commandChannel.send(Command.Finish)
+            }
+        }
+    }
+
+    val webViewClient = object : WebViewClient() {
+        override fun onPageFinished(view: WebView?, url: String?) {
+            super.onPageFinished(view, url)
+            eventBinder!!.pageLoad(url)
+        }
+    }
+
+    fun onDownload(url: String, mimeType: String, userAgent: String) {
+        eventBinder!!.download(url, mimeType, userAgent)
+    }
+
+    fun setup(binder: IWebViewEvents) {
+        if (eventBinder != null) return
+        eventBinder = binder
+        binder.ready(ctrlBinder)
+    }
+
+    sealed interface Command {
+        data class Load(val url: String) : Command
+        data object Finish : Command
+    }
+}

api/src/main/res/layout/activity_webview.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:id="@+id/main">
+
+    <WebView
+        android:id="@+id/webview"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</LinearLayout>

api/src/main/res/values/strings.xml

@@ -0,0 +1 @@
+<resources></resources>

api/src/main/res/values/themes.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.WebViewActivity" parent="Theme.AppCompat.DayNight">
+        <item name="android:windowActionBar">true</item>
+        <item name="android:windowNoTitle">false</item>
+    </style>
+</resources>