Efecto de animación de corazón flotante de Android (me gusta en vivo) (3) --- puntos de conocimiento relacionados

Este artículo trata sobre la recopilación de puntos de conocimiento relacionados con el efecto de Android Piaoxin Animation (Live Likes)
. Debería ser que no estoy muy familiarizado con las partes relacionadas con la animación, por lo que el primer artículo mencionado anteriormente es solo un resumen y una colación. .

1.vista personalizada de Android onMeasure ()

Se puede decir que las tres funciones de onMeasure (), onLayout () y onDraw () están sobrecargadas para crear la apariencia de una Vista personalizada. Junto con el comportamiento de las vistas sobrecargadas como onTouchEvent (), podemos crear cualquier Vista personalizada perceptible que necesitemos.

Explicación del
modo : Hay tres casos de modo, los valores son MeasureSpec.UNSPECIFIED, MeasureSpec.EXACTLY, MeasureSpec.AT_MOST.

MeasureSpec.EXACTLY es el tamaño exacto. Cuando especificamos layout_width o layout_height del control como un valor específico, como andorid: layout_width = ”50dip”, o FILL_PARENT, es el caso de que se haya determinado el tamaño del control, y es del tamaño exacto.

MeasureSpec.AT_MOST es el tamaño máximo. Cuando el layout_width o layout_height del control se especifica como WRAP_CONTENT, el tamaño del control generalmente cambia con el subespacio o contenido del control. En este momento, el tamaño del control no excede el tamaño máximo permitido por el control padre. Por lo tanto, el modo en este momento es AT_MOST y el tamaño proporciona el tamaño máximo permitido por el control principal.

MeasureSpec.UNSPECIFIED es un tamaño no especificado. No hay muchos casos. Generalmente, el control padre es el AdapterView, que se pasa a través del método de medida.
Por lo tanto, al reescribir el método onMeasure, el tamaño debe calcularse de acuerdo con el modo.
El siguiente código es una forma más típica:

@Override    
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    
    setMeasuredDimension(getMeasuredLength(widthMeasureSpec, true), getMeasuredLength(heightMeasureSpec, false));    
}    


private int getMeasuredLength(int length, boolean isWidth) {    
    int specMode = MeasureSpec.getMode(length);    
    int specSize = MeasureSpec.getSize(length);    
    int size;    
    int padding = isWidth ? getPaddingLeft() + getPaddingRight()    
            : getPaddingTop() + getPaddingBottom();    
    if (specMode == MeasureSpec.EXACTLY) {    
        size = specSize;    
    } else {    
        size = isWidth ? padding + mWave.length / 4 : DEFAULT_HEIGHT    
                + padding;    
        if (specMode == MeasureSpec.AT_MOST) {    
            size = Math.min(size, specSize);    
        }    
    }    
    return size;    
}  

Dirección del enlace relacionado: http://blog.csdn.net/pi9nc/article/details/18764863


Interpolador de animación 2.android

2.1 Explicación del texto del interpolador:

http://blog.csdn.net/jason0539/article/details/16370405

El interpolador se utiliza para la interpolación temporal en la animación. Su función es mapear un cambio de valor de punto flotante de 0 a 1 a otro cambio de valor de punto flotante.

(1) AccelerateDecelerateInterpolator cambia lentamente al principio y al final de la animación, y acelera en el medio
(2) AccelerateInterpolator cambia lentamente al comienzo de la animación, y luego comienza a acelerar
(3) AnticipateInterpolator comienza hacia atrás y adelante Flick
(4) AnticipateOvershootInterpolator al principio, desplácese hacia atrás y luego hacia adelante un cierto valor antes de regresar al valor final
(5) BounceInterpolator rebota al final de la animación
(6) CycleInterpolator se repite un número específico de veces, la tasa cambia a lo largo de la curva sinusoidal
(7)) DecelerateInterpolator es rápido y luego lento al comienzo de la animación
(8) LinearInterpolator cambia a una tasa constante
(9.) OvershootInterpolator da un giro hacia adelante un cierto valor y luego regresa a la posición original

2.2 Explicación de la carta del interpolador:

http://www.cnblogs.com/mengdd/p/3346003.html

2.3 Uso simple del interpolador (es mejor escribirlo usted mismo)
https://github.com/walfud/HelloInterpolator

2.4 Interpolador personalizado (uso avanzado):
http://www.cnblogs.com/wondertwo/p/5327586.html


3.ruta y ruta de animación de Android

Explicación básica de la ruta:
http://blog.csdn.net/cquwentao/article/details/51363475

Ruta avanzada y medida de ruta:
http://blog.csdn.net/cquwentao/article/details/51436852

PathMeasure
PathMeasure se utiliza principalmente para medir la ruta, a través de ella, podemos obtener las coordenadas de un punto específico en la ruta y así sucesivamente. Primero mira su método básico.

(1) Método de construcción
public PathMeasure ()
public PathMeasure (Path path, boolean forceClosed)
Como arriba, hay dos métodos, el primero no se explicará, el segundo método tiene dos parámetros;
ruta: la ruta
forceClosed para ser medido : Ya sea para cerrar el camino

(2) setPath
public void setPath (Path path, boolean forceClosed)
Aquí se especifica la ruta a medir, que es básicamente similar al segundo constructor anterior.

(3) getLength
devuelve la longitud total de la ruta actual.

(4) getMatrix
public boolean getMatrix (distancia flotante, matriz de matriz, indicadores int)
Este método es similar al anterior, excepto que devuelve una matriz procesada, pero esta matriz usa la esquina superior izquierda como punto de rotación, por lo que debe Este punto se mueve al punto central.
También hay banderas de parámetros adicionales, que se refieren a la información que necesita el martrix. El valor de las banderas tiene los siguientes dos
PathMeasure.POSITION_MATRIX_FLAG: información de ubicación
pathMeasure.TANGENT_MATRIX_FLAG: información de recorte, información de azimut, haciendo que la imagen gire de acuerdo con la ruta.


4. Atomicinteger de clase acumulativa segura para subprocesos

El papel de la clase atomicinteger: especialmente adecuado para un alto acceso concurrente.

AtomicInteger, una clase Integer que proporciona operaciones atómicas. En el lenguaje Java, las operaciones ++ i e i ++ no son seguras para subprocesos. Al usarlas, inevitablemente se usará la palabra clave sincronizada. AtomicInteger utiliza una interfaz de suma y resta segura para subprocesos.

Dirección relacionada:
http://www.cnblogs.com/Gordon-YangYiBao/archive/2012/08/07/2626422.html

http://haininghacker-foxmail-com.iteye.com/blog/1401346

Supongo que te gusta

Origin blog.csdn.net/android_freshman/article/details/52447444
Recomendado
Clasificación