CoreAnimation Espace de noms

L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.

Classes

CAAction	Interface implémentée par des objets qui participent à des animations coordonnées par un CALayer.
CAAnimation	Classe de base pour les animations.
CAAnimationDelegate	Classe déléguée pour la classe CAAnimation.
CAAnimationDelegate_Extensions	Méthodes d’extension à la CAAnimationDelegate classe .
CAAnimationGroup	Regroupe et orchestre plusieurs animations.
CAAnimationStateEventArgs	Fournit des données pour l’événement E:CoreAnimation.CAAnimationStateEventArgs.AnimationStopped.
CABasicAnimation	Animations basées sur une image clé unique.
CAContentsFormatExtensions	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CADisplayLink	Objet de synchronisation entre vos animations et l’actualisation de l’affichage.
CAEAGLLayer	Couche utilisée pour afficher le contenu OpenGL.
CAEmitterBehavior	Définit le comportement d’un émetteur de système de particules.
CAEmitterCell	Source de particules émises par une CAEmitterLayer instance.
CAEmitterLayer	Émetteur de système de particules. Les types de particules sont définis par CAEmitterCell.
CAFillMode	Constantes utilisées pour la propriété FillMode dans CAAnimation et CALayer, utilisées pour contrôler le comportement des objets une fois l’animation terminée.
CAGradientLayer	Couche qui restitue un dégradé sur son arrière-plan.
CAGradientLayerTypeExtensions	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CAKeyFrameAnimation	Prise en charge des animations basées sur des images clés.
CALayer	Les couches contiennent les images qui sont rendues à l’écran.
CALayerDelegate	Classe déléguée pour CALayer.
CALayerDelegate_Extensions	Méthodes d’extension à l’interface ICALayerDelegate pour prendre en charge toutes les méthodes du CALayerDelegate protocole.
CAMediaTiming	Fournit un système de minutage hiérarchique, avec prise en charge de la répétition et du séquencement.
CAMediaTimingFunction	Définit le rythme d’une animation.
CAMetalLayer	CALayer rendu à l’aide de fonctions Metal.
CAPropertyAnimation	Animation qui peut animer des propriétés d’objet.
CAReplicatorLayer	Couche qui réplique une couche existante, avec certains attributs (couleur, transformation) modifiés.
CAScrollExtensions	Méthodes d’extension pour CAScroll.
CAScrollLayer	Couche utilisée pour afficher les parties d’une autre couche.
CAShapeLayer	Dessine une courbe plus bezier et compose le résultat avec sa première sous-couche.
CASpringAnimation	Animation de ressort avec raideur, masse et amortissement.
CATextLayer	Mise en forme de texte simple et rendu du texte normal ou attribué.
CATextLayerAlignmentModeExtensions	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CATextLayerTruncationModeExtensions	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CATiledLayer	Couche dont le contenu peut être fourni de manière asynchrone et avec plusieurs niveaux de détail.
CATransaction	Framework pour synchroniser plusieurs opérations de transformation.
CATransformLayer	Couche de composition 3D.
CATransition	Animations de transition pour une couche.
CAValueFunction	Classe utilisée pour appliquer des fonctions aux valeurs de propriété pendant une animation.

Structures

CATransform3D

Transformation 3D.

Interfaces

ICAAction	Interface représentant les méthodes requises (le cas échéant) du protocole CAAction.
ICAAnimationDelegate	Délégué pour répondre aux événements de cycle de vie des animations.
ICALayerDelegate	Interface représentant les méthodes requises (le cas échéant) du protocole CALayerDelegate.
ICAMediaTiming	Interface représentant les méthodes requises (le cas échéant) du protocole CAMediaTiming.
ICAMetalDrawable	Interface qui définit un protocole pour une mémoire tampon d’affichage au niveau de la couche métallique.

Énumérations

CAContentsFormat	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CACornerMask	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CAEdgeAntialiasingMask	Indicateurs utilisés pour déterminer le côté d’une couche qui doit être anticrénelé.
CAGradientLayerType	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CAScroll	Énumère les directions de défilement.
CATextLayerAlignmentMode	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.
CATextLayerTruncationMode	L’espace de noms CoreAnimation fournit un accès à l’infrastructure d’animation sous-jacente qui alimente UIKit.

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

Basé sur des blocs

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

Asynchrone

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