¿Cómo usar arrastrar y soltar en las aplicaciones de Android?

Puede utilizar el marco de arrastrar y soltar de Android para permitir que sus usuarios muevan datos con una acción gráfica de arrastrar y soltar. Esto puede ser de una Vista en su propio programa a otra, o entre su aplicación y otra cuando el modo de ventanas múltiples está habilitado. En el marco se incluyen una clase de evento de arrastre, detectores de arrastre y métodos y clases auxiliares.

Ejemplos de casos de uso para arrastrar y soltar

1. Algo que lo ayude a arrastrar un puntero sobre datos en vivo para obtener el color del objeto o la cosa
2. En la pantalla de inicio de su dispositivo móvil, donde se muestra cada programa, podemos arrastrar y soltar sin esfuerzo íconos de aplicaciones de una ubicación a otra.

Sugerencia geek: para notificar al sistema que se está llamando a un evento de arrastre, su aplicación llama a la función startDrag(). Esta técnica también distribuye datos de una vista a otra.

Gestos utilizados en el evento completo

El marco de arrastrar y soltar en Android le permite arrastrar y soltar una vista a otra, es decir, en una actividad, si tiene dos o más vistas, puede mover los datos de una vista de una vista a la otra usando la función de arrastrar y soltar de Android. estructura. Por ejemplo, si su actividad de Android contiene dos TextViews, uno en la mitad de la pantalla y el otro en la otra mitad, el contenido del primer TextView puede arrastrarse y soltarse en el otro TextView.

1. Comenzado: comienza produciendo un ClipData y un ClipData. El elemento para los datos que se están transfiriendo. Proporcione los metadatos que se guardan en un objeto ClipDescription dentro de ClipData como parte del objeto ClipData. Es posible que desee utilizar un valor nulo en lugar de un objeto real para una acción de arrastrar y soltar que no refleje la transferencia de datos.
2. Continuación: si el detector de eventos de arrastre devuelve verdadero, el programa puede iniciar el evento de arrastre. El evento de arrastre está en curso, lo que significa que ha comenzado pero aún no ha terminado. Por ejemplo, si desea arrastrar un TextView llamado tv1 desde la posición 1 a la posición 2, los estados intermedios entre los dos están en estado continuo.
3. Soltado: el elemento arrastrado se libera dentro del cuadro delimitador de una Vista. El sistema envía un evento de arrastre con el tipo de acción ACTION DROP al oyente del objeto View.
4. Terminado: cuando el usuario suelta el elemento después de arrastrarlo y se llaman todos los eventos relacionados con ese estado de soltar, el sistema envía una señal a la aplicación de que la acción de soltar está completa y se realizan todas las funciones necesarias. Como resultado, el sistema muestra que el evento de arrastrar y soltar ha terminado.

Eventos que involucran arrastre

Consulte la siguiente tabla para comprender todos los diferentes eventos relacionados con el arrastre:

Efectos y Sombras en los Arrastre

El sistema muestra una imagen que el usuario arrastra durante una operación de arrastrar y soltar. Este gráfico representa los datos que se extraen en términos de movilidad de datos. La imagen ilustra algunas partes del proceso de arrastre para otros procedimientos.

La imagen se conoce como sombra de arrastre. Lo crea declarando métodos para un objeto View.DragShadowBuilder y luego pasándolo al sistema cuando inicia un arrastre con startDrag(). El sistema utiliza los métodos de devolución de llamada descritos en View.DragShadowBuilder para obtener una sombra de arrastre como parte de su respuesta a startDrag().

Ejemplo

En este ejemplo, arrastraremos y soltaremos una vista de texto dentro de una región delimitada de una ubicación a otra.

Paso #1: Primero, agregue el archivo de diseño de la aplicación

<?xml version="1.0" encoding="utf-8"?>
<ConstraintLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    <LinearLayout
            android:layout_width="match_parent"
            android:id="@+id/gfgLayout"
            android:orientation="vertical"
            android:layout_height="80dp"
            android:background="#0F9D58 ">
        <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:id="@+id/gfgDrop"
                android:text="GFG | First App "
                android:textSize="16p"
                android:layout_margin="24dp"
                android:textColor="#0F9D58 "/>
    </LinearLayout>
</ConstraintLayout>

Paso #2: Trabajar con el archivo Kotlin

package com.geeksforgeeks.sampleDrag
  
import android.os.Bundle
import android.support.v7.app.AppCompatActivity
import android.util.Log
import android.defGeeksView.DragEvent
import android.defGeeksView.MotionEvent
import android.defGeeksView.DefGeeksView
import android.defGeeksView.DefGeeksViewGroup
import android.widget.LinearLayout
import kotlinx.android.synthetic.main.activity_main.*
  
class MainActivity: AppCompatActivity(), DefGeeksView.OnTouchListener, DefGeeksView.DragHappeningListener {
    private val TAG = MainActivity::class.java.simpleName
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentDefGeeksView(R.layout.activity_main)
        theDraggers()
    }
    private fun theDraggers() {
        gfgDrop.setOnTouchListener(this)
        geeksforgeeksDefGeeksView.setDragHappeningListener(this)
    }
    override fun dragHappening(defGeeksView:DefGeeksView, dragEvent: DragEvent):Boolean {
        Log.d(TAG, "dragHappening: defGeeksView->$defGeeksView\n DragEvent$dragEvent")
        when (dragEvent.action) {
            DragEvent.ACTION_DRAG_ENDED -> {
                return true
            }
            DragEvent.ACTION_DRAG_EXITED -> {
                return true
            }
            DragEvent.ACTION_DRAG_ENTERED -> {
                return true
            }
            DragEvent.ACTION_DRAG_STARTED -> {
                return true
            }
            DragEvent.ACTION_DROP -> {
                val gfgTextDefGeeksView = dragEvent.localState as DefGeeksView
                val defaultText = gfgTextDefGeeksView.parent as DefGeeksViewGroup
                defaultText.removeDefGeeksView(gfgTextDefGeeksView)
                val container = defGeeksView as LinearLayout
                container.addDefGeeksView(gfgTextDefGeeksView)
                defaultText.removeDefGeeksView(gfgTextDefGeeksView)
                gfgTextDefGeeksView.x = dragEvent.x
                gfgTextDefGeeksView.y = dragEvent.y
                defGeeksView.addDefGeeksView(gfgTextDefGeeksView)
                defGeeksView.setVisibility(DefGeeksView.VISIBLE)
                return true
            }
            DragEvent.ACTION_DRAG_LOCATION -> {
                return true
            }
            else -> return false
        }
    }
    override fun onTouch(defGeeksView:DefGeeksView, motionEvent: MotionEvent):Boolean {
        return if (motionEvent.action === MotionEvent.ACTION_DOWN) {
            val dragShadowBuilder = DefGeeksView.DragShadowBuilder(defGeeksView)
            defGeeksView.startDrag(null, dragShadowBuilder, defGeeksView, 10)
            true
        } else {
            false
        }
    }
}

Obtén el código completo aquí .

Conclusión

Los dispositivos que ejecutan Android 7.0 (API nivel 24) o superior habilitan el modo de ventanas múltiples , que permite a los usuarios arrastrar y soltar datos de un programa a otro:

1. La aplicación que inicialmente tenía los datos se denomina aplicación de origen. Es aquí cuando comienza el trabajo duro.
2. La aplicación que recibe datos se denomina aplicación de destino. Es el punto en el que el arrastre llega a su fin.

Aprendimos a usar la funcionalidad de arrastrar y soltar en nuestra aplicación de Android en este artículo. Descubrimos una gran cantidad de eventos relacionados con el evento de arrastre. Finalmente, demostramos la función de arrastrar y soltar. Entonces, utilizando el método mencionado anteriormente, puede crear aplicaciones adicionales de arrastrar y soltar en Android.