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/ksoichiro/Android-ObservableScrollView 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 5y ago

• 9 active contributors
• Apache-2.0 licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 5y ago
• ⚠ Single-maintainer risk — top contributor 90% 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 ksoichiro/Android-ObservableScrollView repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/ksoichiro/Android-ObservableScrollView.

What it runs against: a local clone of ksoichiro/Android-ObservableScrollView — 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 ksoichiro/Android-ObservableScrollView | 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 ≤ 1832 days ago | Catches sudden abandonment since generation |

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "ksoichiro/Android-ObservableScrollView(\\.git)?\\b" \\
  && ok "origin remote is ksoichiro/Android-ObservableScrollView" \\
  || miss "origin remote is not ksoichiro/Android-ObservableScrollView (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 "library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivityTest.java" \\
  && ok "library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivityTest.java" \\
  || miss "missing critical file: library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivityTest.java"
test -f "library/build.gradle" \\
  && ok "library/build.gradle" \\
  || miss "missing critical file: library/build.gradle"
test -f "library/AndroidManifest.xml" \\
  && ok "library/AndroidManifest.xml" \\
  || miss "missing critical file: library/AndroidManifest.xml"
test -f "docs/reference/supported-widgets.md" \\
  && ok "docs/reference/supported-widgets.md" \\
  || miss "missing critical file: docs/reference/supported-widgets.md"
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"

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

Android-ObservableScrollView is a library that provides reusable custom views (ObservableScrollView, ObservableListView, ObservableRecyclerView, ObservableWebView) that emit scroll position callbacks, enabling UI interactions like Toolbar translations, parallax effects, and sticky headers. It bridges the gap between raw scroll events and Material Design interactions by letting developers observe scroll velocity and position in real-time. Monorepo structure: library code is in the main directory (core observable view classes), samples/ contains runnable example Activities, and docs/ is a static site with markdown guides (basic/, advanced/, quick-start/) and auto-generated reference. Build uses Gradle with subproject structure (library + samples as separate builds).

Android app developers targeting API 9+ who need to implement Material Design patterns like collapsing toolbars, parallax backgrounds, and scroll-linked animations without writing custom scroll listeners from scratch.

The project is stable and production-ready: it has comprehensive test coverage (JaCoCo integration via build.gradle), CI/CD via Travis, is published to Maven Central, and reached Android Arsenal feature status (#1136). However, the last visible activity appears to be ~2015-era (Gradle 1.5.0, pre-AndroidX), suggesting it's largely maintenance mode rather than actively developed.

Moderate risk: this is a single-maintainer project (ksoichiro) with no visible recent commits or activity, and it predates AndroidX migration (no androidx dependencies in build.gradle). Apps targeting modern Android versions will need to verify compatibility, though the core logic is unlikely to break. Dependency risk is low—it only depends on Android framework APIs.

The repository appears to be in maintenance mode with no active development visible in the provided metadata. The presence of .travis-script.sh and .travis.yml indicates CI was set up, but no recent activity is evident. Documentation is comprehensive and complete.

git clone https://github.com/ksoichiro/Android-ObservableScrollView.git
cd Android-ObservableScrollView
# Build using Gradle (specified in build.gradle)
./gradlew build
# To run samples, open in Android Studio and run the samples subproject

Daily commands: This is an Android library, not a runnable app. To test the library: ./gradlew build builds the AAR. To see it in action: open samples/ subproject in Android Studio and run on an emulator or device via ./gradlew :samples:installDebug.

• library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivityTest.java — Core test suite validating scroll event observation mechanics on the primary ScrollView implementation
• library/build.gradle — Defines library compilation, dependencies, and packaging for the observable scroll framework
• library/AndroidManifest.xml — Declares library permissions and metadata required for scroll interception on Android views
• docs/reference/supported-widgets.md — Documents which scrollable widgets (ListView, RecyclerView, GridView, ScrollView, WebView) are supported by the library
• README.md — Entry point explaining the library's purpose, API compatibility, and typical use cases (Toolbar interactions, Material Design)
• library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/RecyclerViewActivityTest.java — Validates scroll observation on modern RecyclerView, the primary scrollable widget in contemporary Android apps

• Observ — undefined

Add Support for a New Scrollable Widget

1. Create a new test Activity in library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ extending the widget type (e.g., CustomScrollableWidgetActivity.java) (library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/CustomScrollableWidgetActivity.java)
2. Write instrumented test class (CustomScrollableWidgetActivityTest.java) following existing patterns (ScrollViewActivityTest.java, ListViewActivityTest.java) (library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/CustomScrollableWidgetActivityTest.java)
3. Update supported-widgets.md documentation to include the new widget with its compatibility notes (docs/reference/supported-widgets.md)
4. Add touch interception test variant in library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ (e.g., TouchInterceptionCustomWidgetActivityTest.java) (library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/TouchInterceptionCustomWidgetActivityTest.java)

Add a New Documentation Example (e.g., Parallax Effect, Sticky Header)

1. Create markdown file in docs/basic/ or docs/advanced/ describing the pattern (e.g., docs/basic/new-pattern.md) (docs/basic/new-pattern.md)
2. Add entry to docs/basic/_data.json or docs/advanced/_data.json with title, description, and link (docs/basic/_data.json)
3. Include code snippets, layout XML examples, and Java implementation showing scroll listener setup (docs/basic/new-pattern.md)
4. Reference the pattern in docs/overview.md under appropriate use-case section (docs/overview.md)

Release a New Library Version

1. Update version in gradle/version.gradle (VERSION_NAME and VERSION_CODE) (gradle/version.gradle)
2. Document changes in docs/reference/release-notes.md with version, date, and changelog entries (docs/reference/release-notes.md)
3. Run tests and coverage via .travis-script.sh or local gradle build to ensure quality gates pass (.travis-script.sh)
4. Publish artifact to Maven Central via Gradle (gradle-mvn-push.gradle handles coordinates from library/gradle.properties) (gradle/gradle-mvn-push.gradle)

• Android Framework (API 9+) — Provides the foundation for intercept scroll events on all Android scrollable views; broad device compatibility through API level 9 onwards
• Gradle with AAR packaging — Modern Android library build standard; enables Maven Central distribution and seamless Gradle dependency resolution
• Instrumented Tests (androidTest) — Essential for validating scroll event capture on actual Android widgets and touch event interception without mocking
• Travis CI + Coveralls — Automates test execution on pull requests and tracks code coverage metrics to ensure scroll observation reliability

• Single library supports multiple widget types (ScrollView, ListView, RecyclerView, GridView, WebView) with same observer API

  • Why: Reduces boilerplate and learning curve for developers; simplifies integration across heterogeneous layouts
  • Consequence: Library code must handle widget-specific quirks (e.g., ListView header positions differ from RecyclerView), increasing internal complexity

• Touch event interception baked into core scroll observation

  • Why: Enables responsive UI updates (e.g., Toolbar hiding) that depend on both scroll AND touch momentum detection
  • Consequence: Potential for touch event conflicts if app also consumes touches; requires careful listener registration order

• Extensive instrumented tests rather than unit tests

  • Why: Scroll observation is inherently tied to Android framework lifecycle and touch events; mocking is insufficient
  • Consequence: Test execution slower (depends on emulator/device); CI setup more complex than pure JVM testing

• Not a real-time database; does not persist scroll state to backend storage
• Not a UI framework; library only observes and reports scroll metrics—does not render UI components (developers implement Toolbar/parallax themselves)
• Not a gesture recognition library; focuses on scroll events, not swipes, pinch-to-zoom, or other multi-touch gestures
• Not cross-platform (iOS, Flutter, React Native); Android-specific leveraging framework internals

No explicit environment variables required, but note: (1) Gradle version is pinned to 1.5.0 (very old)—modern Android Studio may auto-upgrade, breaking builds; use ./gradlew wrapper to regenerate gradle-wrapper.jar if needed. (2) The library was designed pre-AndroidX (no androidx imports in source), so ViewCompat workarounds may be needed for modern compileSdkVersion targets. (3) JaCoCo is at 0.7.5.201505241946 (2015-era), which may not work with newer Java versions—you may need to upgrade org.jacoco:org.jacoco.core in build.gradle if tests fail.

• Custom View Subclassing — The entire library works by subclassing framework Views (ScrollView, ListView, RecyclerView) and overriding onScrollChanged() to inject listener callbacks—understanding the View lifecycle is essential to extending or debugging the library
• Callback Pattern / Observer Pattern — ObservableScrollViewCallbacks uses the classic observer/callback pattern to decouple scroll event producers from consumers; this is how the library lets Activities react to scroll without tight coupling
• Parallax Scrolling — Multiple samples (ParallaxImageActivity) demonstrate parallax by translating background layers at different rates based on scroll position—a key Material Design effect that relies on real-time scroll callbacks
• Velocity Tracking — ObservableScrollViewCallbacks provides onScrollStateChanged() with velocity information, enabling scroll-linked animations that feel natural by matching scroll momentum rather than just position
• Reflection-based Property Animation — Toolbar translation effects in samples use reflection to dynamically animate View properties (translationY, alpha) without hard-coding for each property—common pattern in older Android code before ObjectAnimator matured
• JaCoCo Code Coverage — Build configuration integrates JaCoCo for test coverage reporting to Coveralls CI; understanding this setup matters when modifying tests or adding new observable view types

• chrisbanes/ObservableScrollView — Older alternative implementation of observable scroll views, predates this repo and influenced the design pattern
• material-components/material-components-android — Google's official Material Design Android library; includes AppBarLayout which provides similar collapsing toolbar behavior natively in modern Android
• vert-x3/vertx-tcp-eventbus-bridge — Not directly related, but demonstrates event bus patterns similar to the callback-based scroll listener architecture used here
• googlesamples/android-architecture — Google's modern Android architecture samples; useful for understanding how to integrate ObservableScrollView into MVVM/MVP patterns on contemporary Android

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 unit tests for ObservableScrollView core classes

The repo has CI/CD setup (Travis CI, Coveralls) but the library/ directory lacks visible test files. Given the complexity of scroll observation and the various supported widgets (ListView, ScrollView, WebView, etc. mentioned in docs/reference/supported-widgets.md), adding unit tests would improve reliability and leverage the existing Coveralls integration.

• [ ] Create library/src/test/java/com/github/ksoichiro/observablescrollview/ directory structure
• [ ] Add unit tests for scroll event callbacks and observer pattern in core classes
• [ ] Add instrumentation tests for supported widgets listed in docs/reference/supported-widgets.md
• [ ] Verify Coveralls badge and coverage metrics update in CI pipeline

Add GitHub Actions workflow to replace/supplement Travis CI

The repo uses .travis.yml (Travis CI) which is older infrastructure. Adding a GitHub Actions workflow would modernize CI/CD, provide faster feedback, and better integrate with GitHub's native features. The .travis-script.sh file indicates custom build logic that should be migrated.

• [ ] Create .github/workflows/android-build.yml with build, test, and coverage jobs
• [ ] Migrate build logic from .travis-script.sh to GitHub Actions
• [ ] Add support for running tests on multiple Android API levels
• [ ] Configure Coveralls integration within the new GitHub Actions workflow

Create CHANGELOG.md with detailed version history

While docs/reference/release-notes.md exists, there's no CHANGELOG.md following standard conventions. Given the library has versioning configured in gradle/version.gradle and published to Maven Central, a detailed CHANGELOG would help users understand what changed between releases and improve discoverability of features.

• [ ] Extract release history from git tags and docs/reference/release-notes.md
• [ ] Create CHANGELOG.md with structured entries (Added, Changed, Fixed, Deprecated) following Keep a Changelog format
• [ ] Include upgrade guides for breaking changes between major versions
• [ ] Link CHANGELOG.md from README.md and reference it in CONTRIBUTING.md

• Add AndroidX compatibility: update build.gradle to include androidx dependencies and migrate imports (e.g., android.support.v4.view → androidx.core.view) to make the library compatible with modern Android apps. This is high-impact and low-risk.
• Write integration tests for ObservableRecyclerView scroll callback timing: the samples/ directory has FlexibleSpaceRecyclerViewActivity but no unit tests verify that OnScrollListener fires at the correct scroll positions. Add Robolectric-based tests under library/src/test/java/.
• Expand docs/basic/sticky-header.md with a RecyclerView example: currently only ScrollView example exists, but RecyclerView is the standard; add a code snippet showing how to implement sticky headers with ObservableRecyclerView and LayoutManager coordinate transforms.

The codebase has significant security concerns primarily stemming from severely outdated build tools and dependencies from 2015. The Gradle build system version (1.5.0) and related build dependencies (JaCoCo, Coveralls plugin) are 8+ years old and lack modern security patches. This creates multiple risks including potential man-in-the-middle attacks during dependency resolution, unpatched vulnerabilities in the build system, and compromised supply chain security. The use of custom/unmaintained plugins further increases risk. Immediate action is required to modernize the build infrastructure. Additionally, the project lacks a vulnerability disclosure policy. These issues are typical of legacy Android projects and require comprehensive updates to meet current security standards.

• High · Outdated Gradle Build Tools — build.gradle (subprojects dependencies). The build.gradle file specifies 'com.android.tools.build:gradle:1.5.0' which is significantly outdated (released in 2015). This version contains known security vulnerabilities and lacks security patches for dependency management, build process vulnerabilities, and Android security features introduced in later versions. Fix: Update to a recent stable version of Android Gradle Plugin (e.g., 7.x or 8.x). Review and test compatibility with the codebase before upgrading.
• High · Outdated JaCoCo Dependency — build.gradle (buildscript dependencies). The project uses org.jacoco:org.jacoco.core:0.7.5.201505241946 from 2015. This version may contain unpatched vulnerabilities and lacks modern security improvements. JaCoCo handles code instrumentation which could have security implications. Fix: Update to the latest stable version of JaCoCo (currently 0.8.x series). Review release notes for security-related fixes.
• Medium · Custom Gradle Plugin from Unknown Source — build.gradle (buildscript dependencies). The dependency 'com.github.ksoichiro:gradle-eclipse-aar-plugin:0.1.1' is a custom plugin with no version control visibility. The source, maintenance status, and security audit status are unclear. Using unmaintained or unverified plugins increases supply chain risk. Fix: Verify the plugin's source code, maintenance status, and security. Consider using only official or widely-audited plugins. Document the rationale for this dependency.
• Medium · Outdated Coveralls Plugin — build.gradle (subprojects buildscript dependencies). The coveralls-gradle-plugin:2.1.0 is from 2015 and likely unmaintained. Third-party plugins handling credentials/tokens for CI/CD integration pose potential security risks if vulnerabilities exist. Fix: Update to the latest version of the coveralls plugin or consider using alternative code coverage reporting solutions maintained by the Gradle ecosystem.
• Medium · Use of HTTP for Maven Central Repository — build.gradle (multiple repository declarations). The build.gradle file uses 'mavenCentral()' which defaults to HTTP in older Gradle versions. While mavenCentral() now uses HTTPS by default in modern Gradle, the outdated Gradle version (1.5.0) may use HTTP, creating man-in-the-middle attack risks. Fix: Update Gradle version to ensure HTTPS is used. Explicitly configure repositories to use HTTPS. Consider using gradle-wrapper properties to enforce minimum Gradle version.
• Low · Missing Security Headers in Documentation — docs/ directory structure. The documentation files in /docs do not show evidence of security best practices documentation (HTTPS enforcement, security headers, etc.) for the hosted website. Fix: Add security headers documentation and ensure the documentation website uses HTTPS, CSP headers, and other security best practices.
• Low · No SECURITY.md or Vulnerability Disclosure Policy — Repository root. The repository lacks a SECURITY.md file or documented vulnerability disclosure policy, making it difficult for security researchers to responsibly report vulnerabilities. Fix: Create a SECURITY.md file with a responsible disclosure policy, contact information, and guidelines for security researchers to report vulnerabilities.

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.