Services & Dependency Injection

How to access Klyx services from your extension

Klyx provides services to extensions through property delegates and context functions. Services fall into two categories: global PluginService instances shared across all plugins, and per-plugin PluginRuntimeService instances scoped to your plugin.

Plugin services (global)

Global services are singletons shared across all plugins. Access them with by plugin():

private val screens: ScreenRegistry by plugin()
private val toolbar: ToolbarRegistry by plugin()
private val navigator: Navigator by plugin()
private val fileSystem: FileSystem by plugin()
private val openers: FileOpenerRegistry by plugin()
private val settings: Settings by plugin()
private val fonts: Fonts by plugin()
private val tabs: Tabs by plugin()
private val terminalManager: TerminalManager by plugin()
private val languageServers: LanguageServerRegistry by plugin()
private val languageRegistry: LanguageRegistry by plugin()
private val logger: Logger by plugin()

These delegates use Koin internally and resolve the service at first access. They work from anywhere in your KlyxPlugin implementation, including init blocks.

When you access Logger via by plugin(), Klyx automatically wraps it in a PluginLogger that tags log entries with your plugin’s name. This means you do not need to specify a tag manually.

Runtime services (per-plugin)

Runtime services are unique to your plugin instance. Access them with by runtime():

private val info: PluginInfo by runtime()
private val context: PluginContext by runtime()
private val lifecycleOwner: PluginLifecycleOwner by runtime()
private val pluginScope: PluginScope by runtime()
private val settings: PluginSettings by runtime()

PluginInfo gives you access to the plugin descriptor and file paths:

info.descriptor.name       // "My Extension"
info.descriptor.id         // "com.myext.helloworld"
info.descriptor.version    // "1.0.0"
info.descriptor.minAppVersion   // "4.2.0"
info.descriptor.maxAppVersion    // "5.0.0" or null
info.descriptor.entryClass       // "com.myext.MyExtension"
info.descriptor.description      // "A description"
info.descriptor.icon             // "icon.png" or null
info.descriptor.license          // "MIT"
info.descriptor.author           // PluginAuthor or null
info.descriptor.links            // PluginLinks or null
info.descriptor.permissions      // List<String>
info.apkPath                 // Path to the installed APK
info.bundlePath                // Path to the .klyx bundle (if available)
info.iconPath                  // Path to the icon file (if available)

PluginContext

The PluginContext gives your plugin access to the core application and runtime services:

val context: PluginContext by runtime()

Property	Type	Description
app	App	The core application instance
pluginId	String	The unique identifier of this plugin
dataDir	File	Private directory owned by this plugin for persistent data
resources	Resources	The plugin’s own Android Resources, backed by its APK
context	Context	An Android Context whose Resources point at the plugin’s own APK

Resolving services from PluginContext

You can resolve services inline from a PluginContext:

val screens = context.service<ScreenRegistry>()
val settings = context.service<Settings>()

The event bus

The event bus is accessed through the plugin context:

val bus = currentPluginContext().eventBus

Plugin resources

The PluginContext.context is an Android Context backed by the plugin’s own APK resources. Use withResources to make Compose resource lookups resolve against the plugin:

withResources {
    Icon(
        painterResource(R.drawable.my_icon),
        contentDescription = stringResource(R.string.icon_desc)
    )
}

Coroutine context access

Within a plugin’s coroutine scope, access services through the current coroutine context:

pluginScope.launch {
    val ctx = currentPluginContext()
    val owner = currentLifecycleOwner()
    val bus = ctx.eventBus

    val settings = ctx.service<Settings>()
    settings.settings.collect { current ->
        // React to settings changes
    }
}

Available functions:

Function	Returns	Description
currentPluginContext()	PluginContext	Current plugin context (throws if not in a plugin scope)
currentPluginContextOrNull()	PluginContext?	Current plugin context or null
currentLifecycleOwner()	PluginLifecycleOwner	Current lifecycle owner (throws if not in a plugin scope)

Complete service list

Service	Type	Description
ScreenRegistry	PluginService	Register and unregister composable screens
ToolbarRegistry	PluginService	Register and unregister toolbar actions
Navigator	PluginService	Navigate between app destinations
FileSystem	PluginService	File operations: list, read, write, delete, search
FileOpenerRegistry	PluginService	Register and unregister custom file openers
Settings	PluginService	Read and update application settings
Fonts	PluginService	Load font families from URIs
Tabs	PluginService	Manage workspace tabs
TerminalManager	PluginService	Create and manage terminal sessions
LanguageServerRegistry	PluginService	Register language server providers for file patterns
LanguageRegistry	PluginService	Register tree-sitter language grammars and queries
Logger	PluginService	Log messages with levels, tags, and plugin awareness
PluginSettingsRegistry	PluginService	Optionally register a dedicated settings screen for your plugin
PluginInfo	PluginRuntimeService	Current plugin descriptor and bundle paths
PluginContext	PluginRuntimeService	App reference, plugin data dir, resources, event bus
PluginLifecycleOwner	PluginRuntimeService	Android LifecycleOwner with lifecycleScope
PluginScope	PluginRuntimeService	Coroutine scope tied to load/unload lifecycle
PluginSettings	PluginRuntimeService	Typed, isolated settings store scoped to your plugin