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
• ⚠ Scorecard: marked unmaintained (0/10)
• ⚠ Scorecard: default branch unprotected (0/10)

_{Computed from maintenance signals — commit recency, contributor breadth, bus factor, license, CI, tests, cross-checked against OpenSSF Scorecard}

Android library that provides observable scroll event callbacks on scrollable views (ScrollView, ListView, RecyclerView, WebView). It enables Material Design interactions like collapsing toolbars, parallax effects, and sticky headers by exposing scroll offset and velocity to listeners via ObservableScrollViewCallbacks. Standard Android library structure: gradle-based monorepo with a core library module (likely in library/ or observablescrollview/), sample app modules for Android Studio and Eclipse, and comprehensive documentation under docs/ organized by feature (basic/, advanced/, quick-start/). Build configuration in build.gradle with custom Gradle plugin for Eclipse AAR support.

Android developers building Material Design apps (targeting API 9+) who need to react to scroll position for dynamic UI effects like hiding/showing action bars, translating toolbars, or creating parallax image effects without manually implementing onScrollListener boilerplate.

Production-ready and stable. Published on Maven Central with CI/CD via Travis CI and Wercker, distributed on Google Play Store, and supports back to API level 9. Code is 283KB Java with test coverage tracked via Coveralls. Appears to be in maintenance mode rather than active development (no breaking changes signaled).

Low risk for stable use, but shows signs of slower maintenance: minimal dependency surface (core Android only), single maintainer (ksoichiro), and no visible recent activity in the provided data. The codebase is mature enough that breaking Android framework changes (beyond API 9) are unlikely to affect it, but expect slower response to issues.

No active development visible in provided metadata. Library appears feature-complete for its intended use case (scroll event observation and Material Design toolkit interactions). Historical focus was on sample apps and documentation updates via docs/ directory and CI/CD setup.

git clone https://github.com/ksoichiro/Android-ObservableScrollView.git && cd Android-ObservableScrollView && ./gradlew build. Requires Android SDK (build.gradle references gradle 1.5.0, so API level 9+ support). Open in Android Studio or import Eclipse project via provided eclipseAar plugin configuration.

Daily commands: gradle tasks from build.gradle: ./gradlew build compiles library and samples. ./gradlew test runs unit tests. CI via .travis.yml and Wercker (wercker.yml) for automated APK builds deployed to Play Store. No separate dev server; development is Android project iteration in IDE.

• library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivity.java — Core test activity demonstrating the primary use case of observing scroll events on ScrollView; entry point for understanding the library's basic functionality.
• library/build.gradle — Defines the library module's build configuration, dependencies, and Android SDK targets; essential for understanding the project's compatibility and toolchain.
• library/AndroidManifest.xml — Declares the library's Android manifest configuration and minimum API level requirements; critical for understanding supported Android versions.
• build.gradle — Root build configuration defining the project structure, versioning, and build plugin dependencies; orchestrates all subproject builds.
• README.md — Comprehensive overview of the library's purpose, capabilities, and quick-start guide; must-read for understanding the project's scope and goals.
• docs/reference/supported-widgets.md — Documents which scrollable widgets are supported by the library (ListView, RecyclerView, ScrollView, GridView, WebView); critical for understanding scope.

• ObservableScrollView / Observable*View Classes (Android View framework, Observer pattern) — Core library classes that wrap or extend scrollable widgets; capture scroll events and dispatch to listeners
  • Failure mode: Listeners not invoked if scroll detection logic fails; manifests as unresponsive UI (toolbar doesn't hide, parallax doesn't animate)
• OnScrollListener / OnTouchInterceptionListener Interfaces (Java interfaces, callback pattern) — Callback interfaces that developers implement to react to scroll and touch events
  • Failure mode: Malformed listener implementation can block main thread; scroll frame drops and UI jank
• Test Activities (ScrollViewActivity, ListViewActivity, etc.) (AndroidX Test framework, Espresso assertions) — Instrumented test fixtures that instantiate observable widgets and validate scroll event callbacks
  • Failure mode: Test failures indicate scroll observation broken for a specific widget type
• undefined — undefined

Add Support for a New Scrollable Widget

1. Create a test activity extending the desired scrollable widget (e.g., ListView, RecyclerView) in library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ (library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/NewWidgetActivity.java)
2. Create a corresponding instrumented test class with NewWidgetActivityTest.java following the pattern of ScrollViewActivityTest.java or RecyclerViewActivityTest.java (library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/NewWidgetActivityTest.java)
3. Update docs/reference/supported-widgets.md to list the new widget type (docs/reference/supported-widgets.md)
4. Run tests via ./gradlew build to validate the implementation works across the observed scroll event lifecycle (build.gradle)

Document a New Scroll Pattern or Use Case

1. Create a new markdown file in docs/basic/ for simple patterns or docs/advanced/ for complex ones (e.g., docs/basic/new-pattern.md) (docs/basic/index.md)
2. Add an entry to the appropriate _data.json (docs/basic/_data.json or docs/advanced/_data.json) to include it in navigation (docs/basic/_data.json)
3. Create a corresponding test activity in library/src/androidTest/java demonstrating the pattern (library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/)
4. Include code examples and screenshots in the documentation markdown file (docs/basic/new-pattern.md)

Release a New Version to Maven Central

1. Update version in gradle/version.gradle or gradle.properties (gradle/version.gradle)
2. Run full test suite with ./gradlew build --info to ensure all tests pass (library/build.gradle)
3. Update docs/reference/release-notes.md with changelog entries (docs/reference/release-notes.md)
4. Execute ./gradlew uploadArchives to deploy to Maven Central via gradle/gradle-mvn-push.gradle (gradle/gradle-mvn-push.gradle)
5. Commit, tag, and push to trigger Travis CI build via .travis.yml (.travis.yml)

• Android SDK (API 9+) — Broad device compatibility; library targets Gingerbread and above to support legacy and modern Android devices
• Gradle Build System — Standard Android build automation; enables reproducible builds and Maven Central integration
• Instrumented Tests (androidTest) — Validates scroll behavior on actual Android widgets across different view types; essential for library correctness
• Travis CI — Continuous integration; automatically runs tests and generates coverage reports on every commit

• Single observable pattern for all widget types

  • Why: Unified API makes the library simple and predictable across ListView, RecyclerView, ScrollView, GridView, WebView
  • Consequence: Widget-specific optimizations or behaviors must be implemented in listener code rather than the library itself

• Focus on scroll position observation rather than lazy loading or view recycling

  • Why: Allows library to remain lightweight and widget-agnostic
  • Consequence: Developers must implement custom logic for advanced features like infinite scrolling or image lazy-loading

• Extensive documentation with visual examples and Material Design patterns

  • Why: Helps developers quickly adopt Material Design patterns (flexible toolbars, parallax, sticky headers)
  • Consequence: Maintenance burden to keep docs synchronized with API changes and Android framework updates

• Does not provide built-in animations or view manipulation; library only observes, developers implement UI reactions
• Does not handle touch event interception directly; delegates to scrollable widgets
• Not a RecyclerView adapter or ListView adapter replacement; focuses purely on scroll observation
• Does not support non-Android platforms; Android-specific library only

JaCoCo 0.7.5 pinned in build.gradle (old version; may conflict with modern Gradle); Eclipse AAR plugin (gradle-eclipse-aar-plugin) is legacy and may fail on newer Gradle/Android plugin versions. Build script uses Android Gradle 1.5.0 (very old; likely needs update for modern API levels and AGP). Samples reference 'android-studio' and 'eclipse' separately, implying different build paths. No explicit minSdkVersion visible in provided files, but README claims API 9+ compatibility.

• Observer Pattern (OnScrollListener callbacks) — Core architectural pattern of this library; understanding callback registration and event propagation is essential to using ObservableScrollViewCallbacks correctly.
• Scroll offset and velocity calculation — Scroll events expose both absolute offset (pixel distance from top) and velocity (pixels per frame); required for smooth parallax, scaling, and translation animations in Material Design.
• Toolbar collapsing (flexible space pattern) — Material Design pattern heavily documented here (docs/basic/flexible-space-toolbar.md); binding scroll offset to toolbar height/alpha changes is the primary use case.
• Parallax scrolling — Visual effect where background images scroll slower than foreground content; implemented via scroll offset binding to view translation in docs/basic/parallax-image.md.
• ViewPager scroll synchronization — Non-standard scrollable container requiring custom scroll interception; advanced/viewpager.md shows how to observe cross-page scroll position for coordinated toolbar animations.
• Material Design (Android 5.0+ Lollipop) — Design system and UI patterns (AppBar, elevation, motion) this library was built to support; Toolbar introduction in Lollipop enabled scroll-linked effects previously difficult to implement.
• JaCoCo code coverage reporting — Coverage tooling integrated into build.gradle (JaCoCo 0.7.5) and Coveralls CI badge; understanding coverage metrics helps identify untested scroll scenarios.

• AndroidSlidingUpPanel/AndroidSlidingUpPanel — Alternative Material Design interaction library for bottom sheets and sliding panels, often combined with ObservableScrollView for nested scroll behaviors.
• chrisbanes/cheesesquare — Canonical example app demonstrating Material Design collapsing toolbar and scroll interactions, overlaps with basic use-case documentation here.
• google/material-components-android — Official Material Design components library; newer alternative for scroll-linked behaviors (AppBarLayout with OnOffsetChangedListener replaces ObservableScrollView for modern projects.
• CarlosEsco/MaterialDesignLibrary — Companion Material Design widget library that pairs with scroll observation for complete UI toolkit.
• rtugeek/PagerBottomTabStrip — Demonstrates scroll-linked ViewPager behavior similar to advanced/viewpager.md example in this library.

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 library

The repo has CI/CD configured (Travis, Coveralls) but the library/src directory structure is missing from the file listing, suggesting test coverage may be incomplete. Adding comprehensive unit tests for scroll event observation, callback handling, and supported widget interactions would improve code reliability and increase the coverage badges shown in README.

• [ ] Create library/src/test/java directory structure for JUnit tests
• [ ] Write tests for core scroll observation logic and state transitions
• [ ] Add tests for each supported widget type (ListView, RecyclerView, ScrollView, etc.) as listed in docs/reference/supported-widgets.md
• [ ] Ensure tests achieve >80% coverage and integrate with existing Coveralls reporting

Migrate build.gradle from Gradle 1.5.0 to current Android Gradle Plugin

The build configuration in build.gradle uses Android Gradle Plugin 1.5.0 (from 2015), which is severely outdated and incompatible with modern Android Studio versions. This blocks new contributors from easily building the project and prevents use of modern language features.

• [ ] Update build.gradle classpath 'com.android.tools.build:gradle:1.5.0' to latest stable version (e.g., 8.x)
• [ ] Update gradle/wrapper/gradle-wrapper.properties to use Gradle 8.x wrapper
• [ ] Update deprecated buildscript syntax and API usage (e.g., compileSdkVersion -> android.compileSdk)
• [ ] Test build and CI pipeline (.travis.yml) still passes with updated config

Create missing API reference documentation for library classes

The docs folder contains extensive guides (basic/, advanced/, quick-start/) but docs/reference/index.md lacks concrete API documentation. New contributors need documentation for public classes, methods, and listeners in the library to understand and extend functionality.

• [ ] Document main classes (e.g., ObservableScrollView, ObservableScrollViewCallbacks) in docs/reference/api.md with method signatures
• [ ] Add listener interface documentation and callback parameter descriptions
• [ ] Include code examples for each major public API method referenced in docs/basic/ guides
• [ ] Update docs/reference/index.md to link to the new API reference

• Add instrumented tests under androidTest/ for ObservableScrollViewCallbacks on each view type (ScrollView, ListView, RecyclerView, WebView) verifying scroll offset and velocity values at known scroll distances.
• Document and create sample for ListView scroll observation (advanced/listview.md), parallel to existing ViewPager sample, since library supports multiple scrollable view types but ViewPager example is more prominent.
• Update build.gradle Android plugin versions from 1.5.0 to modern AGP 4.x and bump JaCoCo to latest stable; verify all samples still run on API level 28+ while maintaining API 9 minSdk claim.

This Android library project has significant security concerns centered on severely outdated dependencies and build tools from 2015. The Gradle build tool version (1.5.0), JaCoCo (0.7.5), and related plugins are all 7+ years old and contain known vulnerabilities. The project lacks modern dependency management practices such as dependency locking and vulnerability scanning. While the library itself (an observable scroll view) has low inherent injection/XSS risk due to its domain, the build infrastructure and dependency chain present substantial supply-chain risks. Critical priority should be given to updating the build toolchain and implementing automated security scanning in CI/CD pipelines.

• High · Outdated Gradle Build Tool Version — build.gradle, subprojects buildscript dependencies. The build.gradle file specifies 'com.android.tools.build:gradle:1.5.0', which is severely outdated (released in 2015). This version contains numerous known security vulnerabilities and lacks modern security features, dependency checking, and exploit mitigations. Fix: Update to the latest stable Android Gradle Plugin version (currently 8.x). Review and update all transitive dependencies during the upgrade process.
• High · Outdated JaCoCo Dependency — buildscript dependencies in build.gradle. The classpath includes 'org.jacoco:org.jacoco.core:0.7.5.201505241946', released in 2015. This outdated version may contain unpatched security vulnerabilities in code coverage analysis. Fix: Update JaCoCo to the latest stable version (0.8.8 or newer). Verify compatibility with current Java/Android versions.
• Medium · Outdated Coveralls Gradle Plugin — subprojects buildscript dependencies in build.gradle. The 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.1.0' dependency is outdated and may have unpatched vulnerabilities or compatibility issues with modern build systems. Fix: Update to the latest version of the coveralls gradle plugin. Consider using alternative modern coverage reporting tools if this plugin is no longer actively maintained.
• Medium · Outdated Custom Gradle Plugin — buildscript dependencies in build.gradle. The custom plugin 'com.github.ksoichiro:gradle-eclipse-aar-plugin:0.1.1' appears to be from 2015 or earlier. Outdated custom plugins may have unpatched vulnerabilities or compatibility issues. Fix: Audit or update the gradle-eclipse-aar-plugin to ensure it uses secure practices. Consider whether this Eclipse-specific plugin is still necessary for modern Android development.
• Medium · Missing Dependency Version Pinning — build.gradle (all repositories configuration). The repository structure uses mavenCentral() without explicit version constraints or lock files visible. This could allow transitive dependency vulnerabilities to be introduced during builds if a compromised package version is published. Fix: Implement dependency locking using Gradle's dependency locking feature. Use version constraints and regularly scan dependencies with tools like 'dependencyCheck' or 'OWASP Dependency-Check'.
• Low · No Security Configuration File — Repository root. No evidence of security scanning configuration files (e.g., .snyk, dependencycheck config, or SECURITY.md) in the repository structure. Fix: Add security scanning to the CI/CD pipeline. Include a SECURITY.md file with vulnerability reporting guidelines. Configure automated dependency vulnerability scanning in CI/CD.

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

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

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.

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 ≤ 1835 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/ScrollViewActivity.java" \\
  && ok "library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivity.java" \\
  || miss "missing critical file: library/src/androidTest/java/com/github/ksoichiro/android/observablescrollview/test/ScrollViewActivity.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 "build.gradle" \\
  && ok "build.gradle" \\
  || miss "missing critical file: build.gradle"
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 1835 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1805d)"
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).

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