Communitygithub.com

ComeOnOliver/skillshub

Guía completa para implementar animaciones en Flutter. Úsala al agregar movimiento y efectos visuales a aplicaciones Flutter: animaciones implícitas (AnimatedContainer, AnimatedOpacity, TweenAnimationBuilder), animaciones explícitas (AnimationController, Tween, AnimatedWidget/AnimatedBuilder), animaciones héroe (transiciones de elementos compartidos), animaciones escalonadas (secuenciales/superpuestas) y animaciones basadas en física. Incluye un flujo de trabajo para elegir el tipo de animación adecuado, patrones de implementación y mejores prácticas para rendimiento y experiencia de usuario.

¿Qué es skillshub?

Esta habilidad proporciona una guía completa y estructurada para implementar animaciones en Flutter, desde las más simples hasta las más complejas. Está diseñada para desarrolladores que buscan agregar movimiento y efectos visuales a sus aplicaciones, ofreciendo un árbol de decisión claro para elegir entre animaciones implícitas, explícitas, héroe, escalonadas o basadas en física según los requisitos específicos del proyecto. La guía cubre widgets comunes como AnimatedContainer, AnimationController, Hero y sus patrones de uso, así como mejores prácticas para el rendimiento, la accesibilidad y la experiencia del usuario. Es compatible con todos los entornos de desarrollo Flutter que admitan la escritura de código Dart y se puede utilizar directamente en proyectos existentes para mejorar la interactividad y la estética de las interfaces.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Animaciones en Flutter

Descripción general

Crea animaciones suaves y eficientes en Flutter utilizando el enfoque adecuado para cada caso de uso. Esta habilidad cubre el flujo de trabajo completo de animación: desde elegir entre enfoques implícitos y explícitos hasta implementar efectos complejos como transiciones héroe y animaciones escalonadas.

Árbol de decisión del tipo de animación

Elige el tipo de animación adecuado según tus requisitos:

Animaciones Implícitas - Úsalas cuando:

  • Animes una sola propiedad (color, tamaño, posición)
  • La animación se active por un cambio de estado
  • No necesites control detallado

Animaciones Explícitas - Úsalas cuando:

  • Necesites control total sobre el ciclo de vida de la animación
  • Animes múltiples propiedades simultáneamente
  • Necesites reaccionar a cambios de estado de la animación
  • Crees animaciones o transiciones personalizadas

Animaciones Héroe - Úsalas cuando:

  • Compartas un elemento entre dos pantallas
  • Crees transiciones de elementos compartidos
  • El usuario espere que un elemento "vuele" entre rutas

Animaciones Escalonadas - Úsalas cuando:

  • Múltiples animaciones deban ejecutarse secuencialmente o superponerse
  • Creases efectos de onda o revelaciones secuenciales
  • Animes elementos de una lista en secuencia

Animaciones Basadas en Física - Úsalas cuando:

  • Las animaciones deban sentirse naturales/físicas
  • Se requiera comportamiento de resorte, gestos de desplazamiento
  • Interacciones arrastrables

Animaciones Implícitas

Las animaciones implícitas manejan automáticamente la animación cuando las propiedades cambian. No necesitan controlador.

Widgets implícitos comunes

AnimatedContainer - Anima múltiples propiedades (tamaño, color, decoración, relleno):

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 - Animación de fundido simple:

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

TweenAnimationBuilder - Animación Tween personalizada sin código repetitivo:

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(),
)

Otros widgets implícitos:

  • AnimatedPadding - Animación de relleno
  • AnimatedPositioned - Animación de posición (en Stack)
  • AnimatedAlign - Animación de alineación
  • AnimatedContainer - Múltiples propiedades
  • AnimatedSwitcher - Transición entre widgets
  • AnimatedDefaultTextStyle - Animación de estilo de texto

Mejores prácticas

  • Prefiere animaciones implícitas para casos simples
  • Usa curvas apropiadas para movimiento natural (ver clase Curves)
  • Establece curve y duration para un comportamiento predecible
  • Usa el callback onEnd cuando sea necesario
  • Evita animaciones implícitas anidadas por rendimiento

Animaciones Explícitas

Las animaciones explícitas proporcionan control total con AnimationController.

Componentes principales

AnimationController - Impulsa la animación:

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 y final:

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

CurvedAnimation - Aplica una curva a la animación:

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

Patrón AnimatedWidget

Ideal para widgets animados reutilizables:

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(),
      ),
    );
  }
}

Patrón AnimatedBuilder

Ideal para widgets complejos con animaciones:

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

Monitoreo del estado de la animación

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

Múltiples animaciones 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(),
        ),
      ),
    );
  }
}

Transiciones explícitas incorporadas

Flutter proporciona transiciones listas para usar:

  • FadeTransition - Animación de fundido
  • ScaleTransition - Animación de escala
  • SlideTransition - Animación de desplazamiento
  • SizeTransition - Animación de tamaño
  • RotationTransition - Animación de rotación
  • PositionedTransition - Animación de posición (en Stack)

Ejemplo:

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

Consejos de rendimiento

  • Libera los controladores cuando se elimine el widget
  • Usa AnimatedBuilder para reconstrucciones óptimas
  • Evita setState() en los listeners de animación (usa AnimatedWidget/AnimatedBuilder)
  • Usa timeDilation para ralentizar animaciones durante la depuración

Animaciones Héroe

Las animaciones héroe crean transiciones de elementos compartidos entre pantallas.

Animación Héroe básica

Pantalla de origen:

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

Pantalla de destino:

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

Ejemplo 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 pantallas:

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

Animación Héroe radial

Transforma de círculo a rectángulo durante la transición:

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

Úsalo con MaterialRectCenterArcTween para interpolación basada en el centro:

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

Mejores prácticas para Héroe

  • Usa etiquetas únicas y consistentes (a menudo el propio objeto de datos)
  • Mantén los árboles de widgets héroe similares entre rutas
  • Envuelve las imágenes en Material con color transparente para un efecto "pop"
  • Usa timeDilation para depurar transiciones
  • Considera HeroMode para deshabilitar animaciones héroe cuando sea necesario

Animaciones Escalonadas

Ejecuta múltiples animaciones con diferentes tiempos.

Animación escalonada básica

Todas las animaciones comparten un 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,
    );
  }
}

Temporización basada en intervalos

Cada animación tiene un Interval entre 0.0 y 1.0:

animation = Tween<double>(begin: 0, end: 300).animate(
  CurvedAnimation(
    parent: controller,
    curve: const Interval(
      0.25,  // Comienza al 25% de la duración del controlador
      0.50,  // Termina al 50% de la duración del controlador
      curve: Curves.ease,
    ),
  ),
);

Tweens comunes

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

Animación de menú 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();
  }
}

Mejores prácticas para escalonadas

  • Usa Interval para desplazar las animaciones en el tiempo
  • Asegúrate de que la duración del controlador cubra todos los intervalos
  • Usa curvas para un movimiento natural dentro de los intervalos
  • Considera timeDilation para depurar la temporización
  • Escalona los elementos del menú con retraso creciente para un efecto de onda

Animaciones Basadas en Física

Crea animaciones con sensación natural usando simulaciones físicas.

Animación Fling

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

Simulación física personalizada

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

Simulaciones físicas comunes

  • SpringSimulation - Física de resorte
  • BouncingScrollSimulation - Desplazamiento con rebote
  • ClampingScrollSimulation - Desplazamiento sin rebote
  • GravitySimulation - Basada en gravedad

Mejores prácticas

HACER

  • Libera AnimationController al eliminar el widget
  • Usa AnimatedBuilder/AnimatedWidget en lugar de setState() en los listeners
  • Elige curvas apropiadas para un movimiento natural
  • Usa timeDilation para depurar animaciones
  • Considera el rendimiento (evita widgets pesados en las reconstrucciones de animación)
  • Prueba las animaciones en varios dispositivos
  • Soporta animaciones inversas para una sensación intuitiva

NO HACER

  • Olvides liberar AnimationController (fuga de memoria)
  • Uses setState() en los listeners de animación cuando AnimatedBuilder sea suficiente
  • Asumas que la animación se completa instantáneamente (maneja AnimationStatus)
  • Sobreamimes (las animaciones pueden distraer a los usuarios)
  • Creases animaciones que se sientan "entrecortadas" (usa curvas suaves)
  • Ignorar la accesibilidad (respeta la preferencia disableAnimations)

Recursos

references/

implicit.md - Referencia completa para widgets de animación implícita con ejemplos y mejores prácticas.

explicit.md - Inmersión profunda en animaciones explícitas, AnimationController y patrones.

hero.md - Guía de animaciones héroe con transiciones estándar y radiales.

staggered.md - Patrones de animación escalonada y estrategias de temporización.

physics.md - Animaciones y simulaciones basadas en física.

curves.md - Referencia para la clase Curves y cómo elegir curvas apropiadas

...

[truncado para traducción]

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

Skills relacionados