Guía de introducción a transiciones animadas personalizadas en iOS 8
Con la llegada de los guiones gráficos, todo lo anterior ha pasado a la historia, ya que este nuevo enfoque ha sido ampliamente utilizado por la comunidad de desarrolladores. El guión gráfico ofrece tres ventajas importantes sobre las tecnologías más antiguas:
Todo el diseño de la interfaz se produce en un solo archivo. El número total de documentos para un proyecto se ha reducido significativamente, especialmente en proyectos grandes. Por supuesto, puede utilizar archivos nib adicionales y solo crear vistas auxiliares.
Los desarrolladores pueden explorar instantáneamente la interfaz y el proceso de la aplicación. Las transiciones entre los controladores de vista (el término técnico para el diseño de interfaz se llama escenas) y cómo ocurren las transiciones están perfectamente definidas en el guión gráfico y se presentan claramente a los desarrolladores.
En resumen, la transición entre escenas constituye una parte especial del storyboard, que generalmente llamamos segue.
Las transiciones están estrechamente relacionadas con la navegación y el procesamiento de aplicaciones porque definen claramente los detalles de las transiciones de una vista a otra. Estos detalles especifican si se aplica la animación, el tipo de animación y, por supuesto, la preparación y ejecución del proceso de conversión real. Además, las transiciones se utilizan para transferir datos al siguiente controlador de vista, lo cual también es común.
Desde una perspectiva de programación, las escenas son objetos de la clase UIStoryboardSegue, que se introdujo por primera vez en iOS 5. y otras categorías de objetos.
La diferencia es que dichos objetos no se pueden crear ni utilizar directamente. Sin embargo, puede especificar las propiedades de la transformación y luego proporcionarlas cuando la transformación esté a punto de ocurrir para lograr el objetivo. El marco UIKit proporciona una serie de transiciones predefinidas con transiciones animadas predeterminadas, que incluyen: transiciones push (incluidos controladores de navegación para aplicaciones), transiciones modales con selecciones animadas y transiciones emergentes. En casos más avanzados, las transiciones predeterminadas del SDK de iOS pueden no ser suficientes, por lo que los desarrolladores deben implementar sus segmentos personalizados. Crear una transición personalizada no es difícil ya que forma parte de las técnicas de programación estándar de iOS. De hecho, solo necesitas generar una subclase de UIStoryboardSegue y sobrecargar un método llamado realizar. La lógica de la animación personalizada debe implementarse en este método de ejecución. El desarrollador también debe programar los activadores que cambian acciones de un controlador de vista a otro y viceversa, lo cual es un paso estándar. En este tutorial, mi objetivo es mostrarle cómo implementar una transición personalizada e introducir varios aspectos del concepto a través de una sencilla aplicación de demostración. El conocimiento sobre la creación de transiciones personalizadas puede guiarlo.
El camino hacia el desarrollo de aplicaciones más potentes. Además, las transiciones personalizadas también ayudan a maximizar la experiencia del usuario y desarrollar aplicaciones hermosas y llamativas. Si está interesado en aprender lo que acabo de decir, exploremos todos los detalles y secretos de las transiciones personalizadas en este tutorial.
Descripción general de la aplicación A diferencia de mi tutorial anterior donde proporcioné un proyecto inicial, este tutorial creará una aplicación desde cero. De hecho, hice esto a propósito porque algunas partes importantes del proyecto requerían Interface Builder, así que sentí que hacerlo paso a paso desde el principio le permitiría ver los detalles.
Como dije antes, desarrollaremos una aplicación muy sencilla en la que crearemos dos transiciones personalizadas. Cabe señalar de antemano que nuestra aplicación de demostración tendrá tres controladores de vista, lo que significa que hay tres escenas y tres clases relacionadas en el generador de interfaces. Por defecto, el primero lo crea Xcode, por lo que sólo necesitamos agregar dos más. Crearemos una transición personalizada que navegue desde el primer controlador de vista hasta el segundo controlador de vista.
(Y vuelve), y del primero al tercero (Y vuelve). No hemos agregado ninguna conexión entre el segundo y el tercer controlador de vista.
Por lo tanto, necesitamos crear dos transformaciones personalizadas. Porque para incluir el retorno, cada transición requiere la creación de dos clases correspondientes (entonces, * * * cuatro): En la primera clase, implementaremos la transición del primer controlador de vista al otro controlador de vista. Toda la lógica personalizada. La segunda clase implementa la lógica de regresar al primer controlador de vista, en otras palabras, implementa una secuencia de despliegue. Hablaremos sobre deshacer la transición más adelante, pero por ahora sólo debemos recordar que esta es la transición que nos devuelve al controlador de vista anterior.
El controlador de vista en sí no tiene nada que ver con eso. Usaremos una etiqueta para representar el nombre del controlador de vista, y cada uno tendrá un color de fondo diferente para que podamos ver la transición (sí, esta será una aplicación colorida). El primer y segundo controlador de vista también tendrán etiquetas adicionales donde se mostrarán mensajes personalizados de otros controladores de vista.
Finalmente, cuando ocurran las siguientes acciones, se producirá la transición
Artículo 2: API de animación UIView universal Swift Uso de la API de animación UIView universal Swift.
De forma predeterminada, los lectores de este artículo podrán escribir animaciones básicas.
Explicación de parámetros
*Si la explicación es incorrecta, indíquelo, gracias*
1 Duración: tiempo de ejecución de la animación.
2 Retraso: tiempo de ejecución del retraso de la animación.
3 opciones:
. Repetir: la animación se ejecuta repetidamente para siempre.
. Autoreverse: una vez finalizada la animación, continúe realizando el comportamiento opuesto. Esta propiedad sólo se puede utilizar con . Atributos duplicados.
Curva Lineal: La animación realiza un movimiento lineal.
. CurveEaseIn: la animación comienza lentamente y luego se acelera gradualmente.
CurveEaseOut: La animación comienza rápidamente y termina lentamente.
. CurveEaseInOut: la animación comienza lentamente, luego se acelera y se ralentiza antes de finalizar. Transición Ninguna: Sin animación de transición.
. TransitionFlipFromTop: invierte la animación desde arriba alrededor del eje horizontal. TransitionFlipFromBottom: invierte la animación desde abajo alrededor del eje horizontal.
. TransitionFlipFromLeft: invierte la animación desde la izquierda alrededor del eje vertical.
. TransitionFlipFromRight: invierte la animación alrededor del eje vertical desde la derecha.
. TransitionCurlUp: Animación para pasar páginas de abajo hacia arriba.
. TransitionCurlDown: Animación para pasar páginas de arriba a abajo.
. TransitionCrossDissolve: la vista se disuelve y desaparece, mostrando una nueva animación de vista.
4 usandoSpringWithDamping: Resistencia del resorte, el rango de valores es 0.0-1.0 Cuanto menor es el valor, más obvio es el efecto de vibración del "resorte".
5inicialSpringVelocity: la velocidad inicial de la animación (pt/s). Cuanto mayor sea el valor, más rápida será la velocidad inicial. Pero cabe señalar que si la velocidad inicial es alta, el rebote se producirá en poco tiempo. Animación ordinaria
animateWithDuration:delay:options:animation:complete:class func animateWithDuration(_ length:NSTimeInterval,
retraso de retardo: NSTimeInterval,
opciones: UIViewAnimationOptions ,
Animación animada: ()->Void,
Finalización completa: ((Bool)->Void))
Uso especificado La duración, Los controladores de retraso, opciones y finalización animan los cambios en una o más vistas.
Crear una animación fija para una o más vistas según los parámetros correspondientes (la traducción es una opinión puramente personal, por favor indicar si hay algún error).
animateWithDuration:delay:usingspringwithminding:velocidad inicial del resorte:opciones:animation:complete:
clase func animateWithDuration(_ duración:NSTimeInterval,
retraso de retardo: NSTimeInterval ,
Utilice un resorte con amortiguación en: CG float,
Velocidad inicial del resorte: CGFloat,
opciones: UIViewAnimationOptions,
Animación Animación: ()->Void,
Finalizar finalización: ((Bool)->Void))
Utiliza una curva de tiempo que corresponde al movimiento físico del resorte para realizar la vista. animación.
Crear una animación elástica de una vista basada en los parámetros correspondientes (similar a un resorte, la traducción es puramente una opinión personal, por favor indique si hay algún error)
La La imagen está tomada del blog de Song, solo para que quede más claro y mostrar los diferentes efectos de llamar a las dos API.
Comparación de curvas de movimiento entre la animación de primavera y la animación ordinaria:
Efectos de animación de la animación de primavera, animación fácil, animación lineal;
Animación de transición
transitionWithView:duration:options:animations:completion:class func TransitionWithView(_ view:ui view,
Duración de la duración: NSTimeInterval,
opciones de opciones: UIViewAnimationOptions,
Animación de animación: (()->Void),
Finalización completa: ((Bool)->Void))
Según lo especificado, las vistas del contenedor crean animaciones de transición. . Construya una animación de transición para la vista especificada (la traducción es puramente personal, indique si hay algún error) TransitionFromview:to view:duration:options:completion:
class func TransitionFromView(_ from view: vista de interfaz de usuario,
p>toView toView: UIView,
Duración: NSTimeInterval,
opciones: UIViewAnimationOptions,
Completar: (( Bool) ->Void))
Crea una animación de transición entre vistas especificadas utilizando los parámetros dados.
Construya una animación de transición entre dos vistas determinadas (la traducción es puramente una opinión personal, indíquela si hay algún error)
Lo anterior es la API de animación básica de la animación UIView Esto es realmente práctico. Es muy simple, solo comprenda el significado de los diferentes parámetros.
Capítulo 3: Desarrollo y aprendizaje de la animación central de iOS, conceptos básicos de la animación central
Animación básica (CABasicAnimation)
Animación de fotogramas clave (CAKeyframeAnimation)
Grupo de animación
Animación de transición-transición
animación de transición de vista dual-ui
1. Conceptos básicos de la animación central
p>
1. Importe el marco QuartzCore.framework.
Pasos de desarrollo
1). Inicialice un objeto de animación y establezca algunas propiedades relacionadas con la animación.
Muchas propiedades en CALayer se pueden animar usando CAAnimation, incluyendo: opacidad, posición, transformación, límite, contenido, etc. (Puede buscar en la documentación de la API: CALayer Animatable Properties).
3). Agregue el objeto de animación a la capa (CALayer) e inicie la animación.
4) Agregue animación a la capa (CALayer) llamando a addAnimation:forKey de CALayer, para que se pueda activar la animación. Puede detener las animaciones en una capa llamando a removeAnimationForKey.
5).El proceso de ejecución de la animación de CoreAnimation es una operación en segundo plano y no bloqueará el hilo principal.
2. Propiedades
1). Duración: la duración de la animación.
2).repeatCount: Número de repeticiones (HUGE_VALF, MAX FLOAT repetición ilimitada).
3).Duración de la repetición: tiempo de repetición (rara vez se usa)
4).removedOnCompletion: el valor predeterminado es Sí. De forma predeterminada, las animaciones se eliminan de la capa después de la ejecución.
5).Modo de relleno
6).biginTime
7).timingFunction: Función de control de velocidad para controlar el ritmo de la animación.
8). Representante
Segundo, Cabasiimagination (Cabasiimagination)
Si solo implementa el efecto de animación de cambios de atributos simples, puede usar el bloque UIView Animación. reemplaza la animación básica.
1. Descripción del atributo
- fromValue: valor inicial de keyPath del valor del atributo correspondiente de keyPath.
-to value: El valor final del atributo correspondiente de la ruta clave.
2. Descripción del proceso de animación:
-Con la animación, durante la duración de la animación, el valor del atributo correspondiente de keyPath cambia gradualmente de Valor a valor.
- El contenido de keyPath es la propiedad de animación animable de CALayer.
-Si fillMode = kCAFillModeForwards, removeoncomplementation = No, luego de que finalice la animación, la capa siempre mostrará el estado después de que se ejecute la animación, pero en esencia, los valores de los atributos de la capa aún están los valores iniciales antes de que se ejecute la animación, realmente no han cambiado.
3. Implementación del código
El desplazamiento debe considerar la cuestión del establecimiento del punto objetivo.
1. Encapsule todos los métodos de animación en una clase.
MyCAHelper.h
#Importar
#Importar
#Definir kCAHelperAlphaAnimation @ "opacidad";? //Desvanecimiento de la animación #Definir kcahelperscaleanization @ " transform . scale "; // Escalar animación
# Definir kCAHelperRotationAnimation @ " transform .rotation " // Animación de rotación
# Definir kCAHelperPositionAnimation; @ " position ";// Animación de posición de traducción
@interface MyCAHelper: NSObject
#pragma mark: el método de llamada unificado de animación básica
+(cabasic animación *)myBasicAnimationWithType:(ns string *)duración del tipo de animación:(intervalo de tiempo cf)duración desde:(ns value *)desde
hasta:(NSValue *)hasta
Respuesta automática: ( BOOL) respuesta automática;
#pragma mark-método de animación de fotogramas clave
# pragmark vibración de animación
+ (CAKeyframeAnimation
*) myKeyShakeAnimationWithDuration: duración (intervalo de tiempo cf)
Ángulo: ángulo (CGFloat)
Recuento de repeticiones: (CGFloat) recuento de repeticiones;
#Marca de comentario Mejor animación de ruta
+(CAKeyframeAnimation *)mykeypathanimationwithdration:(cftime intervalo)duración ruta:(UIBezierPath *)ruta;
# pragmark animación de simulación elástica
+ (CAKeyframeAnimation * )myKeyBounceAnimationFrom:(punto CG)desde
Hasta:(CGPoint)a
Duración:(CFTimeInterval)Duración;
@end
MyCAHelper.m
#Import "MyCAHelper.h"
@Implement MyCAHelper
#pragma mark: método de llamada unificado para animaciones básicas
+(animación cabásica *)myBasicAnimationWithType:(ns string *)duración del tipo de animación:(intervalo de tiempo cf)duración
Desde: (NSValue *)desde
Hasta: (NSValue * ) Para
Respuesta automática: (BOOL)Respuesta automática
{
// 1. Crear una instancia de un objeto de animación CA.
animación cabañas * anim =[animación de animación cabañas con ruta clave:tipo de animación];
//// 2. Establecer propiedades de animación
[anim set duración: duración];
[anim set from value:from];
[anim setto value:to];
[anim setAutoreverses:auto revereses] ;
Volver a la animación;
}
Método de animación de fotogramas clave de #pragma
# animación de vibración de pragmark
+ (CAKeyframeAnimation
*)myKeyShakeAnimationWithDuration:(intervalo de tiempo cf)duración
Ángulo:(CGFloat)ángulo
Recuento de repeticiones: (CGFloat)recuento de repeticiones
p>{
// 1. Inicializar la instancia del objeto de animación
CAKeyframeAnimation * anim =[CAKeyframeAnimation
animationWithKeyPath:@ " transform . rotación "] ;
// 2. Establecer propiedades de animación
[anim set length:duration];
[anim setValues:@[@(angle) ),@( -Angle), @(angle)]];
[anim setRepeatCount:repeatCount];
Volver a la animación;
}
#Pragma marca la animación de la ruta Bezier
+(CAKeyframeAnimation *)myKeyPathAnimationWithDuration:(cftime intervalo)Duración de la ruta:(UIBezierPath *)ruta
{
// 1. Inicializar la instancia del objeto de animación
CAKeyframeAnimation * anim =[CAKeyframeAnimation
animationWithKeyPath:@ " position "];
// 2. Establecer Propiedades de animación
[anim set length:duration];