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/HarlonWang/AVLoadingIndicatorView 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.

AVOID — Stale and unlicensed — last commit 3y ago

• 7 active contributors
• ⚠ Stale — last commit 3y ago
• ⚠ Single-maintainer risk — top contributor 87% of recent commits
• ⚠ No license — legally unclear to depend on
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{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 HarlonWang/AVLoadingIndicatorView repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/HarlonWang/AVLoadingIndicatorView.

What it runs against: a local clone of HarlonWang/AVLoadingIndicatorView — 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 HarlonWang/AVLoadingIndicatorView | Confirms the artifact applies here, not a fork | | 2 | Default branch master exists | Catches branch renames | | 3 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 4 | Last commit ≤ 1158 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of HarlonWang/AVLoadingIndicatorView. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/HarlonWang/AVLoadingIndicatorView.git
#   cd AVLoadingIndicatorView
#
# 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 HarlonWang/AVLoadingIndicatorView and re-run."
  exit 2
fi

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

# 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/wang/avi/AVLoadingIndicatorView.java" \\
  && ok "library/src/main/java/com/wang/avi/AVLoadingIndicatorView.java" \\
  || miss "missing critical file: library/src/main/java/com/wang/avi/AVLoadingIndicatorView.java"
test -f "library/src/main/java/com/wang/avi/Indicator.java" \\
  && ok "library/src/main/java/com/wang/avi/Indicator.java" \\
  || miss "missing critical file: library/src/main/java/com/wang/avi/Indicator.java"
test -f "library/src/main/res/values/attrs.xml" \\
  && ok "library/src/main/res/values/attrs.xml" \\
  || miss "missing critical file: library/src/main/res/values/attrs.xml"
test -f "library/build.gradle" \\
  && ok "library/build.gradle" \\
  || miss "missing critical file: library/build.gradle"
test -f "app/src/main/java/com/wang/avi/sample/SampleActivity.java" \\
  && ok "app/src/main/java/com/wang/avi/sample/SampleActivity.java" \\
  || miss "missing critical file: app/src/main/java/com/wang/avi/sample/SampleActivity.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 1158 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1128d)"
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/HarlonWang/AVLoadingIndicatorView"
  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).

AVLoadingIndicatorView is a deprecated Android library that provides a collection of 24+ pre-built loading animation indicators (BallPulseIndicator, LineScaleIndicator, CubeTransitionIndicator, etc.) as reusable custom View components. It lets Android developers drop animated loading spinners into layouts via XML with a single indicatorName attribute, eliminating the need to build rotation/scale animations from scratch. Two-module Gradle structure: library/ contains the core AVLoadingIndicatorView custom View and 24 Indicator implementations (likely under library/src/main/java/com/wang/avi/indicators/), while app/ is a demo module showcasing all indicators in SampleActivity and IndicatorActivity with RecyclerView. No separation of concerns visible; all animations likely in Java Canvas/Paint.

Android app developers (API 14+) who need polished loading indicators in activities and fragments without implementing Canvas-based animations or complex ObjectAnimators. Specifically useful for developers targeting the 2013–2015 era of Android development, before Material Design loaders became standard.

Abandoned/deprecated as of ~2016. The README explicitly states 'THIS PROJECT IS NO LONGER BEING MAINTAINED.' Codebase is stable (v2.1.3) with a pre-built APK present, but no active commits, no CI/CD visible, minimal test coverage (only one empty ApplicationTest.java), and no ProGuard/modern Android Gradle Plugin updates.

High risk for new projects: targets SDK 23 (Android 6.0) with compileSdkVersion hardcoded to 23, incompatible with modern Android toolchains (API 31+). Single maintainer (HarlonWang), no visible issue tracker or PR history in file list. Reflection-based indicator loading via class names (see Proguard section) is fragile and requires manual keep rules. Zero dependency transparency beyond support-appcompat-v7:23.2.0.

Nothing. Project is dormant. No recent commits, no open issues, no planned work. An APK snapshot exists at apk/app-debug.apk but appears to be a historical artifact.

git clone https://github.com/HarlonWang/AVLoadingIndicatorView.git
cd AVLoadingIndicatorView
./gradlew build
./gradlew :app:installDebug

Requires Java 7+ and Android SDK 23. Open in Android Studio 2.0–3.x era IDEs for best compatibility.

Daily commands:

./gradlew :app:run
# or
./gradlew :app:installDebug && adb shell am start -n com.wang.avi.sample/.SampleActivity

No Makefile or npm scripts; pure Gradle. Targets Android 6.0 (minSdk 14).

• library/src/main/java/com/wang/avi/AVLoadingIndicatorView.java — Main entry point and core widget class that orchestrates all loading indicator animations—every contributor must understand the API contract and rendering lifecycle
• library/src/main/java/com/wang/avi/Indicator.java — Abstract base interface that all 30+ indicator implementations inherit from—defines the animation contract that powers the entire library
• library/src/main/res/values/attrs.xml — XML attributes schema for AVLoadingIndicatorView configuration—required reading for understanding customization and XML layout integration
• library/build.gradle — Library module build configuration with SDK version targets and artifact publishing details—critical for build compatibility and dependency management
• app/src/main/java/com/wang/avi/sample/SampleActivity.java — Primary demo activity showcasing all indicator types and usage patterns—essential reference for API usage and integration examples
• README.md — Project documentation explicitly stating DEPRECATED status and providing usage guide—sets expectations and deprecation warnings for all consumers

• AVLoadingIndicatorView (Android View, ValueAnimator, Canvas, Paint) — Main custom View managing indicator lifecycle: inflation, attribute parsing, animation orchestration, resource cleanup
  • Failure mode: If indicator class not found by reflection, NullPointerException on draw(); animation stops abruptly
• Indicator Interface & Implementations (Java, Canvas drawing primitives) — Abstract animation contract; 30+ concrete implementations (BallPulse, LineScale, etc.) each rendering a unique animation pattern
  • Failure mode: Malformed draw() implementation causes visual glitches, crashes on out-of-bounds canvas access, or infinite loops
• ValueAnimator (Android Animation Framework) — Drives smooth frame updates from 0–1000ms duration, triggers invalidate() to request canvas redraws
  • Failure mode: If animator not properly cancelled on stop(), memory leak and continued CPU usage; animation persists in background
• Demo Activity & RecyclerView (Android Activity, RecyclerView, ViewHolder) — Showcases all 30+ indicator types in scrollable list; allows selection and detail view
  • Failure mode: Memory leaks if animations not stopped when items scroll out of view; UI

Add a New Loading Indicator Animation

1. Create new Java class in library/src/main/java/com/wang/avi/indicators/ extending Indicator interface (library/src/main/java/com/wang/avi/indicators/NewIndicator.java)
2. Implement required methods: draw(Canvas, Paint), setAlpha(int), setColor(int), getAnimationDuration() (library/src/main/java/com/wang/avi/indicators/NewIndicator.java)
3. Register indicator name in AVLoadingIndicatorView factory logic (reflection-based lookup by class name) (library/src/main/java/com/wang/avi/AVLoadingIndicatorView.java)
4. Add test layout in demo app to verify animation renders correctly (app/src/main/res/layout/activity_sample.xml)

Integrate AVLoadingIndicatorView into an Activity Layout

1. Add library dependency to app/build.gradle: compile project(':library') (app/build.gradle)
2. Add AVLoadingIndicatorView widget to your layout XML with indicatorName attribute (app/src/main/res/layout/activity_sample.xml)
3. Reference view in Activity code and control via start()/stop() methods (app/src/main/java/com/wang/avi/sample/SampleActivity.java)

Customize Indicator Appearance

1. Set indicatorColor via XML attribute app:indicatorColor or programmatically setIndicatorColor() (library/src/main/res/values/attrs.xml)
2. Set indicatorSize for scale adjustment via app:indicatorSize attribute (library/src/main/res/values/attrs.xml)
3. Extend Indicator class and override drawing logic to implement custom animations (app/src/main/java/com/wang/avi/sample/MyCustomIndicator.java)

• Android Canvas & Paint API — Provides low-level 2D drawing primitives for custom frame-by-frame animations without heavy dependencies
• ValueAnimator — Drives smooth animation loop at consistent frame rate, handles interpolation and timing automation
• Reflection-based Factory Pattern — Allows dynamic indicator type selection via string name in XML (indicatorName attribute) without hardcoded switch statements
• Custom View Subclass (Android View) — Integrates seamlessly into standard Android layout hierarchies, supports XML inflation and attribute binding

• Deprecated project—no longer maintained

  • Why: Author moved focus to other projects; decided to mark as DEPRECATED in README
  • Consequence: No bug fixes, no new features, no support for modern Android versions (compileSdkVersion 23 is from 2015)

• 30+ separate Indicator classes instead of parameterized single class

  • Why: Each animation has unique drawing logic; easier to understand and modify per-indicator
  • Consequence: Code duplication in setup/initialization; large number of classes; maintenance burden for similar animations

• Custom drawing on Canvas instead of AnimationDrawable or Lottie

  • Why: Fine-grained control, lightweight, no JSON parsing overhead, pure Java implementation
  • Consequence: All animations must be hand-coded; more complex than declarative formats; harder to preview in design tools

• Reflection-based indicator lookup by class name string

  • Why: Enables XML attribute configuration without hardcoding; flexible and extensible
  • Consequence: Runtime class loading overhead; poor IDE type safety; cryptic error messages if class name misspelled

• Does not provide real-time animations synchronized to actual data loading progress
• Does not support animation preview in Android Studio layout editor
• Does not handle rotation state persistence (animations restart on configuration change)
• Does not provide Material Design loading indicators
• Does not support animated vector drawables or Lottie format
• Not compatible with Android API levels > 23 without manual updates

Reflection-based class loading: Indicators are instantiated dynamically by class name string (e.g., indicatorName="BallPulseIndicator"); ProGuard obfuscation will silently break this. Android Gradle Plugin version: buildToolsVersion "23.0.2" is incompatible with Gradle 5.0+ and Android Studio 4.0+; requires legacy toolchain. No lifecycle awareness: animations may leak memory if View is not properly destroyed; no onDetachedFromWindow() cleanup visible. SDK 23 hardcoding: compileSdkVersion cannot be upgraded without API deprecation refactoring. Thread safety: Canvas drawing occurs on main thread; heavy indicator rendering may block UI.

• Android Custom Views and Canvas Drawing — All 24 indicators are implemented as custom Views using Canvas.drawPath(), drawCircle(), drawRect() with ValueAnimator or ObjectAnimator; understanding Canvas coordinate systems and paint operations is core to this library.
• Reflection and Dynamic Class Instantiation — Indicators are loaded dynamically by string name (e.g., 'BallPulseIndicator') via Class.forName() and newInstance(); this enables XML-driven selection but breaks with ProGuard obfuscation.
• ObjectAnimator and PropertyAnimator — Each indicator likely uses ObjectAnimator to animate properties (rotation, scale, alpha) over time; essential for understanding how the loading animations loop and respond to start/stop lifecycle.
• Android Lifecycle and View Detachment — Animations must be paused/resumed with Activity lifecycle to avoid memory leaks and redundant rendering; this library's lack of explicit lifecycle callbacks is a hidden trap.
• ProGuard Obfuscation and Keep Rules — Because indicator classes are instantiated by name, ProGuard must have explicit -keep class com.wang.avi.indicators.** { *; } rules or production builds will fail silently at runtime.
• Measure and Layout in Android Custom Views — Custom Views must override onMeasure() and onDraw(); AVLoadingIndicatorView likely handles wrap_content sizing and respects layout_width/layout_height attributes, which varies per indicator.
• Strategy Pattern and Polymorphism — Each Indicator is a strategy implementing a common interface or abstract class; the host View delegates animation rendering to the selected strategy, enabling easy swapping without modifying core View logic.

• ninjaprox/NVActivityIndicatorView — iOS equivalent library; original inspiration cited in README. Useful for parity if supporting both platforms.
• material-components/material-components-android — Modern Android loading indicators and Material Design spinners that should be used instead of AVLoadingIndicatorView for new projects.
• android/architecture-samples — Reference for contemporary Android architecture best practices; AVLoadingIndicatorView's Canvas pattern is pre-MVVM and lacks ViewModel lifecycle integration.
• square/okhttp — Common networking library used alongside loading indicators in real-world Android apps; not included as dependency here but typical use case.
• robolectric/robolectric — Testing framework needed to unit-test the Canvas drawing logic in Indicator classes without an emulator.

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 comprehensive unit tests for all Indicator implementations

The library/src/androidTest directory contains only ApplicationTest.java with no tests for the 15+ indicator classes (BallBeatIndicator, BallClipRotateIndicator, etc.). Given this is a deprecated but still-used visual component library, adding unit tests for indicator initialization, animation properties, and drawing behavior would help prevent regressions and make maintenance easier for future contributors.

• [ ] Create library/src/test/java/com/wang/avi/indicators directory structure
• [ ] Add unit tests for each indicator in library/src/main/java/com/wang/avi/indicators/*.java (at least 5 core indicators: BallBeatIndicator, BallClipRotateIndicator, BallGridBeatIndicator, BallPulseIndicator, LineSpinFadeLoaderIndicator)
• [ ] Test indicator initialization parameters, animation duration getters, and Draw() method behavior using Robolectric or equivalent
• [ ] Update library/build.gradle to include testImplementation dependencies for junit and robolectric

Add instrumented UI tests for AVLoadingIndicatorView in sample app

The app/src/androidTest/java/com/wang/avi/sample contains only ApplicationTest.java skeleton. The IndicatorActivity.java and SampleActivity.java demonstrate the library's usage but lack automated tests. Adding Espresso tests would verify that indicators render correctly, animations start/stop properly, and custom indicators (MyCustomIndicator.java) work as expected.

• [ ] Create app/src/androidTest/java/com/wang/avi/sample/AVLoadingIndicatorViewTest.java with Espresso tests
• [ ] Add test cases for: indicator visibility toggling, animation lifecycle (start/stop), programmatic attribute changes via setIndicator(), and custom indicator rendering
• [ ] Add testImplementation dependencies for espresso-core and espresso-intents to app/build.gradle
• [ ] Test against activities in app/src/main/java/com/wang/avi/sample/IndicatorActivity.java and SampleActivity.java

Update deprecated Android Support Library dependencies to AndroidX

The build.gradle specifies compileSdkVersion 23 and dependencies on com.android.support:appcompat-v7:23.2.0 and com.android.support:recyclerview-v7:23.2.0, which are deprecated and no longer maintained. Migrating to AndroidX (androidx.appcompat:appcompat, androidx.recyclerview:recyclerview) would modernize the codebase, improve compatibility with newer Android versions, and provide a template for users updating their own projects.

• [ ] Update app/build.gradle and library/build.gradle: change compileSdkVersion to 31+ and update support library imports to androidx equivalents
• [ ] Update app/src/main/AndroidManifest.xml and library/src/main/AndroidManifest.xml if they reference support library attributes
• [ ] Update gradle.properties to add android.useAndroidX=true and android.enableJetifier=true for backward compatibility during migration
• [ ] Test the sample app (SampleActivity.java, IndicatorActivity.java) and verify all indicators render correctly with AndroidX

• Upgrade compileSdkVersion from 23 to 30+ and minSdkVersion from 14 to 21: requires testing all 24 indicators for deprecation warnings and updating support library versions in library/build.gradle and app/build.gradle.
• Add unit tests for Indicator initialization and animation frame rendering: create library/src/test/java/com/wang/avi/indicators/ with parametrized tests for each indicator's draw(Canvas) method using Robolectric or Canvas mocking.
• Document the custom Indicator interface and abstract class in Javadoc: add code comments to the base Indicator class (likely in library/src/main/java/com/wang/avi/) explaining the required methods (onDraw, onMeasure) and linking to MyCustomIndicator.java as a reference implementation.

This project presents significant security concerns primarily due to its deprecated status and severely outdated dependencies. The codebase targets Android 6.0 (API 23) with build tools from 2015 and contains multiple known vulnerable libraries. The explicit statement that the project is no longer maintained is a critical red flag for production use. Additional concerns include disabled code obfuscation and potential network security configuration gaps. Migration to an actively maintained alternative is strongly recommended for any production application.

• High · Outdated Android Dependencies — app/build.gradle, library/build.gradle. The project uses compileSdkVersion 23 and buildToolsVersion 23.0.2, which are from 2015. Additionally, dependencies like appcompat-v7:23.2.0 and recyclerview-v7:23.2.0 are significantly outdated and may contain known security vulnerabilities. Fix: Update to the latest stable Android SDK version (API 34+), buildToolsVersion, and all support library dependencies. Use Google's AndroidX libraries instead of deprecated support libraries.
• High · Project No Longer Maintained — README.md. The README explicitly states 'THIS PROJECT IS NO LONGER BEING MAINTAINED'. This means security patches and bug fixes will not be applied, leaving the codebase vulnerable to future exploits. Fix: Do not use this library in production. Consider migrating to actively maintained alternatives for loading indicator views or maintaining a fork with security updates.
• Medium · Minification Disabled in Release Build — app/build.gradle. The build.gradle shows minifyEnabled is set to false for release builds. This disables code shrinking and obfuscation, making the APK larger and the code more susceptible to reverse engineering. Fix: Enable minification and obfuscation in release builds by setting minifyEnabled to true and ensuring proper proguard-rules.pro configuration.
• Medium · Low Target SDK Version — app/build.gradle. targetSdkVersion is set to 23 (Android 6.0, released in 2015). Modern Android requires targeting recent API levels to access the Google Play Store and to meet contemporary security standards. Fix: Update targetSdkVersion to the latest available Android API level (currently 34 or higher) to ensure compliance with Google Play Store requirements and modern security practices.
• Low · Missing Security Configuration — app/src/main/res/. No network security configuration file (network_security_config.xml) is visible in the file structure. This could indicate missing SSL pinning or improper TLS validation configuration. Fix: Implement a network_security_config.xml file to enforce SSL/TLS best practices and consider implementing certificate pinning if the app communicates with specific backends.

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.