¿Cómo implementar el deslizamiento hacia la izquierda y hacia la derecha en Android? ¿Alguien puede enseñarme?
/**
* Faux WorkSapce en Launcher es una clase que te permite deslizarte hacia la izquierda y hacia la derecha para cambiar de pantalla
*
*/
la clase pública ScrollLayout extiende ViewGroup {
/*
* Cuando el elemento padre del control está a punto de colocar su control secundario, Se llamará al método onMeasure. Pregunta "¿Qué tan grande quieres colocarlo?
* widthMeasureSpec y heightMeasureSpec. Especifican el espacio disponible del control y metadatos sobre la descripción de ese espacio.
* A Un mejor enfoque que devolver un resultado es pasar la altura y el ancho de la Vista al método setMeasuredDimension
* MeasureSpec contiene una dimensión y un modo
* Hay tres modos posibles:
p>* SIN ESPECIFICAR: el diseño principal no tiene restricciones en el diseño secundario, y el diseño secundario puede ser de cualquier tamaño
* Exacto: el diseño principal determina el tamaño exacto del diseño secundario. no importa cuán grande sea, todo debe limitarse a este límite
* AT_MOST: el subdiseño puede ser arbitrariamente grande
/*
* Clase VelocityTracker.
*
* Función: Calcula la velocidad de movimiento de cada píxel en función de la posición táctil
*
* Métodos comunes. son:
*
* public void addMovement (MotionEvent ev) Función: agrega un objeto táctil, concretamente MotionEvent, para calcular la velocidad de toque
* public void .computeCurrentVelocity (int unidades)
* Función: Calcular la velocidad de movimiento en unidades: Calcular la velocidad de movimiento en unidades de cada píxel. En realidad, no lo entiendo del todo, así que simplemente dale un valor de. 1000. El significado de la unidad es el siguiente: Unidad de parámetro:
* La unidad de velocidad 1 significa píxeles por milisegundo, 1000 significa píxeles por segundo, etc.: obtiene la velocidad en la dirección X.
*/
/*
* Clase ViewConfiguration
*
* Función: Obtener algún estándar. Valores constantes de tiempo de espera: obtener tiempo de espera, tamaño y distancia. Algunos valores constantes estándar
*
* Métodos comunes:
*
<. p> * public int getScaledEdgeSlop()*
*
* Descripción: obtiene el valor mínimo de píxel que se puede mover con el tacto. solo si se excede este valor, significa que debemos deslizar la pantalla
*
* public static int getLongPressTimeout()
*
<. p> ** * Descripción: Obtener la ejecución presionando prolongadamente El valor de onLongClickListener.
Es decir, cuando presionas un toque en una Vista, solo si el valor de tiempo excede
*
*, significa que debemos recuperar el tiempo prolongado en la Vista. Presione el evento; de lo contrario, suelte el dedo cuando sea menor que este punto de tiempo y solo ejecute el oyente onClick
*/
cadena final estática privada TAG = "ScrollLayout". ;
p>Desplazador privado mScroller;
VelocityTracker privado mVelocityTracker;
privado int mCurScreen ;//pantalla actual
privado int mDefaultScreen = 0;
//dos estados: si está en estado deslizante
private static final int TOUCH_STATE_REST = 0 //Estado estático
private static final int TOUCH_STATE_SCROLLING = 1;// Estado deslizante
private static final int SNAP_VELOCITY = 600; // Tasa deslizante mínima
private int mTouchState = TOUCH_STATE_REST;
private int mTouchSlop;//Cuánto cambiar Los píxeles se consideran una operación de movimiento
private float mLastMotionX;
private float mLastMotionY
public ScrollLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
// TODO genera automáticamente un código auxiliar de constructor
}
public ScrollLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO genera automáticamente códigos auxiliares de constructor
mScroller = new Scroller(context );
mCurScreen = mDefaultScreen;
// Inicializa la distancia mínima de deslizamiento
mTouchSlop = ViewConfiguration. get(getContext()) .getScaledTouchSlop();
}
/**
* Generar vista
*/
@ Override
protected void onLayout(boolean change, int l, int t, int r, int b) {
// TODO genera automáticamente resguardos de métodos
if (cambiado) {
int childLeft = 0;
final int childCount = getChildCount();
for (int i = 0 ; yo < niño
Count; i++) {
Vista final childView = getChildAt( i);
if (childView.getVisibility() != View.GONE) {
final int childWidth = childView.getMeasuredWidth();
childView.layout(childLeft, 0, childLeft + childWidth,
childView.getMeasuredHeight();
final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
if (heightMode ! = MeasureSpec.EXACTLY) {
throw new IllegalStateException(
"ScrollLayout solo puede ejecutarse en EXACTAMENTE modo ");
}
// El ancho y alto de los hijos son los mismos que scrollLayout
final int count = getChildCount();
for (int i = 0; i < count; i++) {
getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);
}
// Log.e(TAG, "moviéndose a la pantalla "+mCurScreen);
scrollTo(mCurScreen * ancho, 0);
}
/ **
* Desplácese a la página de destino
según la posición de diseño actual
*/
public void snapToDestination() {
// Determina si excede la posición media de la siguiente pantalla. Si es así, pasa a la siguiente pantalla; de lo contrario, permanece en la pantalla original.
// Una fórmula tan simple significa: Supongamos el desplazamiento de desplazamiento actual. El valor de desplazamiento (scrollCurX más la mitad del ancho de cada pantalla) dividido por el ancho de cada pantalla es
// donde se encuentra nuestra pantalla de destino.
Si el ancho de cada pantalla es 320dip, y el ancho de nuestra pantalla es 500dip, entonces obviamente deberíamos estar en la segunda pantalla, con índice 1
// Es decir (500 + 320/2)/ 320 = 1
final int screenWidth = getWidth();
final int destScreen = (getScrollX() + screenWidth / 2) / screenWidth;
snapToScreen( destScreen) ;
}
public void snapToScreen(int whatScreen) {
// Obtener una página de diseño válida
whichScreen = Math .max (0, Math.min(cuálScreen, getChildCount() - 1));
if ( getScrollX() != (cuálScreen * getWidth()){
final int delta = whichScreen * getWidth() - getScrollX();
mScroller.startScroll(getScrollX(), 0, delta, 0,
Math.abs(delta) * 5); p>
mCurScreen = whatScreen;
onScreenChangeListener.onScreenChange(mCurScreen);