If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/daimajia/AndroidViewAnimations shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

GO — Healthy across all four use cases

• 17 active contributors
• MIT licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 5y ago
• ⚠ Concentrated ownership — top contributor handles 71% of recent commits

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live daimajia/AndroidViewAnimations repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/daimajia/AndroidViewAnimations.

What it runs against: a local clone of daimajia/AndroidViewAnimations — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in daimajia/AndroidViewAnimations | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 1753 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of daimajia/AndroidViewAnimations. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/daimajia/AndroidViewAnimations.git
#   cd AndroidViewAnimations
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of daimajia/AndroidViewAnimations and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "daimajia/AndroidViewAnimations(\\.git)?\\b" \\
  && ok "origin remote is daimajia/AndroidViewAnimations" \\
  || miss "origin remote is not daimajia/AndroidViewAnimations (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "library/src/main/java/com/daimajia/androidanimations/library/YoYo.java" \\
  && ok "library/src/main/java/com/daimajia/androidanimations/library/YoYo.java" \\
  || miss "missing critical file: library/src/main/java/com/daimajia/androidanimations/library/YoYo.java"
test -f "library/src/main/java/com/daimajia/androidanimations/library/BaseViewAnimator.java" \\
  && ok "library/src/main/java/com/daimajia/androidanimations/library/BaseViewAnimator.java" \\
  || miss "missing critical file: library/src/main/java/com/daimajia/androidanimations/library/BaseViewAnimator.java"
test -f "library/src/main/java/com/daimajia/androidanimations/library/Techniques.java" \\
  && ok "library/src/main/java/com/daimajia/androidanimations/library/Techniques.java" \\
  || miss "missing critical file: library/src/main/java/com/daimajia/androidanimations/library/Techniques.java"
test -f "library/build.gradle" \\
  && ok "library/build.gradle" \\
  || miss "missing critical file: library/build.gradle"
test -f "demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java" \\
  && ok "demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java" \\
  || miss "missing critical file: demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1753 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1723d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/daimajia/AndroidViewAnimations"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

AndroidViewAnimations is a curated library of 50+ pre-built view animation effects for Android, similar to CSS Animate.css but for native Views. It wraps the Android Animation API with a fluent API called YoYo that lets developers chain animations (fade, flip, rotate, bounce, slide, zoom) on any View in one line of code without dealing with ObjectAnimator boilerplate. Gradle monorepo split into two modules: library/ (the AAR artifact in library/src/main/java/com/daimajia/androidanimations/) contains 50+ Technique enum classes and the YoYo orchestrator, and demo/ (demo/src/main/java/com/daimajia/androidanimations/) contains ExampleActivity and EffectAdapter showcasing all effects. Build outputs via library/build.gradle and demo/build.gradle with shared settings in gradle.properties.

Android developers building consumer-facing apps who want polished entrance/exit animations and attention-grabbers (shake, pulse, tada) without implementing complex transformation matrices or animation state machines. Specifically useful for UI/UX teams prioritizing smooth, pre-tested animation effects over custom Motion Layout choreography.

Mature but dormant. The library reached v2.4 with stable API, includes CI via Travis CI (.travis.yml present), and was ported away from NineOldAndroids to native Android Animation APIs (v2.0+). However, the 2019 README footer suggests the original author moved on to finance work, and no evidence of recent commits or active maintenance is visible in the file structure.

Low risk for existing integrations but declining maintenance. The library has no visible test suite (no src/test or androidTest directories), single-author provenance (daimajia), and likely depends on Android Easing Functions (AnimationEasingFunctions) as a peer dependency that may not track modern Android API levels. Gradle build uses older Gradle 4.0.1 which may cause issues with Android Gradle Plugin 7.0+.

No active development visible. The file structure shows static demo content (demo/src/main/res/layout/ with activity_my.xml, example.xml, item.xml) and no pending work. The 2019 README note indicates the original author transitioned away; no branch structure or issue/PR data is present in the provided snapshot.

git clone https://github.com/daimajia/AndroidViewAnimations.git && cd AndroidViewAnimations && ./gradlew build. Then run ./gradlew demo:installDebug to install the demo APK on a connected emulator or device.

Daily commands: ./gradlew demo:installDebug && adb shell am start -n com.daimajia.androidanimations/.ExampleActivity (or MyActivity). Or open Android Studio, File > Open, select this directory, then Run > Run 'demo'.

• library/src/main/java/com/daimajia/androidanimations/library/YoYo.java — Primary public API entry point for all animation operations; essential for understanding how users trigger animations
• library/src/main/java/com/daimajia/androidanimations/library/BaseViewAnimator.java — Abstract base class for all animators; defines the animation lifecycle, property setup, and execution model
• library/src/main/java/com/daimajia/androidanimations/library/Techniques.java — Registry enum mapping animation names to animator classes; critical for understanding available animations and plugin architecture
• library/build.gradle — Defines library dependencies (Android Easing Functions), build config, and publication settings for Maven Central
• demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java — Demonstrates YoYo API usage patterns and typical integration scenarios for new developers
• library/src/main/java/com/daimajia/androidanimations/library/attention/BounceAnimator.java — Reference implementation of a concrete animator; shows pattern for defining keyframe animations using ObjectAnimator

Add a New Animation

1. Create a new animator class in the appropriate category folder (e.g., attention/, bouncing_entrances/, fading_exits/) extending BaseViewAnimator (library/src/main/java/com/daimajia/androidanimations/library/attention/CustomAnimator.java)
2. Implement getAnimators() to return an array of ObjectAnimator instances defining the animation properties (alpha, translationX, scaleX, rotationY, etc.) (library/src/main/java/com/daimajia/androidanimations/library/attention/CustomAnimator.java)
3. Add an enum entry to Techniques.java mapping your animation name to the new animator class (library/src/main/java/com/daimajia/androidanimations/library/Techniques.java)
4. Test via YoYo.with(Techniques.CustomAnimation).duration(500).playOn(view) (demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java)

Customize Animation Duration & Repeat

1. Use YoYo fluent API methods: .duration(milliseconds), .repeat(count), .onStart(listener), .onEnd(listener) (library/src/main/java/com/daimajia/androidanimations/library/YoYo.java)
2. Chain methods before calling playOn(view): YoYo.with(Techniques.Bounce).duration(800).repeat(2).playOn(myButton) (demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java)

Integrate into New Activity/Fragment

1. Add library dependency to your app's build.gradle: implementation 'com.daimajia.androidanimations:library:2.4@aar' (demo/build.gradle)
2. Import YoYo and Techniques in your Activity/Fragment (demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java)
3. Call YoYo.with(technique).duration(ms).playOn(view) in response to user interaction or lifecycle event (demo/src/main/java/com/daimajia/androidanimations/ExampleActivity.java)

• Android ObjectAnimator / AnimatorSet — Native Android property animation framework (API 11+) for smooth, hardware-accelerated view transformations with precise timing control
• Android Easing Functions (daimajia/AnimationEasingFunctions) — Provides time interpolators (ease-in, ease-out, elastic, bounce) to create natural motion curves beyond linear acceleration
• Builder/Fluent API (YoYo) — Enables concise, readable chaining of animation configuration (duration, repeat, callbacks) without nested constructors
• Enum-based Technique Registry — Type-safe, compile-time checked mapping of animation names to implementations; simplifies adding new effects without reflection

• Removed NineOldAndroids in v2.0, rely on native Android ObjectAnimator (API 11+)

  • Why: Modern Android projects target higher API levels; native framework is faster and built-in
  • Consequence: Cannot support API <11; reduced library size; no compatibility shim layer

• Single-view focus: animates one view at a time per YoYo instance

  • Why: Simplifies API surface and lifecycle management; users can compose multi-view animations manually
  • Consequence: Choreographed group animations require explicit listener-based sequencing; no built-in staggering

• Keyframe animations defined in Java (via ObjectAnimator arrays)

  • Why: No external animation file format to maintain; animations are code, testable and versionable
  • Consequence: Complex animations require mathematical calculation; less visual authoring than timeline-based tools

• Does not provide real-time animation editing or preview tools
• Does not support SVG path-based animations or shape morphing
• Does not handle layout transitions or Activity/Fragment shared element animations (use Android Transition Framework instead)
• Not a motion design framework; purely a pre-built animation library
• Does not manage complex state machines or animation sequencing logic (user responsibility via listeners)

No test suite means animation effects rely on manual emulator/device testing—regressions are not caught automatically. Library depends on Android Easing Functions via implicit peer dependency (not declared in library/build.gradle shown), so that library must be on the classpath. Gradle 4.0.1 is old (released 2018); modern Android Studio may warn or fail to sync; may need to upgrade gradle/wrapper/gradle-wrapper.properties. ProGuard rules in library/proguard-rules.pro and demo/proguard-rules.pro must be respected for obfuscated builds.

• ObjectAnimator and AnimatorSet — Core Android framework APIs that AndroidViewAnimations wraps; understanding property animations vs View animations is essential to debug why animations stutter or don't apply to custom properties
• Easing Functions / Interpolators — YoYo animations feel natural because of easing curves (ease-in, ease-out, elastic); this library pairs with AnimationEasingFunctions to provide non-linear timing
• Fluent/Builder Pattern — YoYo.with(Technique).duration().repeat().playOn() is a fluent API; understanding this pattern helps extend YoYo with new configuration options
• Property Animation vs View Animation — AndroidViewAnimations v2.0+ migrated from frame-by-frame View animations to property animations; knowing the difference prevents stale animation caching bugs on rotated/scaled Views
• View Transformation Matrices — Rotation, scale, and flip animations manipulate View.setScaleX/Y and View.setRotation; understanding transformation order prevents unexpected visual artifacts
• AAR (Android Archive) Module — This project publishes library/ as an AAR via Gradle; understanding AAR vs JAR helps when managing transitive dependencies and ProGuard obfuscation
• ProGuard/R8 Obfuscation Rules — library/proguard-rules.pro and demo/proguard-rules.pro preserve animation class names; incorrect rules cause animations to silently fail in release builds

• daimajia/AnimationEasingFunctions — Peer dependency providing easing function implementations (e.g., cubic, elastic) that AndroidViewAnimations uses to make animations more natural
• facebook/rebound — Facebook's spring physics animation library for Android; alternative to ObjectAnimator for smoother, physics-based entrance/exit effects
• airbnb/lottie-android — Vector animation library for Android that can replace frame-by-frame View animations with designer-friendly JSON exports from After Effects
• daneden/animate.css — Original web inspiration for this project; CSS animation library that AndroidViewAnimations directly ported to Android
• ArtFeel/AFViewShaker — Original iOS inspiration showing the shake animation concept that motivated this Android collection

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add instrumented tests for BaseViewAnimator and animation chaining

The library lacks Android instrumented tests to verify that animations actually execute correctly on devices/emulators. Currently only demo app exists. Adding tests for BaseViewAnimator.java and YoYo.java would ensure animation chains, listeners, and repeat counts work as documented. This is critical for a library focused on view animations.

• [ ] Create library/src/androidTest/java/com/daimajia/androidanimations/library/ directory structure
• [ ] Add BaseViewAnimatorTest.java to test animation lifecycle (start, cancel, repeat)
• [ ] Add YoYoChainTest.java to test animation chaining via .with() and .after()
• [ ] Configure library/build.gradle with androidTestImplementation dependencies (androidx.test:runner, espresso)
• [ ] Add test for verify listeners fire correctly in multiple animation scenarios

Upgrade Gradle build system and add GitHub Actions CI

The repo uses outdated Gradle 4.0.1 (from 2016) and Travis CI which is deprecated. Modernizing to current Gradle 7.x+ and GitHub Actions will improve reliability, faster builds, and better maintenance. .travis.yml exists but is stale.

• [ ] Update build.gradle classpath to gradle:7.4.2 or latest stable
• [ ] Update gradle/wrapper/gradle-wrapper.properties distributionUrl to Gradle 7.x
• [ ] Create .github/workflows/android-ci.yml with steps: checkout, setup Java, build library, run demo app lint
• [ ] Test build locally with ./gradlew clean build
• [ ] Remove or deprecate .travis.yml with note directing to GitHub Actions

Add comprehensive animator documentation and JavaDoc for Techniques enum

Techniques.java likely contains the enum of all 40+ animation types, but there's no JavaDoc explaining what each animation does visually. README.md snippet is incomplete ('Usage' section cuts off mid-Gradle). New contributors can't understand which animator to use without running demo app.

• [ ] Add JavaDoc comments to each animator constant in library/src/main/java/com/daimajia/androidanimations/library/Techniques.java with brief descriptions (e.g. 'BOUNCE_IN: Bouncy entrance from bottom')
• [ ] Complete README.md 'Usage' section with full Gradle example and add 'Available Animations' table listing all Techniques with descriptions
• [ ] Add code examples in README showing: basic usage with YoYo.with(), chaining animations, and setting duration/repeat
• [ ] Document library/src/main/java/com/daimajia/androidanimations/library/BaseViewAnimator.java with class-level JavaDoc explaining animation lifecycle

• Add unit tests for BaseViewAnimator and sample Technique classes (e.g., Shake, Tada) using Robolectric or Espresso in library/src/androidTest/java/. Currently no test directory exists.
• Update Gradle wrapper from 4.0.1 to 7.x in gradle/wrapper/gradle-wrapper.properties and gradle/wrapper/gradle-wrapper.jar, then verify demo builds and runs on Android Studio 2021.x+.
• Document the peer dependency on daimajia/AnimationEasingFunctions in library/build.gradle with an explicit 'implementation' or 'api' declaration, and add a setup guide to README.md showing how to include both libraries.

The AndroidViewAnimations project has a moderate security posture with significant concerns around outdated build tools and deprecated dependencies. The primary risks are the outdated Gradle plugin (4.0.1) and reliance on the deprecated JCenter repository. While the codebase itself is a UI animation library with lower inherent security risks compared to applications handling sensitive data, the infrastructure and dependency management require modernization. No obvious injection vulnerabilities or hardcoded secrets were detected in the provided files. Immediate action is recommended to update build tools and migrate to modern, maintained repositories.

• High · Outdated Gradle Build Plugin — build.gradle (buildscript dependencies). The project uses gradle:4.0.1 which was released in 2017 and contains known security vulnerabilities. This outdated version may have unpatched security issues and lacks modern security features. Fix: Update to the latest stable Gradle plugin version (currently 8.x). Run 'gradle wrapper --gradle-version=<latest>' to update.
• Medium · Deprecated Repository (JCenter) — build.gradle (allprojects repositories section). The project uses jcenter() repository which was deprecated by Bintray in 2021 and officially shut down. This poses maintenance and security risks as package sources may become unavailable or compromised. Fix: Replace jcenter() with mavenCentral() or Maven Central. Update buildscript and allprojects repositories to use 'mavenCentral()' exclusively.
• Medium · Missing Android Security Hardening — demo/src/main/AndroidManifest.xml and library/src/main/AndroidManifest.xml. The AndroidManifest.xml files are not shown in the provided content, but no evidence of security hardening measures (e.g., android:usesCleartextTraffic restrictions, proper permission declarations) is visible in the file structure. Fix: Ensure AndroidManifest.xml includes: android:usesCleartextTraffic='false', proper permission declarations with justification, and consider implementing Android security best practices guidelines.
• Low · No Dependency Version Pinning — build.gradle and library/build.gradle. The build.gradle file shows no explicit version constraints or lock files visible. This could lead to unexpected build results if transitive dependencies receive updates with breaking or security changes. Fix: Implement dependency version pinning using constraint or lock files. Use 'dependencyLocking' feature or explicitly specify versions for all dependencies.
• Low · ProGuard Configuration Review Needed — demo/proguard-rules.pro and library/proguard-rules.pro. ProGuard rules files exist (demo/proguard-rules.pro and library/proguard-rules.pro) but their content is not provided. Improper ProGuard configuration could expose sensitive method names or logic. Fix: Review ProGuard configurations to ensure sensitive classes and methods are properly obfuscated. Ensure '-keep' rules don't expose security-critical code.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.