Handle drag and drops from widget picker into communal grid.

import android.util.SizeF

import android.widget.FrameLayout

import androidx.compose.animation.core.animateDpAsState

import androidx.compose.foundation.BorderStroke

import androidx.compose.foundation.ExperimentalFoundationApi

import androidx.compose.foundation.background

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.BoxScope

import androidx.compose.foundation.layout.PaddingValues

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.Spacer

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.height

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.layout.size

import androidx.compose.foundation.layout.width

import androidx.compose.foundation.lazy.grid.GridCells

import androidx.compose.foundation.lazy.grid.GridItemSpan

import androidx.compose.foundation.lazy.grid.LazyHorizontalGrid

import androidx.compose.foundation.lazy.grid.rememberLazyGridState

import androidx.compose.foundation.shape.RoundedCornerShape

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.filled.Add

import androidx.compose.material.icons.filled.Edit

        modifier = modifier.fillMaxSize().background(Color.White),

    ) {

        CommunalHubLazyGrid(

            modifier = Modifier.align(Alignment.CenterStart),

            communalContent = communalContent,

            viewModel = viewModel,

            contentPadding = gridContentPadding(viewModel.isEditMode, toolbarSize),

@OptIn(ExperimentalFoundationApi::class)

@Composable

private fun CommunalHubLazyGrid(

private fun BoxScope.CommunalHubLazyGrid(

    communalContent: List<CommunalContentModel>,

    viewModel: BaseCommunalViewModel,

    modifier: Modifier = Modifier,

    contentPadding: PaddingValues,

    setGridCoordinates: (coordinates: LayoutCoordinates) -> Unit,

    updateDragPositionForRemove: (offset: Offset) -> Boolean,

) {

    var gridModifier = modifier

    var gridModifier = Modifier.align(Alignment.CenterStart)

    val gridState = rememberLazyGridState()

    var list = communalContent

    var dragDropState: GridDragDropState? = null

    if (viewModel.isEditMode && viewModel is CommunalEditModeViewModel) {

        val contentListState = rememberContentListState(communalContent, viewModel)

        list = contentListState.list

        // for drag & drop operations within the communal hub grid

        dragDropState =

            rememberGridDragDropState(

                gridState = gridState,

                .fillMaxSize()

                .dragContainer(dragDropState, beforeContentPadding(contentPadding))

                .onGloballyPositioned { setGridCoordinates(it) }

        // for widgets dropped from other activities

        val dragAndDropTargetState =

            rememberDragAndDropTargetState(

                gridState = gridState,

                contentListState = contentListState,

                updateDragPositionForRemove = updateDragPositionForRemove

            )

        // A full size box in background that listens to widget drops from the picker.

        // Since the grid has its own listener for in-grid drag events, we use a separate element

        // for android drag events.

        Box(Modifier.fillMaxSize().dragAndDropTarget(dragAndDropTargetState)) {}

    } else {

        gridModifier = gridModifier.height(Dimensions.GridHeight)

    }

    LazyHorizontalGrid(

        modifier = gridModifier,

        state = gridState,

) {

    when (model) {

        is CommunalContentModel.Widget -> WidgetContent(model, size, elevation, modifier)

        is CommunalContentModel.WidgetPlaceholder -> WidgetPlaceholderContent(size)

        is CommunalContentModel.Smartspace -> SmartspaceContent(model, modifier)

        is CommunalContentModel.Tutorial -> TutorialContent(modifier)

        is CommunalContentModel.Umo -> Umo(viewModel, modifier)

    }

}

/** Presents a placeholder card for the new widget being dragged and dropping into the grid. */

@Composable

fun WidgetPlaceholderContent(size: SizeF) {

    Card(

        modifier = Modifier.size(Dp(size.width), Dp(size.height)),

        colors = CardDefaults.cardColors(containerColor = Color.Transparent),

        border = BorderStroke(3.dp, LocalAndroidColorScheme.current.tertiaryFixed),

        shape = RoundedCornerShape(16.dp)

    ) {}

}

@Composable

private fun WidgetContent(

    model: CommunalContentModel.Widget,

import android.content.ComponentName

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.setValue

import androidx.compose.runtime.toMutableStateList

import com.android.systemui.communal.domain.model.CommunalContentModel

import com.android.systemui.communal.ui.viewmodel.CommunalEditModeViewModel

    private val onDeleteWidget: (id: Int) -> Unit,

    private val onReorderWidgets: (widgetIdToPriorityMap: Map<Int, Int>) -> Unit,

) {

    var list by mutableStateOf(communalContent)

    var list = communalContent.toMutableStateList()

        private set

    /** Move item to a new position in the list. */

    fun onMove(fromIndex: Int, toIndex: Int) {

        list = list.toMutableList().apply { add(toIndex, removeAt(fromIndex)) }

        list.apply { add(toIndex, removeAt(fromIndex)) }

    }

    /** Remove widget from the list and the database. */

    fun onRemove(indexToRemove: Int) {

        if (list[indexToRemove] is CommunalContentModel.Widget) {

            val widget = list[indexToRemove] as CommunalContentModel.Widget

            list = list.toMutableList().apply { removeAt(indexToRemove) }

            list.apply { removeAt(indexToRemove) }

            onDeleteWidget(widget.appWidgetId)

        }

    }

            onAddWidget(newItemComponentName, /*priority=*/ list.size - newItemIndex)

        }

    }

    /** Returns true if the item at given index is editable. */

    fun isItemEditable(index: Int) = list[index] is CommunalContentModel.Widget

}

/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.systemui.communal.ui.compose

import android.content.ClipDescription

import android.content.ComponentName

import android.content.Intent

import android.view.DragEvent

import androidx.compose.foundation.ExperimentalFoundationApi

import androidx.compose.foundation.draganddrop.dragAndDropTarget

import androidx.compose.foundation.gestures.Orientation

import androidx.compose.foundation.gestures.scrollBy

import androidx.compose.foundation.lazy.grid.LazyGridItemInfo

import androidx.compose.foundation.lazy.grid.LazyGridState

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.MutableState

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableFloatStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.rememberCoroutineScope

import androidx.compose.runtime.rememberUpdatedState

import androidx.compose.ui.Modifier

import androidx.compose.ui.draganddrop.DragAndDropEvent

import androidx.compose.ui.draganddrop.DragAndDropTarget

import androidx.compose.ui.draganddrop.mimeTypes

import androidx.compose.ui.draganddrop.toAndroidDragEvent

import androidx.compose.ui.geometry.Offset

import androidx.compose.ui.platform.LocalDensity

import androidx.compose.ui.unit.dp

import com.android.systemui.communal.domain.model.CommunalContentModel

import com.android.systemui.communal.ui.compose.extensions.plus

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.delay

import kotlinx.coroutines.isActive

import kotlinx.coroutines.launch

/**

 * Holds state associated with dragging and dropping items from other activities into the lazy grid.

 *

 * @see dragAndDropTarget

 */

@Composable

internal fun rememberDragAndDropTargetState(

    gridState: LazyGridState,

    contentListState: ContentListState,

    updateDragPositionForRemove: (offset: Offset) -> Boolean,

): DragAndDropTargetState {

    val scope = rememberCoroutineScope()

    val autoScrollSpeed = remember { mutableFloatStateOf(0f) }

    // Threshold of distance from edges that should start auto-scroll - chosen to be a narrow value

    // that allows differentiating intention of scrolling from intention of dragging over the first

    // visible item.

    val autoScrollThreshold = with(LocalDensity.current) { 60.dp.toPx() }

    val state =

        remember(gridState, contentListState) {

            DragAndDropTargetState(

                state = gridState,

                contentListState = contentListState,

                scope = scope,

                autoScrollSpeed = autoScrollSpeed,

                autoScrollThreshold = autoScrollThreshold,

                updateDragPositionForRemove = updateDragPositionForRemove,

            )

        }

    LaunchedEffect(autoScrollSpeed.floatValue) {

        if (autoScrollSpeed.floatValue != 0f) {

            while (isActive) {

                gridState.scrollBy(autoScrollSpeed.floatValue)

                delay(10)

            }

        }

    }

    return state

}

/**

 * Attaches a listener for drag and drop events from other activities.

 *

 * @see androidx.compose.foundation.draganddrop.dragAndDropTarget

 * @see DragEvent

 */

@OptIn(ExperimentalFoundationApi::class)

@Composable

internal fun Modifier.dragAndDropTarget(

    dragDropTargetState: DragAndDropTargetState,

): Modifier {

    val state by rememberUpdatedState(dragDropTargetState)

    return this then

        Modifier.dragAndDropTarget(

            shouldStartDragAndDrop = accept@{ startEvent ->

                    startEvent.mimeTypes().any { it == ClipDescription.MIMETYPE_TEXT_INTENT }

                },

            target =

                object : DragAndDropTarget {

                    override fun onStarted(event: DragAndDropEvent) {

                        state.onStarted()

                    }

                    override fun onMoved(event: DragAndDropEvent) {

                        state.onMoved(event)

                    }

                    override fun onDrop(event: DragAndDropEvent): Boolean {

                        return state.onDrop(event)

                    }

                    override fun onEnded(event: DragAndDropEvent) {

                        state.onEnded()

                    }

                }

        )

}

/**

 * Handles dropping of an item coming from a different activity (e.g. widget picker) in to the grid

 * corresponding to the provided [LazyGridState].

 *

 * Adds a placeholder container to highlight the anticipated location the widget will be dropped to.

 * When the item is held over an empty area, the placeholder appears at the end of the grid if one

 * didn't exist already. As user moves the item over an existing item, the placeholder appears in

 * place of that existing item. And then, the existing item is pushed over as part of re-ordering.

 *

 * Once item is dropped, new ordering along with the dropped item is persisted. See

 * [ContentListState.onSaveList].

 *

 * Difference between this and [GridDragDropState] is that, this is used for listening to drops from

 * other activities. [GridDragDropState] on the other hand, handles dragging of existing items in

 * the communal hub grid.

 */

internal class DragAndDropTargetState(

    private val state: LazyGridState,

    private val contentListState: ContentListState,

    private val scope: CoroutineScope,

    private val autoScrollSpeed: MutableState<Float>,

    private val autoScrollThreshold: Float,

    private val updateDragPositionForRemove: (offset: Offset) -> Boolean,

) {

    /**

     * The placeholder item that is treated as if it is being dragged across the grid. It is added

     * to grid once drag and drop event is started and removed when event ends.

     */

    private var placeHolder = CommunalContentModel.WidgetPlaceholder()

    private var placeHolderIndex: Int? = null

    private var isOnRemoveButton = false

    fun onStarted() {

        // assume item will be added to the end.

        contentListState.list.add(placeHolder)

        placeHolderIndex = contentListState.list.size - 1

    }

    fun onMoved(event: DragAndDropEvent) {

        val dragEvent = event.toAndroidDragEvent()

        isOnRemoveButton = updateDragPositionForRemove(Offset(dragEvent.x, dragEvent.y))

        if (!isOnRemoveButton) {

            findTargetItem(dragEvent)?.apply {

                var scrollIndex: Int? = null

                var scrollOffset: Int? = null

                if (placeHolderIndex == state.firstVisibleItemIndex) {

                    // Save info about the first item before the move, to neutralize the automatic

                    // keeping first item first.

                    scrollIndex = placeHolderIndex

                    scrollOffset = state.firstVisibleItemScrollOffset

                }

                autoScrollIfNearEdges(dragEvent)

                if (contentListState.isItemEditable(this.index)) {

                    movePlaceholderTo(this.index)

                    placeHolderIndex = this.index

                }

                if (scrollIndex != null && scrollOffset != null) {

                    // this is needed to neutralize automatic keeping the first item first.

                    scope.launch { state.scrollToItem(scrollIndex, scrollOffset) }

                }

            }

        }

    }

    fun onDrop(event: DragAndDropEvent): Boolean {

        autoScrollSpeed.value = 0f

        if (isOnRemoveButton) {

            return false

        }

        return placeHolderIndex?.let { dropIndex ->

            val componentName = event.maybeWidgetComponentName()

            if (componentName != null) {

                // Placeholder isn't removed yet to allow the setting the right priority for items

                // before adding in the new item.

                contentListState.onSaveList(

                    newItemComponentName = componentName,

                    newItemIndex = dropIndex

                )

                return@let true

            }

            return false

        }

            ?: false

    }

    fun onEnded() {

        autoScrollSpeed.value = 0f

        placeHolderIndex = null

        contentListState.list.remove(placeHolder)

        isOnRemoveButton = updateDragPositionForRemove(Offset.Zero)

    }

    private fun autoScrollIfNearEdges(dragEvent: DragEvent) {

        val orientation = state.layoutInfo.orientation

        val distanceFromStart =

            if (orientation == Orientation.Horizontal) {

                dragEvent.x

            } else {

                dragEvent.y

            }

        val distanceFromEnd =

            if (orientation == Orientation.Horizontal) {

                state.layoutInfo.viewportSize.width - dragEvent.x

            } else {

                state.layoutInfo.viewportSize.height - dragEvent.y

            }

        autoScrollSpeed.value =

            when {

                distanceFromEnd < autoScrollThreshold -> autoScrollThreshold - distanceFromEnd

                distanceFromStart < autoScrollThreshold ->

                    -(autoScrollThreshold - distanceFromStart)

                else -> 0f

            }

    }

    private fun findTargetItem(dragEvent: DragEvent): LazyGridItemInfo? =

        state.layoutInfo.visibleItemsInfo.firstOrNull { item ->

            dragEvent.x.toInt() in item.offset.x..(item.offset + item.size).x &&

                dragEvent.y.toInt() in item.offset.y..(item.offset + item.size).y

        }

    private fun movePlaceholderTo(index: Int) {

        val currentIndex = contentListState.list.indexOf(placeHolder)

        if (currentIndex != index) {

            contentListState.onMove(currentIndex, index)

        }

    }

    /**

     * Parses and returns the component name of the widget that was dropped into the communal grid.

     *

     * Returns null if the drop event didn't include the widget information.

     */

    private fun DragAndDropEvent.maybeWidgetComponentName(): ComponentName? {

        val clipData = this.toAndroidDragEvent().clipData.takeIf { it.itemCount != 0 }

        return clipData

            ?.getItemAt(0)

            ?.intent

            ?.getParcelableExtra(Intent.EXTRA_COMPONENT_NAME, ComponentName::class.java)

    }

}

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.geometry.Offset

import androidx.compose.ui.geometry.Size

import androidx.compose.ui.graphics.graphicsLayer

import androidx.compose.ui.input.pointer.pointerInput

import androidx.compose.ui.unit.IntOffset

import androidx.compose.ui.unit.IntSize

import androidx.compose.ui.unit.toOffset

import androidx.compose.ui.unit.toSize

import androidx.compose.ui.zIndex

import com.android.systemui.communal.domain.model.CommunalContentModel

import com.android.systemui.communal.ui.compose.extensions.plus

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.channels.Channel

import kotlinx.coroutines.launch

            .firstOrNull { item ->

                // grid item offset is based off grid content container so we need to deduct

                // before content padding from the initial pointer position

                item.isEditable &&

                contentListState.isItemEditable(item.index) &&

                    (offset.x - contentOffset.x).toInt() in item.offset.x..item.offsetEnd.x &&

                    (offset.y - contentOffset.y).toInt() in item.offset.y..item.offsetEnd.y

            }

        val targetItem =

            state.layoutInfo.visibleItemsInfo.find { item ->

                item.isEditable &&

                contentListState.isItemEditable(item.index) &&

                    middleOffset.x.toInt() in item.offset.x..item.offsetEnd.x &&

                    middleOffset.y.toInt() in item.offset.y..item.offsetEnd.y &&

                    draggingItem.index != item.index

    private val LazyGridItemInfo.offsetEnd: IntOffset

        get() = this.offset + this.size

    /** Whether the grid item can be dragged or be a drop target. Only widget card is editable. */

    private val LazyGridItemInfo.isEditable: Boolean

        get() = contentListState.list[this.index] is CommunalContentModel.Widget

    /** Calculate the amount dragged out of bound on both sides. Returns 0f if not overscrolled */

    private fun checkForOverscroll(startOffset: Offset, endOffset: Offset): Float {

        return when {

    }

}

private operator fun IntOffset.plus(size: IntSize): IntOffset {

    return IntOffset(x + size.width, y + size.height)

}

private operator fun Offset.plus(size: Size): Offset {

    return Offset(x + size.width, y + size.height)

}

fun Modifier.dragContainer(

    dragDropState: GridDragDropState,

    beforeContentPadding: ContentPaddingInPx

/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.systemui.communal.ui.compose.extensions

import androidx.compose.ui.geometry.Offset

import androidx.compose.ui.geometry.Size

import androidx.compose.ui.unit.IntOffset

import androidx.compose.ui.unit.IntSize

/** Adds the given size to the x and y offsets in this [IntOffset] */

operator fun IntOffset.plus(size: IntSize): IntOffset {

    return IntOffset(x + size.width, y + size.height)

}

/** Adds the given size to the x and y offsets in this [Offset]. */

operator fun Offset.plus(size: Size): Offset {

    return Offset(x + size.width, y + size.height)

}