Communitygithub.com

ComeOnOliver/skillshub

Guia abrangente para implementar animações em Flutter. Use ao adicionar movimento e efeitos visuais a aplicativos Flutter: animações implícitas (AnimatedContainer, AnimatedOpacity, TweenAnimationBuilder), animações explícitas (AnimationController, Tween, AnimatedWidget/AnimatedBuilder), animações hero (transições de elementos compartilhados), animações escalonadas (sequenciais/sobrepostas) e animações baseadas em física. Inclui fluxo de trabalho para escolher o tipo certo de animação, padrões de implementação e melhores práticas de desempenho e experiência do usuário.

O que é skillshub?

Este skill, **ComeOnOliver/skillshub**, é um guia completo e prático para implementar animações em Flutter, abrangendo desde animações implícitas simples até animações explícitas complexas e baseadas em física. Ele é útil para desenvolvedores que desejam adicionar movimento e efeitos visuais suaves e performáticos a seus aplicativos, oferecendo uma árvore de decisão para escolher o tipo de animação adequado para cada caso, como animações implícitas para propriedades únicas, animações explícitas para controle total do ciclo de vida, animações hero para transições de elementos compartilhados entre telas, animações escalonadas para efeitos sequenciais e animações baseadas em física para movimentos naturais. O skill fornece exemplos de código detalhados, padrões de implementação como AnimatedWidget e AnimatedBuilder, dicas de desempenho e boas práticas, sendo compatível com qualquer plataforma que suporte Flutter, como Android, iOS, web e desktop. Ele funciona organizando o conteúdo em seções claras com exemplos práticos, facilitando a consulta rápida e a aplicação direta no código.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/madteacher/flutter-animations

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Animações Flutter

Visão Geral

Crie animações suaves e performáticas em Flutter usando a abordagem certa para cada caso de uso. Este skill cobre o fluxo de trabalho completo de animação: desde a escolha entre abordagens implícitas/explícitas até a implementação de efeitos complexos como transições hero e animações escalonadas.

Árvore de Decisão do Tipo de Animação

Escolha o tipo de animação certo com base em seus requisitos:

Animações Implícitas - Use quando:

  • Animando uma única propriedade (cor, tamanho, posição)
  • Animações são disparadas por mudanças de estado
  • Não há necessidade de controle refinado

Animações Explícitas - Use quando:

  • Precisa de controle total sobre o ciclo de vida da animação
  • Animando várias propriedades simultaneamente
  • Precisa reagir a mudanças de estado da animação
  • Criando animações ou transições personalizadas

Animações Hero - Use quando:

  • Compartilhando um elemento entre duas telas
  • Criando transições de elementos compartilhados
  • O usuário espera que o elemento "voe" entre rotas

Animações Escalonadas - Use quando:

  • Múltiplas animações devem ser executadas sequencialmente ou sobrepostas
  • Criando efeitos de ondulação ou revelações sequenciais
  • Animando itens de lista em sequência

Animações Baseadas em Física - Use quando:

  • As animações devem parecer naturais/físicas
  • Comportamento de mola, gestos de rolagem
  • Interações arrastáveis

Animações Implícitas

Animações implícitas lidam automaticamente com a animação quando as propriedades mudam. Nenhum controlador necessário.

Widgets Implícitos Comuns

AnimatedContainer - Anima várias propriedades (tamanho, cor, decoração, padding):

AnimatedContainer(
  duration: const Duration(milliseconds: 300),
  curve: Curves.easeInOut,
  width: _expanded ? 200 : 100,
  height: _expanded ? 200 : 100,
  color: _expanded ? Colors.blue : Colors.red,
  child: const FlutterLogo(),
)

AnimatedOpacity - Animação simples de desvanecimento:

AnimatedOpacity(
  opacity: _visible ? 1.0 : 0.0,
  duration: const Duration(milliseconds: 300),
  child: const Text('Olá'),
)

TweenAnimationBuilder - Animação de tween personalizada sem código boilerplate:

TweenAnimationBuilder<double>(
  tween: Tween<double>(begin: 0, end: 1),
  duration: const Duration(seconds: 1),
  builder: (context, value, child) {
    return Opacity(
      opacity: value,
      child: Transform.scale(
        scale: value,
        child: child,
      ),
    );
  },
  child: const FlutterLogo(),
)

Outros widgets implícitos:

  • AnimatedPadding - Animação de padding
  • AnimatedPositioned - Animação de posição (em Stack)
  • AnimatedAlign - Animação de alinhamento
  • AnimatedContainer - Múltiplas propriedades
  • AnimatedSwitcher - Transição cruzada entre widgets
  • AnimatedDefaultTextStyle - Animação de estilo de texto

Melhores Práticas

  • Prefira animações implícitas para casos simples
  • Use curvas apropriadas para movimento natural (veja a classe Curves)
  • Defina curve e duration para comportamento previsível
  • Use o callback onEnd quando necessário
  • Evite animações implícitas aninhadas por desempenho

Animações Explícitas

Animações explícitas fornecem controle total com AnimationController.

Componentes Principais

AnimationController - Controla a animação:

late AnimationController _controller;

@override
void initState() {
  super.initState();
  _controller = AnimationController(
    duration: const Duration(seconds: 2),
    vsync: this,
  );
}

@override
void dispose() {
  _controller.dispose();
  super.dispose();
}

Tween - Interpola entre valores inicial e final:

animation = Tween<double>(begin: 0, end: 300).animate(_controller);

CurvedAnimation - Aplica uma curva à animação:

animation = CurvedAnimation(
  parent: _controller,
  curve: Curves.easeInOut,
);

Padrão AnimatedWidget

Melhor para widgets animados reutilizáveis:

class AnimatedLogo extends AnimatedWidget {
  const AnimatedLogo({super.key, required Animation<double> animation})
    : super(listenable: animation);

  @override
  Widget build(BuildContext context) {
    final animation = listenable as Animation<double>;
    return Center(
      child: Container(
        height: animation.value,
        width: animation.value,
        child: const FlutterLogo(),
      ),
    );
  }
}

Padrão AnimatedBuilder

Melhor para widgets complexos com animações:

class GrowTransition extends StatelessWidget {
  const GrowTransition({
    required this.child,
    required this.animation,
    super.key,
  });

  final Widget child;
  final Animation<double> animation;

  @override
  Widget build(BuildContext context) {
    return Center(
      child: AnimatedBuilder(
        animation: animation,
        builder: (context, child) {
          return SizedBox(
            height: animation.value,
            width: animation.value,
            child: child,
          );
        },
        child: child,
      ),
    );
  }
}

Monitorando o Estado da Animação

animation.addStatusListener((status) {
  switch (status) {
    case AnimationStatus.completed:
      _controller.reverse();
      break;
    case AnimationStatus.dismissed:
      _controller.forward();
      break;
    default:
      break;
  }
});

Múltiplas Animações Simultâneas

class AnimatedLogo extends AnimatedWidget {
  const AnimatedLogo({super.key, required Animation<double> animation})
    : super(listenable: animation);

  static final _opacityTween = Tween<double>(begin: 0.1, end: 1);
  static final _sizeTween = Tween<double>(begin: 0, end: 300);

  @override
  Widget build(BuildContext context) {
    final animation = listenable as Animation<double>;
    return Center(
      child: Opacity(
        opacity: _opacityTween.evaluate(animation),
        child: Container(
          height: _sizeTween.evaluate(animation),
          width: _sizeTween.evaluate(animation),
          child: const FlutterLogo(),
        ),
      ),
    );
  }
}

Transições Explícitas Embutidas

Flutter fornece transições prontas para uso:

  • FadeTransition - Animação de desvanecimento
  • ScaleTransition - Animação de escala
  • SlideTransition - Animação de deslizamento
  • SizeTransition - Animação de tamanho
  • RotationTransition - Animação de rotação
  • PositionedTransition - Animação de posição (em Stack)

Exemplo:

FadeTransition(
  opacity: _animation,
  child: const FlutterLogo(),
)

Dicas de Desempenho

  • Descarte controladores quando o widget for removido
  • Use AnimatedBuilder para reconstruções ideais
  • Evite setState() em listeners de animação (use AnimatedWidget/AnimatedBuilder)
  • Use timeDilation para desacelerar animações durante a depuração

Animações Hero

Animações Hero criam transições de elementos compartilhados entre telas.

Animação Hero Básica

Tela de origem:

Hero(
  tag: 'hero-image',
  child: Image.asset('images/logo.png'),
)

Tela de destino:

Hero(
  tag: 'hero-image',  // Mesma tag!
  child: Image.asset('images/logo.png'),
)

Exemplo Completo

class PhotoHero extends StatelessWidget {
  const PhotoHero({
    super.key,
    required this.photo,
    this.onTap,
    required this.width,
  });

  final String photo;
  final VoidCallback? onTap;
  final double width;

  @override
  Widget build(BuildContext context) {
    return SizedBox(
      width: width,
      child: Hero(
        tag: photo,
        child: Material(
          color: Colors.transparent,
          child: InkWell(
            onTap: onTap,
            child: Image.asset(photo, fit: BoxFit.contain),
          ),
        ),
      ),
    );
  }
}

Navegando entre telas:

Navigator.of(context).push(
  MaterialPageRoute<void>(
    builder: (context) {
      return Scaffold(
        appBar: AppBar(title: const Text('Detalhe')),
        body: Center(
          child: PhotoHero(
            photo: 'images/logo.png',
            width: 300.0,
            onTap: () => Navigator.of(context).pop(),
          ),
        ),
      );
    },
  ),
);

Animação Hero Radial

Transforme de círculo para retângulo durante a transição:

class RadialExpansion extends StatelessWidget {
  const RadialExpansion({
    super.key,
    required this.maxRadius,
    this.child,
  }) : clipRectSize = 2.0 * (maxRadius / math.sqrt2);

  final double maxRadius;
  final double clipRectSize;
  final Widget? child;

  @override
  Widget build(BuildContext context) {
    return ClipOval(
      child: Center(
        child: SizedBox(
          width: clipRectSize,
          height: clipRectSize,
          child: ClipRect(child: child),
        ),
      ),
    );
  }
}

Use com MaterialRectCenterArcTween para interpolação baseada no centro:

static RectTween _createRectTween(Rect? begin, Rect? end) {
  return MaterialRectCenterArcTween(begin: begin, end: end);
}

Melhores Práticas Hero

  • Use tags únicas e consistentes (muitas vezes o próprio objeto de dados)
  • Mantenha as árvores de widgets hero semelhantes entre as rotas
  • Envolva imagens em Material com cor transparente para efeito "pop"
  • Use timeDilation para depurar transições
  • Considere HeroMode para desabilitar animações hero quando necessário

Animações Escalonadas

Execute múltiplas animações com tempos diferentes.

Animação Escalonada Básica

Todas as animações compartilham um controlador:

class StaggerAnimation extends StatelessWidget {
  StaggerAnimation({super.key, required this.controller})
    : opacity = Tween<double>(begin: 0.0, end: 1.0).animate(
        CurvedAnimation(
          parent: controller,
          curve: const Interval(0.0, 0.100, curve: Curves.ease),
        ),
      ),
      width = Tween<double>(begin: 50.0, end: 150.0).animate(
        CurvedAnimation(
          parent: controller,
          curve: const Interval(0.125, 0.250, curve: Curves.ease),
        ),
      );

  final AnimationController controller;
  final Animation<double> opacity;
  final Animation<double> width;

  Widget _buildAnimation(BuildContext context, Widget? child) {
    return Container(
      alignment: Alignment.bottomCenter,
      child: Opacity(
        opacity: opacity.value,
        child: Container(
          width: width.value,
          height: 150,
          color: Colors.blue,
        ),
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return AnimatedBuilder(
      animation: controller,
      builder: _buildAnimation,
    );
  }
}

Temporização Baseada em Intervalos

Cada animação tem um Intervalo entre 0.0 e 1.0:

animation = Tween<double>(begin: 0, end: 300).animate(
  CurvedAnimation(
    parent: controller,
    curve: const Interval(
      0.25,  // Inicia em 25% da duração do controlador
      0.50,  // Termina em 50% da duração do controlador
      curve: Curves.ease,
    ),
  ),
);

Tweens Comuns

borderRadius = BorderRadiusTween(
  begin: BorderRadius.circular(4),
  end: BorderRadius.circular(75),
).animate(
  CurvedAnimation(
    parent: controller,
    curve: const Interval(0.375, 0.500, curve: Curves.ease),
  ),
);

Animação de Menu Escalonado

class _MenuState extends State<Menu> with SingleTickerProviderStateMixin {
  static const _initialDelayTime = Duration(milliseconds: 50);
  static const _itemSlideTime = Duration(milliseconds: 250);
  static const _staggerTime = Duration(milliseconds: 50);
  static const _buttonDelayTime = Duration(milliseconds: 150);
  static const _buttonTime = Duration(milliseconds: 500);

  final _animationDuration =
      _initialDelayTime +
      (_staggerTime * _menuTitles.length) +
      _buttonDelayTime +
      _buttonTime;

  late AnimationController _controller;

  @override
  void initState() {
    super.initState();
    _controller = AnimationController(
      duration: _animationDuration,
      vsync: this,
    );
    _controller.forward();
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}

Melhores Práticas Escalonadas

  • Use Interval para deslocar animações no tempo
  • Certifique-se de que a duração do controlador cubra todos os intervalos
  • Use curvas para movimento natural dentro dos intervalos
  • Considere timeDilation para depurar temporizações
  • Escalone itens de menu com atraso crescente para efeito de ondulação

Animações Baseadas em Física

Crie animações de sensação natural usando simulações físicas.

Animação Fling

_controller.fling(
  velocity: 2.0,  // Unidades por segundo
);

Simulação Física Personalizada

_controller.animateWith(
  SpringSimulation(
    spring: const SpringDescription(
      mass: 1,
      stiffness: 100,
      damping: 10,
    ),
    start: 0.0,
    end: 1.0,
    velocity: 0.0,
  ),
);

Simulações Físicas Comuns

  • SpringSimulation - Física de mola
  • BouncingScrollSimulation - Rolagem com ressalto
  • ClampingScrollSimulation - Rolagem sem ressalto
  • GravitySimulation - Baseada em gravidade

Melhores Práticas

FAÇA

  • Descarte AnimationController na disposição do widget
  • Use AnimatedBuilder/AnimatedWidget em vez de setState() em listeners
  • Escolha curvas apropriadas para movimento natural
  • Use timeDilation para depurar animações
  • Considere o desempenho (evite widgets pesados em construções de animação)
  • Teste animações em vários dispositivos
  • Suporte animações reversas para sensação intuitiva

NÃO FAÇA

  • Esqueça de descartar AnimationController (vazamento de memória)
  • Use setState() em listeners de animação quando AnimatedBuilder é suficiente
  • Assuma que a animação completa instantaneamente (lide com AnimationStatus)
  • Anime em excesso (animações podem distrair usuários)
  • Crie animações que pareçam "instáveis" (use curvas suaves)
  • Ignore acessibilidade (respeite a preferência disableAnimations)

Recursos

referências/

implicit.md - Referência completa para widgets de animação implícita com exemplos e melhores práticas.

explicit.md - Aprofundamento em animações explícitas, AnimationController e padrões.

hero.md - Guia de animações Hero com transições padrão e radiais.

staggered.md - Padrões de animação escalonada e estratégias de temporização.

physics.md - Animações e simulações baseadas em física.

curves.md - Referência para a classe Curves e escolha de curvas apropriadas.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Habilidades Relacionadas