feature: add kdoc to main entites

Author: EmogurovAnton

panel-core/src/main/kotlin/com/redmadrobot/debug/core/DebugEvent.kt

@@ -1,3 +1,17 @@
 package com.redmadrobot.debug.core
 
+/**
+ * Marker interface for events emitted by plugins.
+ *
+ * Plugins send events via [com.redmadrobot.debug.core.plugin.Plugin.pushEvent],
+ * consumers subscribe via [DebugPanel.subscribeToEvents] or [DebugPanel.observeEvents].
+ *
+ * Example:
+ * ```
+ * data class ServerSelectedEvent(val server: DebugServer) : DebugEvent
+ * ```
+ *
+ * @see com.redmadrobot.debug.core.plugin.Plugin.pushEvent
+ * @see DebugPanel.observeEvents
+ */
 public interface DebugEvent

panel-core/src/main/kotlin/com/redmadrobot/debug/core/DebugPanel.kt

@@ -12,13 +12,41 @@ import com.redmadrobot.debug.core.util.ApplicationLifecycleHandler
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.emptyFlow
 
+/**
+ * Main entry point for working with the debug panel.
+ *
+ * Before use, [initialize] must be called in [Application.onCreate].
+ *
+ * Initialization example:
+ * ```
+ * DebugPanel.initialize(
+ *     application = this,
+ *     plugins = listOf(
+ *         ServersPlugin(preInstalledServers),
+ *         KonfeaturePlugin(interceptor, konfeature),
+ *     )
+ * )
+ * ```
+ *
+ * @see Plugin
+ */
 @OptIn(DebugPanelInternal::class)
 public object DebugPanel {
     @Volatile
     private var instance: DebugPanelInstance? = null
+
+    /** Returns `true` if the panel has been initialized via [initialize]. */
     public val isInitialized: Boolean
         get() = instance != null
 
+    /**
+     * Initializes the debug panel with the provided set of plugins.
+     *
+     * Must be called **once** in [Application.onCreate].
+     *
+     * @param application the [Application] instance
+     * @param plugins list of plugins to be displayed in the panel
+     */
     public fun initialize(
         application: Application,
         plugins: List<Plugin>,
@@ -27,14 +55,32 @@ public object DebugPanel {
         ApplicationLifecycleHandler(application).start()
     }
 
+    /**
+     * Subscribes to plugin events with lifecycle binding.
+     *
+     * @param lifecycleOwner lifecycle owner (Activity, Fragment)
+     * @param onEvent callback invoked when an event is received
+     */
     public fun subscribeToEvents(lifecycleOwner: LifecycleOwner, onEvent: (DebugEvent) -> Unit) {
         instance?.getEventLiveData()?.observe(lifecycleOwner, Observer { onEvent.invoke(it) })
     }
 
+    /**
+     * Returns a [Flow] of events from plugins.
+     *
+     * If the panel is not initialized, returns an empty Flow.
+     */
     public fun observeEvents(): Flow<DebugEvent> {
         return instance?.getEventFlow() ?: emptyFlow()
     }
 
+    /**
+     * Opens the Activity containing the debug panel.
+     *
+     * Does nothing if the panel has not been initialized.
+     *
+     * @param activity the Activity from which the panel will be launched
+     */
     public fun showPanel(activity: Activity) {
         if (isInitialized) {
             openDebugPanel(activity)

panel-core/src/main/kotlin/com/redmadrobot/debug/core/annotation/DebugPanelInternal.kt

@@ -1,5 +1,12 @@
 package com.redmadrobot.debug.core.annotation
 
+/**
+ * Marks an API as internal to the debug panel.
+ *
+ * Entities with this annotation are intended for use only within the library's modules and may change without notice.
+ *
+ * Using a marked API outside the library will produce a compilation error.
+ */
 @RequiresOptIn(
     level = RequiresOptIn.Level.ERROR,
     message = "This is an internal part of DebugPanel. You shouldn't use it, cause it can be changed in future"

panel-core/src/main/kotlin/com/redmadrobot/debug/core/data/DebugDataProvider.kt

@@ -1,5 +1,22 @@
 package com.redmadrobot.debug.core.data
 
+/**
+ * Functional interface for lazy data supply to plugins.
+ *
+ * Allows passing data into a plugin through a provider rather than directly,
+ * which is useful when data is produced lazily.
+ *
+ * Example usage with [com.redmadrobot.debug.plugin.servers.ServersPlugin]:
+ * ```
+ * val provider = DebugDataProvider<List<DebugServer>> {
+ *     listOf(DebugServer("Prod", "https://api.example.com", isDefault = true))
+ * }
+ * ServersPlugin(preInstalledServers = provider)
+ * ```
+ *
+ * @param T type of provided data
+ */
 public interface DebugDataProvider<T> {
+    /** Returns data of type [T]. */
     public fun provideData(): T
 }

panel-core/src/main/kotlin/com/redmadrobot/debug/core/extension/CoroutinesExtension.kt

@@ -6,8 +6,13 @@ import kotlinx.coroutines.launch
 import timber.log.Timber
 
 /**
- * Запуск корутины с встроенной обработкой ошибки
- * */
+ * Launches a coroutine with error handling.
+ *
+ * Catches all exceptions except [CancellationException], logs them via Timber.
+ *
+ * @param block suspend block to execute
+ * @param onError callback invoked when an error occurs
+ */
 @Suppress("TooGenericExceptionCaught")
 public fun CoroutineScope.safeLaunch(
     block: suspend CoroutineScope.() -> Unit,
@@ -26,8 +31,13 @@ public fun CoroutineScope.safeLaunch(
 }
 
 /**
- * Запуск корутины с встроенным логированием ошибки
- * */
+ * Launches a coroutine with error logging.
+ *
+ * Equivalent to [safeLaunch] with an empty error handler --
+ * exceptions are only logged via Timber.
+ *
+ * @param block suspend block to execute
+ */
 public fun CoroutineScope.safeLaunch(
     block: suspend CoroutineScope.() -> Unit
 ) {

panel-core/src/main/kotlin/com/redmadrobot/debug/core/extension/PluginsExt.kt

@@ -14,6 +14,12 @@ internal fun getAllPlugins(): List<Plugin> {
     return DebugPanel.getInstance()?.getPluginManager()?.plugins ?: emptyList()
 }
 
+/**
+ * Returns the registered plugin of the specified type.
+ *
+ * @throws IllegalArgumentException if the plugin is not found in the registry
+ * @see DebugPanel
+ */
 @DebugPanelInternal
 public inline fun <reified T : Plugin> getPlugin(): T {
     val plugin = getPlugin(T::class.java.name)

panel-core/src/main/kotlin/com/redmadrobot/debug/core/internal/CommonContainer.kt

@@ -3,5 +3,13 @@ package com.redmadrobot.debug.core.internal
 import android.content.Context
 import com.redmadrobot.debug.core.annotation.DebugPanelInternal
 
+/**
+ * Container with shared dependencies, available to all plugins.
+ *
+ * Passed into [com.redmadrobot.debug.core.plugin.Plugin.getPluginContainer]
+ * when a plugin is initialized.
+ *
+ * @property context application context
+ */
 @DebugPanelInternal
 public class CommonContainer(public val context: Context) : PluginDependencyContainer

panel-core/src/main/kotlin/com/redmadrobot/debug/core/internal/EditablePlugin.kt

@@ -4,10 +4,18 @@ import androidx.compose.runtime.Composable
 import com.redmadrobot.debug.core.annotation.DebugPanelInternal
 
 /**
- * Plugin that will be displayed when opening the settings
+ * Interface for plugins providing a settings screen.
+ *
+ * A plugin implementing this interface will be displayed
+ * in the settings section of the debug panel.
+ *
+ * @see com.redmadrobot.debug.plugin.servers.ServersPlugin -- example implementation
  */
 @DebugPanelInternal
 public interface EditablePlugin {
+    /**
+     * Composable function rendering the plugin's settings UI.
+     */
     @Suppress("TopLevelComposableFunctions", "ComposableFunctionName")
     @Composable
     public fun settingsContent() {

panel-core/src/main/kotlin/com/redmadrobot/debug/core/internal/PluginDependencyContainer.kt

@@ -2,5 +2,13 @@ package com.redmadrobot.debug.core.internal
 
 import com.redmadrobot.debug.core.annotation.DebugPanelInternal
 
+/**
+ * Marker interface for plugin dependency containers.
+ *
+ * Each plugin implements its own container, extending this interface, to hold repositories, interactors, and other dependencies.
+ *
+ * @see com.redmadrobot.debug.core.plugin.Plugin.getPluginContainer
+ * @see CommonContainer
+ */
 @DebugPanelInternal
 public interface PluginDependencyContainer

panel-core/src/main/kotlin/com/redmadrobot/debug/core/plugin/Plugin.kt

@@ -6,6 +6,18 @@ import com.redmadrobot.debug.core.DebugPanel
 import com.redmadrobot.debug.core.internal.CommonContainer
 import com.redmadrobot.debug.core.internal.PluginDependencyContainer
 
+/**
+ * Base class for all debug panel plugins.
+ *
+ * Each plugin is an isolated module with its own UI and dependencies.
+ * To create a plugin, you need to:
+ * 1. Extend [Plugin]
+ * 2. Implement [getName] and [getPluginContainer]
+ * 3. Override [content] to render the UI
+ *
+ * @see DebugPanel.initialize
+ * @see PluginDependencyContainer
+ */
 public abstract class Plugin {
     private lateinit var pluginContainer: PluginDependencyContainer
 
@@ -14,18 +26,46 @@ public abstract class Plugin {
         return this
     }
 
+    /**
+     * Sends an event to the debug panel's shared event bus.
+     *
+     * Subscribers will receive the event via [DebugPanel.subscribeToEvents] or [DebugPanel.observeEvents].
+     *
+     * @param debugEvent event to send
+     */
     public fun pushEvent(debugEvent: DebugEvent) {
         DebugPanel.getInstance()?.pushEvent(debugEvent)
     }
 
+    /**
+     * Returns the plugin's dependency container, cast to type [T].
+     *
+     * @throws ClassCastException if the container does not match the requested type
+     */
     public fun <T> getContainer(): T = pluginContainer as T
 
+    /**
+     * Composable function that renders the plugin's main UI in the debug panel.
+     */
     @Suppress("TopLevelComposableFunctions", "ComposableFunctionName")
     @Composable
     public open fun content() {
     }
 
+    /**
+     * Creates and returns the plugin's dependency container.
+     *
+     * Called during plugin initialization. Use [commonContainer] to access shared dependencies (e.g., [android.content.Context]).
+     *
+     * @param commonContainer container with the panel's shared dependencies
+     * @return the dependency container for this plugin
+     */
     public abstract fun getPluginContainer(commonContainer: CommonContainer): PluginDependencyContainer
 
+    /**
+     * Returns the plugin's unique name.
+     *
+     * Used to identify the plugin in the registry.
+     */
     public abstract fun getName(): String
 }