CoreAnimation Espace de noms

Classes

Structures

Interfaces

Énumérations

Remarques

CoreAnimation est au cœur de l’interface utilisateur de l’iPhone. Les API de cet espace de noms vous permettent d’accéder à l’infrastructure d’animation sous-jacente qui alimente l’UIKit.

Les contrôles UIKit sont implémentés par-dessus CoreAnimation, qui s’interface directement avec OpenGL et CoreGraphics pour fournir un rendu accéléré matériel.

Chacun UIView d’eux est soutenu par un CALayer qui est accessible via la Layer propriété . Lorsque vous dessinez en remplaçant la méthode M:UIKit.UIView.Draw(System.Drawing.RectangleF), vous dessinez dans la couche CoreAnimation.

Tout comme uiView peut contenir d’autres UIViews, les calayers peuvent contenir d’autres instances CALayer. Vous pouvez insérer des couches enfants dans une couche en appelant AddSublayer(CALayer), M:CoreAnimation.CALayer.InsertSublayer(CoreAnimation.CALayer,int), InsertSublayerBelow(CALayer, CALayer), InsertSublayerAbove(CALayer, CALayer) ou supprimez la couche à l’aide de M:CoreAnimation.CALayer.RemoveFromSuperLayer(). En outre, il existe différents types de caLayers fournis par le système d’exploitation et vous pouvez créer les vôtres en sous-classant l’une des couches fournies par le système : CALayer, CATiledLayer, CAScrollLayerCATextLayer, CAReplicatorLayer, CAShapeLayer, , CAGradientLayer, , CATransformLayeret CAEAGLLayerCAEmitterLayer.

Les couches conservent le contenu que vous y dessinez, contrairement à d’autres boîtes à outils, il n’est pas nécessaire d’implémenter une méthode de repeint pour répondre aux événements exposés par la région. Si vous souhaitez mettre à jour le contenu de la couche, vous devez appeler la méthode M:CoreAnimation.CALayer.SetNeedsDisplay() qui déclenche un appel à la DrawInContext(CGContext) méthode que vous pouvez remplacer.

Vous pouvez personnaliser le rendu de la couche en définissant la Delegate propriété de votre couche pour qu’elle pointe vers une instance d’une CALayerDelegate sous-classe.

Vous pouvez appliquer des transformations 3D à vos couches en définissant la Transform propriété et vous pouvez également contrôler la transformation 3D appliquée aux sous-couches en définissant la SublayerTransform propriété . Si vous utilisez sublayerTransform, vous pouvez également utiliser la ZPosition propriété pour lui attribuer une position d’axe Z. Cela est utile pour effectuer des rendus de perspective.

Les couches fournissent les composants accélérés matériels nécessaires à CoreAnimation pour effectuer son travail efficacement. En plus de cette fonctionnalité, CoreAnimation fournit un ensemble d’API pour animer les couches.

Avant iOS 4, les animations étaient spécifiées en tant que transactions : les développeurs d’applications crochetaient la spécification de leurs animations entre les appels à M:UIKit.UIView.BeginAnimations* et M:UIKit.UIView.CommitAnimations*. La réaction aux événements d’animation (par exemple, la continuation une fois l’animation terminée) nécessite l’utilisation d’un objet délégué et de sélecteurs personnalisés. Cette technique est toujours disponible, mais Apple recommande l’utilisation d’animations « basées sur des blocs » dans les applications modernes. Dans la terminologie C#, il s’agit d’animations « basées sur des délégués », où le délégué (ou la fonction anonyme) est de type T:Foundation.NSAction. En outre, Xamarin.iOS fournit des wrappers asynchrones pour les fonctions d’animation couramment utilisées, afin que les développeurs d’applications puissent utiliser les fonctionnalités de async-await C# 5+.

L’exemple suivant illustre les différentes techniques :

//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");
}          

Ces techniques basées sur UIKit doivent satisfaire la plupart des cas d’usage d’animation (en outre, Sprite Kit fournit à la fois l’animation et la modélisation physique appropriées pour les cas d’utilisation à fréquence d’images élevée tels que les jeux). Toutefois, en plus de ces techniques basées sur UIKit, les développeurs d’applications qui créent leurs propres CALayers ont accès aux techniques d’animation de niveau inférieur : Animations implicites et Animations explicites.

N.B. : Les animations de couche sont désactivées dans UIViews, sauf dans les UIView blocs d’animation. (Voir la discussion ci-dessous.)

Les animations implicites ont lieu lorsque les développeurs d’applications modifient une ou plusieurs propriétés dans une couche et CoreAnimation applique ces modifications progressivement en interpolant les valeurs de la valeur actuelle vers la nouvelle valeur sur une période prédéterminée (sauf si elles sont configurées, l’exécution des animations prend 0,25 seconde).

//
// 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;
}

Les développeurs d’applications qui souhaitent plus de contrôle peuvent utiliser l’animation explicite. Pour ce faire, ils créent une instance de l’une des classes CAPropertyAnimationd’animation , CATransition, CAAnimationGroupCABasicAnimation ou CAKeyFrameAnimation. L’animation est attachée à une couche, en appelant la AddAnimation(CAAnimation, String) méthode .

Contrairement aux animations implicites qui se produisent en réaction aux modifications apportées aux propriétés de la couche, les animations explicites ne modifient pas les propriétés de vos objets. Au lieu de cela, ils modifient les propriétés d’une copie de votre graphique de scène stocké dans le PresentationLayer. Cela signifie que les modifications que vous apportez aux objets dans le cadre d’une animation explicite ne sont pas permanentes. Une fois l’animation terminée, les objets sont rendus avec les valeurs qui se trouvent toujours dans le modèle.

//
// 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");

Les animations basées sur des couches sont désactivées par UIViews, sauf dans les UIView blocs d’animation. Les animations basées sur des couches dans ces blocs ignorent la durée des blocs et fonctionnent à leur propre durée spécifiée, soit la valeur par défaut implicite de 0,25 seconde, soit une longueur explicite. Cela est illustré dans l’exemple suivant, dans lequel la UIView durée du bloc d’animation est de 1,0, mais en réalité, l’animation d’opacité implicite basée sur la couche se termine dans 0,25 secondes et le re-positionnement s’exécute pendant 10 secondes.

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");
});