CoreAnimation Namespace

O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.

Classes

CAAction	Uma interface implementada por objetos que participam de animações coordenadas por um CALayer.
CAAnimation	Classe base para animações.
CAAnimationDelegate	Classe delegada para a classe CAAnimation.
CAAnimationDelegate_Extensions	Métodos de extensão para a CAAnimationDelegate classe .
CAAnimationGroup	Agrupa e orquestra várias animações.
CAAnimationStateEventArgs	Fornece dados para o evento E:CoreAnimation.CAAnimationStateEventArgs.AnimationStopped.
CABasicAnimation	Animações baseadas em quadro-chave único.
CAContentsFormatExtensions	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CADisplayLink	Objeto de sincronização entre suas animações e a atualização de exibição.
CAEAGLLayer	Camada usada para renderizar conteúdo OpenGL.
CAEmitterBehavior	Define o comportamento de um emissor do sistema de partículas.
CAEmitterCell	Uma fonte de partículas emitida por uma CAEmitterLayer instância.
CAEmitterLayer	Um emissor do sistema de partículas. Os tipos de partículas são definidos por CAEmitterCell.
CAFillMode	Constantes usadas para a propriedade FillMode em CAAnimation e CALayer, usadas para controlar o comportamento de objetos após a conclusão da animação.
CAGradientLayer	Camada que renderiza um gradiente sobre sua tela de fundo.
CAGradientLayerTypeExtensions	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CAKeyFrameAnimation	Suporte à animação baseada em quadro-chave.
CALayer	As camadas mantêm as imagens renderizadas na tela.
CALayerDelegate	Classe delegada para o CALayer.
CALayerDelegate_Extensions	Métodos de extensão para a ICALayerDelegate interface para dar suporte a todos os métodos do CALayerDelegate protocolo.
CAMediaTiming	Fornece um sistema de tempo hierárquico, com suporte para repetição e sequenciamento.
CAMediaTimingFunction	Define o ritmo de uma animação.
CAMetalLayer	Um CALayer que é renderizado usando funções De metal.
CAPropertyAnimation	Uma animação que pode animar as propriedades do objeto.
CAReplicatorLayer	Uma camada que replica uma camada existente, com alguns atributos (cor, transformação) alterados.
CAScrollExtensions	Métodos de extensão para CAScroll.
CAScrollLayer	Camada usada para mostrar partes de outra camada.
CAShapeLayer	Desenha uma curva de bézier e compõe o resultado com sua primeira subcamadas.
CASpringAnimation	Uma animação spring com rigidez, massa e umidade.
CATextLayer	Leigo de texto simples e renderização de texto regular ou atribuído.
CATextLayerAlignmentModeExtensions	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CATextLayerTruncationModeExtensions	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CATiledLayer	Camada cujo conteúdo pode ser fornecido de forma assíncrona e com vários níveis de detalhes.
CATransaction	Estrutura para sincronizar várias operações de transformação.
CATransformLayer	Camada de composição 3D.
CATransition	Animações de transição para uma camada.
CAValueFunction	Classe usada para aplicar funções a valores de propriedade durante uma animação.

Estruturas

CATransform3D

Transformação 3D.

Interfaces

ICAAction	Interface que representa os métodos necessários (se houver) do protocolo CAAction.
ICAAnimationDelegate	Delegar para responder a eventos de ciclo de vida de animação.
ICALayerDelegate	Interface que representa os métodos necessários (se houver) do protocolo CALayerDelegate.
ICAMediaTiming	Interface que representa os métodos necessários (se houver) do protocolo CAMediaTiming.
ICAMetalDrawable	Interface que define um protocolo para um buffer de exibição na camada de metal.

Enumerações

CAContentsFormat	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CACornerMask	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CAEdgeAntialiasingMask	Sinalizadores usados para determinar qual lado de uma camada deve ser suavizado.
CAGradientLayerType	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CAScroll	Enumera as direções de rolagem.
CATextLayerAlignmentMode	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.
CATextLayerTruncationMode	O namespace CoreAnimation fornece acesso à estrutura de animação subjacente que alimenta o UIKit.

Comentários

CoreAnimation está no centro da interface do usuário do iPhone. As APIs neste namespace fornecem acesso à estrutura de animação subjacente que alimenta o UIKit.

Os controles UIKit são implementados na parte superior do CoreAnimation, que faz interfaces diretamente com o OpenGL e o CoreGraphics para fornecer renderização acelerada por hardware.

Cada UIView um é apoiado por um CALayer que é acessado por meio da Layer propriedade . Ao desenhar substituindo o método M:UIKit.UIView.Draw(System.Drawing.RectangleF), você está desenhando na camada CoreAnimation.

Assim como o UIView pode conter outras UIViews, CALayers pode conter outras instâncias caLayer. Você pode inserir camadas filho em uma camada chamando AddSublayer(CALayer), M:CoreAnimation.CALayer.InsertSublayer(CoreAnimation.CALayer,int), InsertSublayerBelow(CALayer, CALayer)ou InsertSublayerAbove(CALayer, CALayer) remova a camada usando M:CoreAnimation.CALayer.RemoveFromSuperLayer(). Além disso, há vários tipos de CALayers fornecidos pelo sistema operacional e você pode criar o seu próprio subclasse de uma das camadas fornecidas pelo sistema: CALayer, , CATiledLayer, CATextLayer, CAScrollLayer, CAReplicatorLayer, CAGradientLayerCAShapeLayer, CAEAGLLayerCATransformLayere CAEmitterLayer.

As camadas manterão o conteúdo que você desenha neles, ao contrário de outros kits de ferramentas, não é necessário implementar um método repintar para responder a eventos expostos por região. Se você quiser atualizar o conteúdo da camada, deverá chamar o método M:CoreAnimation.CALayer.SetNeedsDisplay() que disparará uma chamada para o DrawInContext(CGContext) método que você pode substituir.

Você pode personalizar a renderização de camada definindo a Delegate propriedade da camada para apontar para uma instância de uma CALayerDelegate subclasse.

Você pode aplicar transformações 3D às camadas definindo a Transform propriedade e também pode controlar a transformação 3D aplicada a subcaminhos definindo a SublayerTransform propriedade . Se você usar a SublayerTransform, também poderá usar a ZPosition propriedade para dar a ela uma posição do eixo Z. Isso é útil para fazer renderizações de perspectiva.

As camadas fornecem os componentes acelerados de hardware necessários para que a CoreAnimation faça seu trabalho com eficiência. Além dessa funcionalidade, o CoreAnimation fornece um conjunto de APIs para animar camadas.

Antes do iOS 4, as animações eram especificadas como transações: os desenvolvedores de aplicativos agrupavam a especificação de suas animações entre chamadas para M:UIKit.UIView.BeginAnimations* e M:UIKit.UIView.CommitAnimations*. Reagir a eventos de animação (como continuação após a conclusão da animação) requer o uso de um objeto delegado e seletores personalizados. Essa técnica ainda está disponível, mas a Apple recomenda o uso de animações "baseadas em bloco" em aplicativos modernos. Na terminologia C#, elas seriam chamadas de animações "baseadas em delegado", em que o delegado (ou função anônima) é do tipo T:Foundation.NSAction. Além disso, o Xamarin.iOS fornece wrappers assíncronos para as funções de animação comumente usadas, para que os desenvolvedores de aplicativos possam usar as instalações do async-await C# 5+.

O exemplo a seguir mostra as diferentes 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");
}

Baseado em bloco

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

Assíncrona

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

Essas técnicas baseadas em UIKit devem satisfazer a maioria dos casos de uso de animação (também, o Sprite Kit fornece animação e modelagem física apropriadas para casos de uso de alta taxa de quadros, como jogos). No entanto, além dessas técnicas baseadas em UIKit, os desenvolvedores de aplicativos que criam seus próprios CALayers têm acesso a técnicas de animação de nível inferior: Animações Implícitas e Animações Explícitas.

N.B.: As animações de camada são desabilitadas em UIViews, exceto em UIView blocos de animação. (Consulte a discussão abaixo.)

As Animações Implícitas ocorrem quando os desenvolvedores de aplicativos alteram uma ou mais das propriedades em uma camada e o CoreAnimation aplicará essas alterações gradualmente interpolando os valores do valor atual para o novo valor em um período predeterminado de tempo (a menos que configurado, as animações levarão 0,25 segundos para serem executadas).

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

Os desenvolvedores de aplicativos que desejam mais controle podem usar Animação Explícita. Para fazer isso, eles criam uma instância de uma das classes CAPropertyAnimationde animação , CATransition, CABasicAnimationCAAnimationGroupou CAKeyFrameAnimation. A animação é anexada a uma camada chamando o AddAnimation(CAAnimation, String) método .

Ao contrário das animações implícitas que ocorrem em reação a alterações nas propriedades da camada, as animações explícitas não alteram as propriedades de seus objetos. Em vez disso, eles alteram as propriedades de uma cópia do grafo de cena armazenado no PresentationLayer. Isso significa que todas as alterações feitas nos objetos como parte de uma animação explícita não são permanentes. Depois que a animação for concluída, os objetos serão renderizados com os valores que ainda estão no 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");

As animações baseadas em camada são desabilitadas por UIViews, exceto em UIView blocos de animação. As animações baseadas em camadas nesses blocos ignoram a duração dos blocos e operam em sua própria duração especificada, seja o padrão implícito de 0,25 segundos ou um comprimento explícito. Isso é mostrado no exemplo a seguir, no qual a UIView duração do bloco de animação é 1,0, mas, na realidade, a animação de opacidade implícita baseada em camada termina em 0,25 segundos e o reposicionamento é executado por 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");
});