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/NumberProgressBar 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.

WAIT — Stale — last commit 6y ago

• 11 active contributors
• MIT licensed
• CI configured
• ⚠ Stale — last commit 6y ago
• ⚠ Concentrated ownership — top contributor handles 59% of recent commits
• ⚠ 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 daimajia/NumberProgressBar repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/daimajia/NumberProgressBar.

What it runs against: a local clone of daimajia/NumberProgressBar — 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/NumberProgressBar | 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 ≤ 2079 days ago | Catches sudden abandonment since generation |

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "daimajia/NumberProgressBar(\\.git)?\\b" \\
  && ok "origin remote is daimajia/NumberProgressBar" \\
  || miss "origin remote is not daimajia/NumberProgressBar (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/numberprogressbar/NumberProgressBar.java" \\
  && ok "library/src/main/java/com/daimajia/numberprogressbar/NumberProgressBar.java" \\
  || miss "missing critical file: library/src/main/java/com/daimajia/numberprogressbar/NumberProgressBar.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/src/main/java/com/daimajia/numberprogressbar/OnProgressBarListener.java" \\
  && ok "library/src/main/java/com/daimajia/numberprogressbar/OnProgressBarListener.java" \\
  || miss "missing critical file: library/src/main/java/com/daimajia/numberprogressbar/OnProgressBarListener.java"
test -f "demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java" \\
  && ok "demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java" \\
  || miss "missing critical file: demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java"
test -f "library/build.gradle" \\
  && ok "library/build.gradle" \\
  || miss "missing critical file: library/build.gradle"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 2079 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~2049d)"
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/NumberProgressBar"
  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).

NumberProgressBar is a lightweight, customizable Android ProgressBar widget that displays a slim progress bar with animated percentage text overlay. It replaces Android's default ProgressBar with a more visually polished component featuring pre-designed color themes (Default, Passing Green, Relax Blue, Grace Yellow, Warning Red, Funny Orange, Beauty Red, Twinkle Night) and extensive attribute control over colors, heights, text sizing, and spacing. Simple two-module Gradle structure: library/ contains the core widget (NumberProgressBar.java, OnProgressBarListener.java) as a reusable AAR, and demo/ is a standalone Android app (MainActivity.java) demonstrating all features. All UI resources (styles, drawable assets) live in library/src/main/res/ and demo/src/main/res/.

Android app developers who want to replace the default Android ProgressBar with a more attractive, configurable progress indicator in their UI layouts. They need fine-grained control over visual styling without implementing custom Canvas drawing from scratch.

This is a stable, mature library (v1.4 released). The codebase is small (~16KB Java), uses Travis CI for builds, and follows standard Android library packaging (gradle-mvn-push.gradle suggests Maven Central distribution). However, the repository shows signs of age—Gradle 2.2.3 is outdated, and no recent commit data is visible, suggesting this may not be actively maintained.

Low risk for production use due to small scope and minimal dependencies, but maintenance risk exists: the single maintainer (daimajia) shows no visible recent activity, Gradle configuration is several versions behind modern standards (current is 7.x+), and there's no test suite visible (no src/test/ directory). The project targets older Android APIs without explicit minSdkVersion visibility in provided files.

No active development is visible from the provided data. The repository appears in maintenance-only state with no pending changes or open milestones mentioned. The presence of gradle-mvn-push.gradle and gradle.properties suggests historical Maven Central publishing setup, but current status is unknown.

git clone https://github.com/daimajia/NumberProgressBar.git
cd NumberProgressBar
./gradlew assembleDebug  # Mac/Linux
# or
gradlew.bat assembleDebug  # Windows

Daily commands:

./gradlew assembleDebug      # Build debug APK for demo
./gradlew installDebug       # Install demo app on connected device
./gradlew build              # Build both library AAR and demo APK

• library/src/main/java/com/daimajia/numberprogressbar/NumberProgressBar.java — Core custom View implementation that renders the progress bar with number display; all visual and behavioral logic depends on understanding this class
• library/src/main/res/values/attrs.xml — Defines all custom XML attributes (colors, dimensions, text styles) that users configure when integrating the library
• library/src/main/java/com/daimajia/numberprogressbar/OnProgressBarListener.java — Public callback interface that applications implement to react to progress changes; essential for integrating into host apps
• demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java — Reference implementation showing all primary use cases and API patterns for the NumberProgressBar widget
• library/build.gradle — Defines library build configuration, Android SDK versions, and Maven publication settings for distribution
• settings.gradle — Root Gradle configuration declaring library and demo as subprojects; required for multi-module build

• NumberProgressBar (View) (Canvas, Paint, Path, ValueAnimator) — Renders progress visuals (arc, number, colors); manages animation state; triggers listener callbacks
  • Failure mode: If onDraw() throws exception, entire app UI deadlocks; invalid progress values cause divide-by-zero or out-of-bounds arc angles
• OnProgressBarListener (Callback) (Java interface) — Allows host app to react to progress state changes asynchronously
  • Failure mode: If listener implementation throws exception, animation and further callbacks are blocked
• Attribute system (attrs.xml) (XML attributes, TypedArray) — Provides declarative configuration surface for colors, dimensions, and behavior without code changes
  • Failure mode: Invalid attribute values (e.g., negative max or corrupt color hex) cause silent fallback to defaults or parsing errors

• Android Activity → NumberProgressBar — App calls setProgress(value) programmatically or via layout inflation with XML attributes
• NumberProgressBar state → Canvas onDraw() — Progress value, colors, and text are read during onDraw() to render the visual representation
• NumberProgressBar → OnProgressBarListener — onProgressChange(current, max) callback fired when progress value changes, notifying app of updates
• ValueAnimator → NumberProgressBar — Animated progress values fed to setProgress() frame-by-frame, triggering redraws via invalidate()

Add a new color theme variant

1. Define new color attributes in the custom attrs namespace (library/src/main/res/values/attrs.xml)
2. Create a new style preset that sets the color attributes to your palette (library/src/main/res/values/styles.xml)
3. Add a preview of the new theme in the demo activity layout (demo/src/main/res/layout/activity_main.xml)
4. Update MainActivity to instantiate and configure a NumberProgressBar with the new theme (demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java)

Add progress event handling to an activity

1. Have your Activity implement OnProgressBarListener interface (demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java)
2. Reference the NumberProgressBar instance by ID in your layout (demo/src/main/res/layout/activity_main.xml)
3. Call setOnProgressBarListener(this) on the NumberProgressBar to register your callback (demo/src/main/java/com/daimajia/numberprogressbar/example/MainActivity.java)
4. Implement onProgressChange(current, max) to respond to progress updates (library/src/main/java/com/daimajia/numberprogressbar/OnProgressBarListener.java)

Customize progress bar appearance via XML

1. Declare NumberProgressBar in your layout with custom attributes (demo/src/main/res/layout/activity_main.xml)
2. Reference available custom attributes (text color, progress color, background color, max value, etc.) (library/src/main/res/values/attrs.xml)
3. Set attributes like android:progressDrawable, custom:progressColor, and custom:unreachedColor on the NumberProgressBar element (demo/src/main/res/layout/activity_main.xml)

• Android Canvas API — Provides low-level drawing primitives (arcs, text, paint) needed to render custom progress bar visual without heavy library dependencies
• Custom XML Attributes (attrs.xml) — Allows declarative configuration directly in layout XML, following Android convention for View customization
• ValueAnimator — Enables smooth progress transitions and visual animations at 60 fps with minimal overhead
• Gradle multi-project build — Separates reusable library code from demo application, enabling independent distribution and dependency management

• Custom View via Canvas drawing instead of compound layout

  • Why: Offers maximum control over rendering and visual polish; reduces view hierarchy depth and memory overhead
  • Consequence: Requires manual implementation of touch events, animations, and accessibility; harder to extend visually than a layout-based approach

• Listener-based callback pattern instead of LiveData or reactive streams

  • Why: Keeps library dependency-free and compatible with pre-AndroidX projects; simpler API surface
  • Consequence: No automatic lifecycle awareness; caller responsible for managing listener lifecycle to prevent memory leaks

• Runtime Canvas drawing instead of drawable resources

  • Why: Enables smooth real-time animation and color customization without pre-rendering multiple assets
  • Consequence: Higher CPU usage during animation; less suitable for extremely resource-constrained devices

• Real-time task progress tracking (no integration with WorkManager, AsyncTask, or background services)
• Accessibility features (no TalkBack support, no semantic descriptions)
• Horizontal layout orientation support (implicitly portrait-only based on design)
• Material Design compliance (predates Material Design era; uses custom styling)
• Thread-safe operations from non-UI threads (must call from main thread)

• Synchronous listener callback on UI thread (Medium) — library/src/main/java/com/daimajia/numberprogressbar/NumberProgressBar.java: OnProgressBarListener callbacks are invoked directly within onDraw() or setProgress() on the UI thread; heavy work in the callback blocks animation and rendering
• No null safety checks on listener (Medium) — library/src/main/java/com/daimajia/numberprogressbar/NumberProgressBar.java: If setOnProgressBarListener() is called with null or listener throws exception, no defensive guard prevents crashes during callback invocation
• ****: undefined

No explicit minSdkVersion or targetSdkVersion visible in provided file list—check library/src/main/AndroidManifest.xml for API level constraints. Gradle 2.2.3 is incompatible with modern JDK 11+; modern machines may require JDK 8 or special Gradle wrapping. The library does not expose constructor overloads or XML attribute documentation in README, requiring source inspection for advanced customization. CI only checks builds (.travis.yml) but no unit tests are present.

• Android Custom View — NumberProgressBar extends View and overrides onDraw() with Canvas to render progress bar graphics and text—fundamental pattern for any custom UI component in Android
• Android Attributes and Styling (attr XML) — The library defines custom XML attributes (reached_color, text_size, etc.) in attrs.xml and preset styles via style.xml—essential for making reusable, configurable widgets
• Android AAR (Android Archive) Packaging — The library/ module builds and publishes as an AAR (Android Archive), allowing other apps to reuse compiled bytecode and resources—standard Android library distribution format
• Canvas Drawing & Paint — NumberProgressBar uses Canvas and Paint objects to draw the progress bar background, foreground, and text dynamically in onDraw()—core Android graphics API for 2D rendering
• Property Animation & ValueAnimator — The progress bar animates progress changes smoothly; likely uses ValueAnimator or ObjectAnimator to interpolate progress values over time
• Gradle Android Plugin & Library Publishing — gradle-mvn-push.gradle configures Maven Central artifact publishing; understanding Gradle tasks and Maven coordinates is necessary for building and distributing Android libraries
• Listener Pattern (Observer) — OnProgressBarListener interface allows apps to subscribe to progress events (onProgressUpdate, onFinish)—standard event-driven callback pattern used throughout Android

• Ming-Zhe/NumberProgressBar — Official iOS port of the same NumberProgressBar UI pattern—allows cross-platform feature parity discussions
• kalasoo/NumberProgressBar — Official web/front-end port (JavaScript/HTML5) of NumberProgressBar—shared design language across platforms
• android/platform_frameworks_base — Android framework source; provides default ProgressBar implementation this library improves upon
• square/android-times-square — Similar era custom Android widget library with reusable AAR packaging pattern and attribute-driven styling
• JakeWharton/ActionBarSherlock — Historical reference: mature backport library from same era showing how to publish Android widgets to Maven Central

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 AndroidX migration and update Gradle build configuration

The repo uses outdated Gradle (2.2.3) and jcenter() which was deprecated in 2021. Migrating to modern Gradle, adding AndroidX support, and switching to mavenCentral() would improve compatibility with current Android development standards and ensure the library works with modern Android projects.

• [ ] Update build.gradle to use Gradle 7.x+ (e.g., classpath 'com.android.tools.build:gradle:7.4.0')
• [ ] Replace jcenter() with mavenCentral() in buildscript and allprojects repositories in root build.gradle
• [ ] Add AndroidX dependencies to library/build.gradle if needed
• [ ] Update library/build.gradle compileSdkVersion and targetSdkVersion to API 33+
• [ ] Test demo app builds and runs on modern Android Studio versions
• [ ] Update README with minimum Gradle and Android API requirements

Add comprehensive unit tests for NumberProgressBar.java

The library has no visible test directory. Adding unit tests for the core NumberProgressBar.java component would ensure API stability, prevent regressions, and make contributions safer. Tests should cover progress updates, listener callbacks (OnProgressBarListener), and custom attributes from attrs.xml.

• [ ] Create library/src/test/java/com/daimajia/numberprogressbar/ directory structure
• [ ] Add NumberProgressBarTest.java with tests for: setProgress(), setMax(), getProgress()
• [ ] Add tests for OnProgressBarListener callback firing on progress changes
• [ ] Add tests for custom XML attributes (color styles, text formatting) defined in library/src/main/res/values/attrs.xml
• [ ] Configure library/build.gradle with testImplementation for JUnit4 and Robolectric
• [ ] Run tests in Travis CI via .travis.yml

Add GitHub Actions CI workflow to replace Travis CI

The .travis.yml file suggests Travis CI is the current CI system. GitHub Actions is now the standard for GitHub repos, offers better integration, and is free for public repos. This would modernize the CI/CD pipeline, improve build visibility, and catch issues faster.

• [ ] Create .github/workflows/android-build.yml with matrix testing for multiple API levels (min API 21+, target API 33+)
• [ ] Add build steps: Gradle wrapper validation, Lint checks, library build, and demo app build
• [ ] Add test execution step for library/src/test (from PR #2 above)
• [ ] Add optional step to generate APK from demo app and verify it builds
• [ ] Update README.md badge from Travis CI to GitHub Actions status badge
• [ ] Keep or remove .travis.yml based on deprecation timeline

• Add Android unit tests under library/src/test/ to verify progress value updates, listener callbacks, and text rendering. Currently zero test coverage visible.
• Document all XML attributes (reached_color, reached_height, unreached_color, unreached_height, text_color, text_size, max, progress) in README with code examples, since only visual diagram exists in current README.
• Upgrade Gradle from 2.2.3 to 7.x and update AGP dependency for JDK 11+ compatibility; modern CI/CD pipelines fail with the current setup.

The codebase demonstrates moderate security concerns, primarily related to outdated build tooling and deprecated repository infrastructure. The most critical issue is the use of Gradle 2.2.3 from 2016, which lacks modern security features and vulnerability patches. The reliance on the sunset JCenter repository creates supply chain risks. The library itself (a UI ProgressBar component) has limited attack surface, but build and dependency security require immediate attention. No hardcoded secrets, injection vulnerabilities, or Docker-related issues were identified in the provided file structure. Recommendations focus on updating build infrastructure and implementing modern dependency management practices.

• High · Outdated Gradle Build Tool — build.gradle (buildscript dependencies). The project uses Gradle 2.2.3 (classpath 'com.android.tools.build:gradle:2.2.3'), which was released in 2016 and is significantly outdated. This version contains multiple known security vulnerabilities and lacks critical security patches for dependency resolution and build integrity. Fix: Update to the latest stable Android Gradle Plugin version (currently 8.x series). Review the Android Gradle Plugin release notes for breaking changes and update accordingly.
• High · Insecure Repository Configuration — build.gradle (repositories configuration). The build configuration relies solely on JCenter repository (jcenter()), which was sunset by Bintray in 2021. Using deprecated repositories can lead to dependency resolution failures and exposure to stale or malicious packages if the repository is compromised or repurposed. Fix: Replace JCenter with Google Maven Repository and Maven Central Repository. Update repositories to: google() and mavenCentral().
• Medium · Missing Dependency Pinning — build.gradle. The build.gradle file does not specify exact versions for the Gradle plugin dependency or lock file mechanisms. This could lead to unexpected behavior if build tools are updated in a way that introduces incompatibilities or security issues. Fix: Implement dependency locking using gradle dependency lock plugin or Gradle's native lock mechanism. Pin all critical dependencies to specific versions rather than ranges.
• Medium · No Security Configuration Visible — library/proguard-rules.pro and demo/proguard-rules.pro. The codebase lacks visible security configurations such as ProGuard/R8 obfuscation rules beyond the presence of proguard-rules.pro files. Without verified obfuscation and minification, the compiled APK may expose sensitive logic. Fix: Review and properly configure ProGuard/R8 rules to enable code obfuscation and shrinking for release builds. Ensure sensitive classes and methods are protected.
• Low · Missing Security Headers in CI/CD — .travis.yml. The .travis.yml file exists but its content is not provided for analysis. Travis CI configurations should implement security best practices such as secure environment variables and branch protection. Fix: Review .travis.yml to ensure: 1) No credentials are hardcoded, 2) Sensitive environment variables use Travis CI's encrypted secrets, 3) Only authorized branches can trigger deployments.
• Low · No Apparent Input Validation Documentation — library/src/main/java/com/daimajia/numberprogressbar/NumberProgressBar.java. While this is a UI library, the NumberProgressBar and related components should validate input parameters to prevent unexpected behavior or crashes from malformed data. Fix: Implement input validation for public methods, especially for progress values and listener callbacks. Document expected parameter ranges and error handling behavior.

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.