androidx.compose.ui.platform

@ExperimentalComposeUiApi
@Composable
fun InterceptPlatformTextInput(
    interceptor: PlatformTextInputInterceptor,
    content: @Composable () -> Unit
): Unit

import androidx.compose.foundation.text.BasicTextField
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.InterceptPlatformTextInput
import androidx.compose.ui.platform.PlatformTextInputMethodRequest

var text by remember { mutableStateOf("") }

InterceptPlatformTextInput(
    interceptor = { request, nextHandler ->
        // Create a new request to wrap the incoming one with some custom logic.
        val modifiedRequest =
            object : PlatformTextInputMethodRequest {
                override fun createInputConnection(outAttributes: EditorInfo): InputConnection {
                    val inputConnection = request.createInputConnection(outAttributes)
                    // After the original request finishes initializing the EditorInfo we can
                    // customize it. If we needed to we could also wrap the InputConnection
                    // before
                    // returning it.
                    updateEditorInfo(outAttributes)
                    return inputConnection
                }

                fun updateEditorInfo(outAttributes: EditorInfo) {
                    // Your code here, e.g. set some custom properties.
                }
            }

        // Send our wrapping request to the next handler, which could be the system or another
        // interceptor up the tree.
        nextHandler.startInputMethod(modifiedRequest)
    }
) {
    BasicTextField(value = text, onValueChange = { text = it })
}

import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.InterceptPlatformTextInput

/**
 * A function that disables the soft keyboard for any text field within its content.
 *
 * The keyboard is re-enabled by removing this modifier or passing `disable = false`.
 */
@Composable
fun DisableSoftKeyboard(disable: Boolean = true, content: @Composable () -> Unit) {
    InterceptPlatformTextInput(
        interceptor = { request, nextHandler ->
            // If this flag is changed while an input session is active, a new lambda instance
            // that captures the new value will be passed to InterceptPlatformTextInput, which
            // will automatically cancel the session upstream and restart it with this new
            // interceptor.
            if (!disable) {
                // Forward the request to the system.
                nextHandler.startInputMethod(request)
            } else {
                // This function has to return Nothing, and since we don't have any work to do
                // in this case, we just suspend until cancelled.
                awaitCancellation()
            }
        },
        content = content,
    )
}

inline fun debugInspectorInfo(crossinline definitions: InspectorInfo.() -> Unit): InspectorInfo.() -> Unit

import androidx.compose.foundation.background
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.debugInspectorInfo
import androidx.compose.ui.platform.inspectable
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp

/** Sample with a single parameter */
fun Modifier.simpleFrame(color: Color) =
    inspectable(
        inspectorInfo =
            debugInspectorInfo {
                name = "simpleFrame"
                value = color
            }
    ) {
        background(color, RoundedCornerShape(5.0.dp))
    }

/** Sample with multiple parameters */
fun Modifier.fancyFrame(size: Dp, color: Color) =
    inspectable(
        inspectorInfo =
            debugInspectorInfo {
                name = "fancyFrame"
                properties["size"] = size
                properties["color"] = color
            }
    ) {
        background(color, RoundedCornerShape(size))
    }

@Composable
fun rememberNestedScrollInteropConnection(hostView: View = LocalView.current): NestedScrollConnection

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.nestedscroll.nestedScroll
import androidx.compose.ui.platform.rememberNestedScrollInteropConnection
import androidx.compose.ui.unit.dp

val nestedSrollInterop = rememberNestedScrollInteropConnection()
// Add the nested scroll connection to your top level @Composable element
// using the nestedScroll modifier.
LazyColumn(modifier = Modifier.nestedScroll(nestedSrollInterop)) {
    items(20) { item ->
        Box(
            modifier =
                Modifier.padding(16.dp).height(56.dp).fillMaxWidth().background(Color.Gray),
            contentAlignment = Alignment.Center,
        ) {
            Text(item.toString())
        }
    }
}

fun View.createLifecycleAwareWindowRecomposer(
    coroutineContext: CoroutineContext = EmptyCoroutineContext,
    lifecycle: Lifecycle? = null
): Recomposer

suspend fun PlatformTextInputModifierNode.establishTextInputSession(
    block: suspend PlatformTextInputSessionScope.() -> Nothing
): Nothing

import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusEventModifierNode
import androidx.compose.ui.focus.FocusState
import androidx.compose.ui.platform.PlatformTextInputMethodRequest
import androidx.compose.ui.platform.PlatformTextInputModifierNode
import androidx.compose.ui.platform.PlatformTextInputSession
import androidx.compose.ui.platform.establishTextInputSession

class PlatformTextInputModifierNodeSample :
    Modifier.Node(), FocusEventModifierNode, PlatformTextInputModifierNode {

    private var focusedJob: Job? = null

    override fun onFocusEvent(focusState: FocusState) {
        focusedJob?.cancel()
        focusedJob =
            if (focusState.isFocused) {
                // establishTextInputSession is a suspend function, so it must be called from a
                // coroutine. Launching it into this modifier node's coroutine scope ensures the
                // session will automatically be torn down when the node is detached.
                coroutineScope.launch {
                    // This will automatically cancel any currently-active session.
                    establishTextInputSession {
                        launch {
                            // TODO: Observe text field state, call into system to update it as
                            //  required by the platform.
                        }

                        // Call out to a platform-specific expect/actual function to create the
                        // platform-specific request.
                        val request: PlatformTextInputMethodRequest = createInputRequest()
                        startInputMethod(request)
                    }
                }
            } else {
                null
            }
    }

    // This would probably be an expect/actual function.
    private fun PlatformTextInputSession.createInputRequest(): PlatformTextInputMethodRequest {
        TODO("Create platform-specific request")
    }
}

fun View.findViewTreeCompositionContext(): CompositionContext?

@ExperimentalComposeUiApi
fun ClipEntry.firstUriOrNull(): Uri?

inline fun Modifier.inspectable(
    noinline inspectorInfo: InspectorInfo.() -> Unit,
    factory: Modifier.() -> Modifier
): Modifier

import androidx.compose.foundation.background
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.debugInspectorInfo
import androidx.compose.ui.platform.inspectable
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp

/** Sample with a single parameter */
fun Modifier.simpleFrame(color: Color) =
    inspectable(
        inspectorInfo =
            debugInspectorInfo {
                name = "simpleFrame"
                value = color
            }
    ) {
        background(color, RoundedCornerShape(5.0.dp))
    }

/** Sample with multiple parameters */
fun Modifier.fancyFrame(size: Dp, color: Color) =
    inspectable(
        inspectorInfo =
            debugInspectorInfo {
                name = "fancyFrame"
                properties["size"] = size
                properties["color"] = color
            }
    ) {
        background(color, RoundedCornerShape(size))
    }

fun Modifier.testTag(tag: String): Modifier

fun ClipData.toClipEntry(): ClipEntry

fun ClipDescription.toClipMetadata(): ClipMetadata

@ExperimentalComposeUiApi
var DisableContentCapture: Boolean

val LocalAccessibilityManager: ProvidableCompositionLocal<AccessibilityManager?>

val LocalAutofill: ProvidableCompositionLocal<Autofill?>

val LocalAutofillManager: ProvidableCompositionLocal<AutofillManager?>

val LocalAutofillTree: ProvidableCompositionLocal<AutofillTree>

val LocalClipboard: ProvidableCompositionLocal<Clipboard>

val LocalClipboardManager: ProvidableCompositionLocal<ClipboardManager>

val LocalConfiguration: ProvidableCompositionLocal<Configuration>

val LocalContext: ProvidableCompositionLocal<Context>

val LocalCursorBlinkEnabled: ProvidableCompositionLocal<Boolean>

val LocalDensity: ProvidableCompositionLocal<Density>

val LocalFocusManager: ProvidableCompositionLocal<FocusManager>

val LocalFontFamilyResolver: ProvidableCompositionLocal<FontFamily.Resolver>

val LocalGraphicsContext: ProvidableCompositionLocal<GraphicsContext>

val LocalHapticFeedback: ProvidableCompositionLocal<HapticFeedback>

val LocalInputModeManager: ProvidableCompositionLocal<InputModeManager>

val LocalInspectionMode: ProvidableCompositionLocal<Boolean>

val LocalLayoutDirection: ProvidableCompositionLocal<LayoutDirection>

val LocalLifecycleOwner: ProvidableCompositionLocal<LifecycleOwner>

val LocalResources: ProvidableCompositionLocal<Resources>

val LocalSavedStateRegistryOwner: ProvidableCompositionLocal<SavedStateRegistryOwner>

val LocalScrollCaptureInProgress: CompositionLocal<Boolean>

val LocalSoftwareKeyboardController: ProvidableCompositionLocal<SoftwareKeyboardController?>

val LocalTextInputService: ProvidableCompositionLocal<TextInputService?>

val LocalTextToolbar: ProvidableCompositionLocal<TextToolbar>

val LocalUriHandler: ProvidableCompositionLocal<UriHandler>

val LocalView: ProvidableCompositionLocal<View>

val LocalViewConfiguration: ProvidableCompositionLocal<ViewConfiguration>

val LocalWindowInfo: ProvidableCompositionLocal<WindowInfo>

val NoInspectorInfo: InspectorInfo.() -> Unit

var isDebugInspectorInfoEnabled: Boolean

var View.compositionContext: CompositionContext?