CoreAnimation Espacio de nombres

Clases

Estructuras

Interfaces

Enumeraciones

Comentarios

CoreAnimation está en el núcleo de la interfaz de usuario de iPhone. Las API de este espacio de nombres proporcionan acceso al marco de animación subyacente que impulsa uiKit.

Los controles UIKit se implementan sobre CoreAnimation, que interactúa directamente con OpenGL y CoreGraphics para proporcionar una representación acelerada por hardware.

Cada UIView uno está respaldado por un CALayer objeto al que se accede a través de la Layer propiedad . Al dibujar reemplazando el método M:UIKit.UIView.Draw(System.Drawing.RectangleF), se dibuja en la capa CoreAnimation.

Al igual que uiView puede contener otras uiView, CALayers puede contener otras instancias de CALayer. Puede insertar capas secundarias en una capa llamando a AddSublayer(CALayer), M:CoreAnimation.CALayer.InsertSublayer(CoreAnimation.CALayer,int), InsertSublayerBelow(CALayer, CALayer)InsertSublayerAbove(CALayer, CALayer) o quitar la capa mediante M:CoreAnimation.CALayer.RemoveFromSuperLayer()). Además, hay varios tipos de CALayers proporcionados por el sistema operativo y puede crear el suyo propio mediante la subclase de una de las capas proporcionadas por el sistema: CALayer, , CATiledLayer, CAScrollLayerCATextLayer, , CAShapeLayerCAReplicatorLayer, CATransformLayerCAGradientLayer, CAEAGLLayer y .CAEmitterLayer

Las capas conservarán el contenido que dibuje en ellos, a diferencia de otros kits de herramientas, no es necesario implementar un método de reintentos para responder a eventos expuestos por regiones. Si desea actualizar el contenido de la capa, debe llamar al método M:CoreAnimation.CALayer.SetNeedsDisplay() que desencadenará una llamada al DrawInContext(CGContext) método que puede invalidar.

Puede personalizar la representación de capas estableciendo la Delegate propiedad de la capa para que apunte a una instancia de una CALayerDelegate subclase.

Puede aplicar transformaciones 3D a las capas estableciendo la Transform propiedad y también puede controlar la transformación 3D aplicada a las subcapas estableciendo la SublayerTransform propiedad . Si usa SublayerTransform, también puede usar la ZPosition propiedad para darle una posición del eje Z. Esto resulta útil para realizar representaciones de perspectiva.

Las capas proporcionan los componentes acelerados de hardware necesarios para que CoreAnimation realice su trabajo de forma eficaz. Además de esta funcionalidad, CoreAnimation proporciona un conjunto de API para animar capas.

Antes de iOS 4, las animaciones se especificaban como transacciones: los desarrolladores de aplicaciones entretendrían la especificación de sus animaciones entre las llamadas a M:UIKit.UIView.BeginAnimations* y M:UIKit.UIView.CommitAnimations*. Reaccionar a eventos de animación (como la continuación después de que finalice la animación) requiere el uso de un objeto delegado y selectores personalizados. Esta técnica sigue estando disponible, pero Apple recomienda el uso de animaciones "basadas en bloques" en aplicaciones modernas. En la terminología de C#, se denominarían animaciones "basadas en delegados", donde el delegado (o función anónima) es de tipo Foundation.NSAction. Además, Xamarin.iOS proporciona contenedores asincrónicos para las funciones de animación que se usan habitualmente, por lo que los desarrolladores de aplicaciones pueden usar las instalaciones de async-await C# 5+.

En el ejemplo siguiente se muestran las distintas técnicas:

//Transaction-based (recommended only for iOS < 4)
UIView.BeginAnimations("transactional");
UIView.SetAnimationDuration(2.0);
imgView.Layer.Position = newPosition;
UIView.SetAnimationDelegate (this);
UIView.SetAnimationDidStopSelector (new Selector ("positionAnimationFinished:"));
UIView.CommitAnimations();
//...etc...
[Export("positionAnimationFinished:")]
void SlideStopped ()
{
    Console.WriteLine("Animation finished; logic continues here");
}

//Block-based, with animations in lambda, continuation as delegate (either technique works in either position)
UIView.Animate(2.0, () => imgView.Layer.Position = newPosition, SlideStopped);
//...etc...
void SlideStopped() { 
     Console.WriteLine("Animation finished; logic continues here");
}

async void MyAnimateAsync {
    await UIView.AnimateAsync(2.0, () => imgView.Layer.Position = newPosition);
    Console.WriteLine("Animation finished; logic continues here");
}          

Estas técnicas basadas en UIKit deben satisfacer la mayoría de los casos de uso de animación (también, Sprite Kit proporciona animación y modelado físico adecuado para casos de uso de alta velocidad de fotogramas, como juegos). Sin embargo, además de estas técnicas basadas en UIKit, los desarrolladores de aplicaciones que crean sus propios CALayertienen acceso a técnicas de animación de nivel inferior: animaciones implícitas y animaciones explícitas.

N.B.: Las animaciones de capa están deshabilitadas en s excepto en UIViewUIView bloques de animación. (Vea la explicación a continuación).

Las animaciones implícitas tienen lugar cuando los desarrolladores de aplicaciones cambian una o varias de las propiedades de una capa y CoreAnimation aplicará esos cambios gradualmente interpolando los valores del valor actual al nuevo valor durante un período predeterminado de tiempo (a menos que se configure, las animaciones tardarán 0,25 segundos en ejecutarse).

//
// The following method sets the opacity to zero on the image's Layer
// and will trigger a 0.25 animation to vanish the image by setting the
// opacity to zero
//
void HideImage (UIImageView image)
{
    view.Layer.Opacity = 0;
}

Los desarrolladores de aplicaciones que quieran tener más control pueden usar animación explícita. Para ello, crean una instancia de una de las clases CAPropertyAnimationde animación , CATransition, CAAnimationGroupCABasicAnimation o CAKeyFrameAnimation. La animación se adjunta a una capa mediante una llamada al AddAnimation(CAAnimation, String) método .

A diferencia de las animaciones implícitas que se producen en reacción a los cambios en las propiedades de la capa, las animaciones explícitas no modifican las propiedades de los objetos. En su lugar, modifican las propiedades de una copia del gráfico de escena almacenado en .PresentationLayer Esto significa que los cambios realizados en los objetos como parte de una animación explícita no son permanentes. Una vez finalizada la animación, los objetos se representarán con los valores que todavía están en el modelo.

//
// Notice that we set the final position for the layer before we start
// animating from 0 to 120 since this is an explicit animation and we
// do not want to see the object "jump" back to 0, 0 at the end of
// the animation
//
layer.Position = new PointF (0, 120);
var positionAnimation = (CAKeyFrameAnimation) CAKeyFrameAnimation.FromKeyPath ("position.y");
positionAnimation.Values = new NSNumber [] { 0, 30, 60, 120 };
layer.AddAnimation (positionAnimation, "myAnimation");

Las animaciones basadas en capas están deshabilitadas por UIViews, excepto dentro de los bloques de UIView animación. Las animaciones basadas en capas dentro de estos bloques omiten la duración de los bloques y funcionan con su propia duración especificada, ya sea el valor predeterminado implícito de 0,25 segundos o una longitud explícita. Esto se muestra en el ejemplo siguiente, en el que la UIView duración del bloque de animación es de 1,0, pero en realidad, la animación implícita de opacidad basada en capas termina en 0,25 segundos y la relocalización se ejecuta durante 10 segundos.

UIView.AnimateAsync(1.0, () => {
	imgView.Layer.Opacity = 0.0f;

	var theAnim = CABasicAnimation.FromKeyPath("position");
	theAnim.From = NSObject.FromObject(firstPosition);
	theAnim.To =  NSObject.FromObject(secondPosition);
	theAnim.Duration = 10.0;

	imgView.Layer.AddAnimation(theAnim, "AnimateFrame");
});