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/robinhood/ticker 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

• 12 active contributors
• Apache-2.0 licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 2y ago
• ⚠ Concentrated ownership — top contributor handles 73% 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 robinhood/ticker repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/robinhood/ticker.

What it runs against: a local clone of robinhood/ticker — 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 robinhood/ticker | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | 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 ≤ 927 days ago | Catches sudden abandonment since generation |

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

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

# 2. License matches what RepoPilot saw
(grep -qiE "^(Apache-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Apache-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is Apache-2.0" \\
  || miss "license drift — was Apache-2.0 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 "ticker/src/main/java/com/robinhood/ticker/TickerView.java" \\
  && ok "ticker/src/main/java/com/robinhood/ticker/TickerView.java" \\
  || miss "missing critical file: ticker/src/main/java/com/robinhood/ticker/TickerView.java"
test -f "ticker/src/main/java/com/robinhood/ticker/TickerColumnManager.java" \\
  && ok "ticker/src/main/java/com/robinhood/ticker/TickerColumnManager.java" \\
  || miss "missing critical file: ticker/src/main/java/com/robinhood/ticker/TickerColumnManager.java"
test -f "ticker/src/main/java/com/robinhood/ticker/TickerColumn.java" \\
  && ok "ticker/src/main/java/com/robinhood/ticker/TickerColumn.java" \\
  || miss "missing critical file: ticker/src/main/java/com/robinhood/ticker/TickerColumn.java"
test -f "ticker/src/main/java/com/robinhood/ticker/TickerCharacterList.java" \\
  && ok "ticker/src/main/java/com/robinhood/ticker/TickerCharacterList.java" \\
  || miss "missing critical file: ticker/src/main/java/com/robinhood/ticker/TickerCharacterList.java"
test -f "ticker/src/main/java/com/robinhood/ticker/TickerDrawMetrics.java" \\
  && ok "ticker/src/main/java/com/robinhood/ticker/TickerDrawMetrics.java" \\
  || miss "missing critical file: ticker/src/main/java/com/robinhood/ticker/TickerDrawMetrics.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 927 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~897d)"
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/robinhood/ticker"
  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).

Ticker is an Android custom View component that animates scrolling text changes with a smooth odometer-like effect. It handles character-by-character animation between strings using a user-defined character progression array, and automatically optimizes animation direction (wrap-around vs forward) for shortest path. Built by extending the base View class and drawing directly to canvas, it provides memory-efficient, hardware-accelerated text animation without external dependencies. Two-module gradle structure: ticker/ contains the core library (TickerView custom View, TickerUtils helpers, and XML attributes in ticker/src/main/res/values/attrs.xml), and ticker-sample/ provides four demo Activities (MainActivity, SlideActivity, PerfActivity, BaseActivity) showcasing different animation styles and performance configurations.

Android developers integrating stock tickers, price displays, counters, or other numerical/textual updates in financial apps or any app requiring polished animated text transitions. Primary audience is Robinhood's internal teams and external Android developers building finance/trading UIs.

Production-ready and actively maintained. The project has a structured gradle build, CI via Travis, clear versioning (currently 2.0.4), migration documentation for breaking changes, and a dedicated sample app demonstrating usage. Last visible evidence of maintenance includes 2.0 migration docs and example implementations, suggesting ongoing support for an established library.

Low risk for a view library. Zero external dependencies (only Android framework), single-module core implementation (ticker/), and clean separation from samples. Main risks are typical of older Android projects: built with Gradle 4.1.3 (from 2021), potential compatibility issues with latest Android versions, and reliance on older jcenter repository (deprecated). No visible open issue tracking in provided data.

No active development visible in provided data. The repository appears stable post-2.0 release with migration documentation in place. The 2_0_migration.md file suggests version 2.0 introduced breaking API changes that have since been documented and likely stabilized.

git clone https://github.com/robinhood/ticker.git
cd ticker
./gradlew build
./gradlew :ticker-sample:installDebug  # or open in Android Studio and run ticker-sample

Daily commands:

./gradlew :ticker-sample:assembleDebug  # Build debug APK
./gradlew :ticker-sample:connectedAndroidTest  # Run on connected device

Or import into Android Studio and run ticker-sample module directly.

• ticker/src/main/java/com/robinhood/ticker/TickerView.java — Core public API and main custom view; entry point for all text animation logic and custom attributes handling.
• ticker/src/main/java/com/robinhood/ticker/TickerColumnManager.java — Orchestrates per-column animation state and character transitions; critical for understanding how multi-character animations are coordinated.
• ticker/src/main/java/com/robinhood/ticker/TickerColumn.java — Individual column animation logic; handles frame-by-frame rendering and scrolling animation for a single character position.
• ticker/src/main/java/com/robinhood/ticker/TickerCharacterList.java — Defines the character set and animation sequence; determines which characters appear during scroll animations and wrap-around behavior.
• ticker/src/main/java/com/robinhood/ticker/TickerDrawMetrics.java — Encapsulates all drawing calculations and measurements; essential for rendering pipeline and layout correctness.
• ticker/src/main/res/values/attrs.xml — XML attribute definitions for TickerView customization; required reference for understanding public API surface.
• ticker/src/main/java/com/robinhood/ticker/LevenshteinUtils.java — Calculates optimal character paths for animation sequences; affects animation smoothness and performance.

Add a Custom Character Animation Sequence

1. Create a custom TickerCharacterList subclass or instantiate with custom character array (ticker/src/main/java/com/robinhood/ticker/TickerCharacterList.java)
2. Call setCharacterList() on TickerView to apply the custom sequence (ticker/src/main/java/com/robinhood/ticker/TickerView.java)
3. Verify in sample activity to see animation behavior (ticker-sample/src/main/java/com/robinhood/ticker/sample/MainActivity.java)

Modify Animation Speed or Easing

1. Locate animation duration and frame rate settings in TickerView constructor or setters (ticker/src/main/java/com/robinhood/ticker/TickerView.java)
2. Adjust frame timing in TickerColumn's frame update logic (ticker/src/main/java/com/robinhood/ticker/TickerColumn.java)
3. Test with PerfActivity to ensure smooth rendering at new timings (ticker-sample/src/main/java/com/robinhood/ticker/sample/PerfActivity.java)

Create a New Animation Style (e.g., Slide vs. Scroll)

1. Define animation mode constant in TickerView and add XML attribute (ticker/src/main/res/values/attrs.xml)
2. Implement conditional rendering logic in TickerColumn's frame calculation (ticker/src/main/java/com/robinhood/ticker/TickerColumn.java)
3. Add sample activity to demonstrate new animation style (ticker-sample/src/main/java/com/robinhood/ticker/sample/SlideActivity.java)
4. Write unit tests for new animation logic (ticker/src/test/java/com/robinhood/ticker/TickerColumnTest.java)

Optimize Rendering for High-Frequency Updates

1. Review TickerDrawMetrics caching strategy and invalidation logic (ticker/src/main/java/com/robinhood/ticker/TickerDrawMetrics.java)
2. Adjust TickerColumnManager frame batching and update frequency (ticker/src/main/java/com/robinhood/ticker/TickerColumnManager.java)
3. Benchmark with PerfActivity and monitor frame rate (ticker-sample/src/main/java/com/robinhood/ticker/sample/PerfActivity.java)

• Custom Android View (Canvas-based) — Enables pixel-perfect control over animated text rendering; direct canvas drawing allows smooth frame-by-frame transitions without relying on layout inflation overhead.
• Levenshtein Distance Algorithm — Optimizes character paths between old and new strings; prevents unnecessary long scrolls (e.g., Z→A wraps around instead of scrolling forward 25 positions).
• Per-Column State Machine (TickerColumn) — Isolates animation logic per character position; enables independent frame updates and simplifies multi-character synchronization.
• Metric Caching (TickerDrawMetrics) — Avoids repeated font measurement calls; critical for high-frequency text updates to reduce GC pressure and maintain 60 FPS rendering.

• Character-by-character animation (TickerColumn) vs. full-text morphing

  • Why: Per-column approach is simpler to implement and reason about, mirrors odometer visual metaphor.
  • Consequence: Cannot animate word positions; each column animates independently. Requires text width pre-calculation for layout stability.

• Manual frame calculation vs. Android ValueAnimator/ObjectAnimator

  • Why: Direct frame control allows fine-grained animation timing and easing without framework overhead.
  • Consequence: More verbose state management; requires explicit onDraw() calls and invalidation. No automatic lifecycle cleanup.

• Configurable character lists (e.g., 0-9 vs. a-z) vs. fixed alphabet

  • Why: Flexibility for financial, alphabetic, special-character use cases.
  • Consequence: Character sequence is a critical input; incorrect list causes broken animations. Must validate in tests.

• Synchronous text updates vs. queued/async updates

  • Why: Simple, predictable API; developer controls animation scheduling.
  • Consequence: Rapid consecutive calls may cause animation stutters; developer responsible for throttling in high-frequency scenarios.

• Does not animate font size, color, or style changes mid-animation
• Does not handle text layout beyond single-line horizontal scrolling
• Does not provide built-in accessibility features (e.g., TalkBack announcements during animation)
• Does not support RTL (right-to-left) text rendering
• Does not cache or persist animation state across Activity lifecycle events

1. Character array order matters: TickerUtils.provideNumberList() returns '0'-'9' in order; custom arrays must be carefully ordered or animation will skip/wrap unexpectedly. 2) Canvas drawing is synchronous on main thread; very long text or extreme animation durations can cause jank — see PerfActivity for benchmarking. 3) Wrap-around animation assumes circular progression — if your character array isn't circular or has gaps, shortest-path optimization may produce unexpected visual results. 4) The library uses jcenter (deprecated) in build.gradle; mavenCentral migration may be needed for future Gradle versions.

• Custom View Canvas Drawing — Ticker achieves animations by directly drawing to canvas rather than compositing Views; understanding onMeasure(), onDraw(), and invalidate() is core to modifying animation rendering
• Character State Machine Animation — The library models text changes as a state machine where each character progresses through a defined array; grasping this model is essential to understanding TickerUtils and character list design
• Wrap-around Shortest Path Optimization — Ticker automatically chooses forward or backward animation direction to minimize character steps; this non-obvious optimization prevents ugly long animations and is a key feature differentiator
• Interpolator-based Easing — Ticker delegates animation timing to Android Interpolators (e.g., OvershootInterpolator); this decouples animation curve from movement logic and allows users to customize feel without touching core code
• Hardware-accelerated View Invalidation — Ticker uses invalidate() to trigger redraws during animation; understanding view hierarchy invalidation and hardware acceleration flags is critical for performance tuning (see PerfActivity)
• Typeface Measurement and Text Metrics — Ticker must measure character widths dynamically to handle string resizing (e.g., '9999' to '10000'); Paint.getTextBounds() and FontMetrics are used internally to ensure correct layout

• airbnb/lottie-android — Alternative animation library for Android; Ticker is simpler/lighter for text-only scrolling, but Lottie offers richer animation support if text is part of complex UI
• square/picasso — Ecosystem companion from Square (similar era Android library philosophy); shares design ethos of minimal dependencies and canvas-level control
• Kotlin/kotlinx.coroutines — For newer Kotlin-first Android projects using Ticker, coroutines enable cleaner async text update sequencing vs manual ValueAnimator callbacks
• robinhood/ticker-js — If a JavaScript/web version exists, it would be a direct port of this library to DOM/Canvas; useful for web-based trading dashboards
• android/views-widgets-compose — Jetpack Compose evolves Android UI paradigm beyond View subclassing; Ticker may eventually need a Compose wrapper for modern Android development

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 TickerColumnManager animation states

The ticker/src/androidTest directory only contains ApplicationTest.java. Given that TickerColumnManager.java orchestrates the core animation logic for scrolling text transitions, there are no dedicated tests for animation lifecycle, character sequencing, or the Levenshtein-based animation calculations used in LevenshteinUtils.java. This is critical for a library focused on smooth animations.

• [ ] Create ticker/src/androidTest/java/com/robinhood/ticker/TickerColumnManagerTest.java
• [ ] Add tests for character animation sequences using TickerCharacterList
• [ ] Test animation timing and state transitions in TickerColumn.java
• [ ] Test edge cases: empty strings, single characters, resizing animations (e.g., '9999' to '10000')
• [ ] Add tests verifying LevenshteinUtils distance calculations drive correct animation paths

Migrate from jcenter() to Maven Central and add GitHub Actions CI

The build.gradle still uses deprecated jcenter() repository (which is no longer recommended) and the project only has .travis.yml for CI. Modern Android projects should use Maven Central and GitHub Actions. The .travis.yml configuration is likely stale given the Gradle 4.1.3 setup.

• [ ] Update root build.gradle: replace jcenter() with mavenCentral() in repositories block
• [ ] Create .github/workflows/android-ci.yml to run Gradle build, tests, and lint on push/PR
• [ ] Verify ticker/gradle-mvn-push.gradle POM configuration still works with Maven Central
• [ ] Remove or archive .travis.yml with a note about migration
• [ ] Update README with current CI badge and build status

Add comprehensive documentation for TickerDrawMetrics and custom character animation

TickerDrawMetrics.java exists in the codebase but has no corresponding documentation. The README is truncated mid-sentence about character lists. New contributors cannot understand how to customize animations without internal source review. The 2_0_migration.md exists but doesn't document the drawing metrics API.

• [ ] Expand 2_0_migration.md with a section documenting TickerDrawMetrics properties and usage
• [ ] Add JavaDoc comments to TickerDrawMetrics.java explaining measurement calculations
• [ ] Create a new CUSTOMIZATION.md guide showing how to use custom TickerCharacterList arrays
• [ ] Document the complete character animation flow: TickerCharacterList → TickerColumn → TickerColumnManager → TickerDrawMetrics
• [ ] Add code examples in documentation showing how to animate custom character sequences (e.g., non-numeric characters)

• Add unit tests for TickerUtils helper methods (provideNumberList, provideCharacterList, etc.) — currently no visible test coverage in ticker/src/test: Low-hanging fruit to improve code quality and document expected behavior of character progression arrays
• Create a documentation file explaining character array design patterns (when to use wrap-around vs linear, performance implications) with example arrays — currently only basic ASCII mentioned in README: New users struggle with custom character arrays; concrete examples (currency symbols, custom ranges) would reduce confusion
• Add Kotlin extension functions to ticker-sample or as a separate ticker-ktx module (e.g., tickerView.setTextAnimated(value) with defaults) to make the library more idiomatic for Kotlin Android projects: Kotlin adoption in Android is high; provides value-add without touching core Java library and demonstrates modern Android patterns

The ticker codebase has moderate security concerns primarily related to outdated build infrastructure and deprecated dependencies. The main risks are: (1) Gradle 4.1.3 is severely outdated with known vulnerabilities, (2) jcenter() repository is deprecated and no longer maintained, creating supply chain risks, and (3) lack of reproducible build configuration. The actual application code appears to be a simple UI component without obvious injection vulnerabilities or hardcoded secrets. Immediate action required: upgrade Gradle version and remove jcenter() repository. The codebase itself (UI component for text animation) has minimal attack surface but the build pipeline requires modernization.

• High · Outdated Gradle Build Tools — build.gradle (classpath 'com.android.tools.build:gradle:4.1.3'). The project uses Gradle 4.1.3 which was released in 2018 and contains known security vulnerabilities. This version lacks security patches for dependency resolution and build execution vulnerabilities. Fix: Update to the latest stable version of Gradle (7.x or 8.x). Current LTS version is 7.6 or later. Run 'gradle wrapper --gradle-version=7.6' to update the wrapper.
• Medium · Deprecated Repository - jcenter() — build.gradle (repositories block with jcenter()). The project uses jcenter() repository which has been sunset by JFrog since May 2021. This repository is no longer maintained and may not receive security updates for dependencies. Using deprecated repositories increases risk of supply chain attacks. Fix: Remove jcenter() and rely solely on mavenCentral() and google() repositories. Update all build.gradle files to remove jcenter() references.
• Medium · Missing ProGuard Configuration for Library — ticker/proguard-rules.pro (may be incomplete or missing). While ticker-sample includes proguard-rules.pro, the main ticker library module lacks explicit ProGuard/R8 configuration. This could expose internal implementation details and make the library vulnerable to reverse engineering. Fix: Ensure comprehensive ProGuard/R8 rules are defined for the ticker library. Include rules to obfuscate public APIs and protect sensitive logic. Set 'minifyEnabled true' in release builds.
• Low · No Dependency Version Lock File — build.gradle files (gradle.properties shows gradle 4.1.3). The project does not appear to have a gradle.lock file for reproducible builds. This means dependency versions can float and introduce unexpected security vulnerabilities without explicit versioning. Fix: Enable and commit gradle.lock file by running './gradlew dependencies --write-locks'. This ensures deterministic builds and makes supply chain attacks more difficult.
• Low · Travis CI Configuration Present — .travis.yml. The .travis.yml file indicates use of Travis CI for continuous integration. Travis CI has had several security incidents. Ensure sensitive credentials are not exposed in the CI configuration. Fix: Review .travis.yml to ensure no secrets, API keys, or credentials are hardcoded. Use Travis CI's encrypted environment variables feature for any sensitive data. Consider migrating to GitHub Actions for better integration and security.

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.