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/danielzeller/Depth-LIB-Android- 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 2y ago

• 9 active contributors
• Distributed ownership (top contributor 28% of recent commits)
• Other licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 2y ago
• ⚠ Non-standard license (Other) — review terms

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

What it runs against: a local clone of danielzeller/Depth-LIB-Android- — 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 danielzeller/Depth-LIB-Android- | Confirms the artifact applies here, not a fork | | 2 | License is still Other | 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 ≤ 584 days ago | Catches sudden abandonment since generation |

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

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

# 2. License matches what RepoPilot saw
(grep -qiE "^(Other)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Other\"" package.json 2>/dev/null) \\
  && ok "license is Other" \\
  || miss "license drift — was Other 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 "lib/src/main" \\
  && ok "lib/src/main" \\
  || miss "missing critical file: lib/src/main"
test -f "app/src/main/java/no/agens/depth/PlayGroundActivity.java" \\
  && ok "app/src/main/java/no/agens/depth/PlayGroundActivity.java" \\
  || miss "missing critical file: app/src/main/java/no/agens/depth/PlayGroundActivity.java"
test -f "lib/build.gradle" \\
  && ok "lib/build.gradle" \\
  || miss "missing critical file: lib/build.gradle"
test -f "app/build.gradle" \\
  && ok "app/build.gradle" \\
  || miss "missing critical file: app/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 584 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~554d)"
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/danielzeller/Depth-LIB-Android-"
  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).

Depth-LIB-Android is a custom shadow and depth rendering library for Android that applies 3D visual depth to Views without relying on Android's default shadow system, which breaks under rotation. It includes a demo app (no.agens.depth) showcasing particle systems (Foam, Smoke, Water), custom Canvas-based rendering, and animation tweens using Facebook Rebound. Dual-module structure: app/ is a demo application with src/main/java/no/agens/depth/ containing example views (BearSceneView, WaterSceneView) and particle systems (Foam, Smoke, Water, Wind); :lib module (referenced in dependencies but not shown in file list) contains the core depth library. Demo focuses on Canvas drawing, animation helpers (TransitionHelper, MenuAnimation), and custom rendering.

Android developers building visually polished UI demos and prototypes who need custom depth effects, shadow rendering, and particle animations that work reliably under view transformations (rotation, translation). Designers and prototype engineers seeking fine-grained control over 3D visual effects.

Experimental/prototype-stage. The library is openly described in the README as 'written as a quick prototype' with visual polish but non-production code quality. Single maintainer (danielzeller), no visible test suite beyond AndroidTest stubs (ApplicationTest.java), Travis CI configured but no recent commit data provided. Not suitable for production without substantial refactoring.

High risk for production use: single maintainer, explicitly stated as prototype code, minimal test coverage (only ApplicationTest.java stub visible), support libraries pinned to Android 28 (deprecated), no dependency on modern AndroidX, and active development status unknown. Breaking API changes likely if revived.

No active development signals visible in the provided file structure. The repo appears dormant—last CI config is .travis.yml (outdated), dependencies frozen at support-v4:28.0.0 and design:28.0.0, and no indication of recent commits or PRs. This is a reference/archived project.

git clone https://github.com/danielzeller/Depth-LIB-Android-.git
cd Depth-LIB-Android-
# Open in Android Studio 2019.2+ (API 21+ required)
# Build via Gradle wrapper: ./gradlew build
# Run demo: ./gradlew installDebug or launch via Android Studio

Daily commands: Load project in Android Studio → Sync Gradle → Run app module on Android 5.0+ device/emulator (minSdkVersion 21). Manual Gradle: ./gradlew app:installDebug then launch no.agens.depth/.RootActivity or PlayGroundActivity.

• lib/src/main — Core library implementation directory—contains the depth effect abstractions and View enhancement logic that all features depend on
• app/src/main/java/no/agens/depth/PlayGroundActivity.java — Primary demo activity showcasing the library's depth effects and animation capabilities—reference implementation for integration patterns
• lib/build.gradle — Library module build configuration defining Android SDK, dependencies, and artifact publishing—controls compilation and library distribution
• app/build.gradle — Application module build configuration with library dependency declaration—shows how to integrate the depth library into projects
• README.md — Project documentation explaining the depth library's purpose, shadow custom implementation, and particle system techniques
• app/src/main/java/no/agens/depth/MenuAnimation.java — Core animation orchestration class demonstrating tweening functions and view transformation patterns central to depth effects
• app/src/main/java/no/agens/depth/TransitionHelper.java — Transition and animation helper utilities providing reusable animation logic for depth view interactions

Add a New Particle Effect System

1. Create a new Java class in app/src/main/java/no/agens/depth/ extending particle physics (follow Water.java, Smoke.java pattern) (app/src/main/java/no/agens/depth/[NewEffect].java)
2. Implement particle update/render loop with Canvas drawing in onDraw() or update() methods (app/src/main/java/no/agens/depth/[NewEffect].java)
3. Create or reuse drawable assets (particle sprites/textures) in app/src/main/res/drawable-xxhdpi/ (app/src/main/res/drawable-xxhdpi/[particle].png)
4. Integrate particle effect into a scene view (e.g., WaterSceneView.java or create new SceneView) (app/src/main/java/no/agens/depth/[NewScene]View.java)
5. Add fragment and layout to expose the effect in the demo UI (app/src/main/res/layout/fragment_[neweffect].xml)

Add a New Animated Scene/Demo Screen

1. Create a new Fragment extending Android Fragment in app/src/main/java/no/agens/depth/ (app/src/main/java/no/agens/depth/[NewScene]Fragment.java)
2. Create corresponding layout XML file with custom view or scene container (app/src/main/res/layout/fragment_[newscene].xml)
3. Implement scene-specific animation orchestration (refer to MenuAnimation.java pattern) (app/src/main/java/no/agens/depth/[NewScene]Animation.java)
4. Register fragment in RootActivity or appropriate navigation controller (app/src/main/java/no/agens/depth/RootActivity.java)
5. Add menu entry to expose the new scene in the app's navigation UI (app/src/main/res/menu/menu_root.xml)

Customize Depth & Shadow Effects

1. Review custom shadow implementation and assets in drawable resources (app/src/main/res/drawable-xxhdpi/actionbar_shadow.png)
2. Create or modify shadow drawable files for specific views or layouts (app/src/main/res/drawable/[custom_shadow].xml)
3. Adjust shadow offsets, blur radius, and color values in drawable definitions (app/src/main/res/drawable/[custom_shadow].xml)
4. Apply custom shadow drawable to target views in layout files using android:background or elevation properties (app/src/main/res/layout/[target_layout].xml)

• Android Canvas API — Direct, efficient pixel-level drawing for custom particle systems, waves, and grain effects; avoids default shadow limitations
• Custom View subclasses (View/SurfaceView) — Enables fine-grained control over rendering, animation timing, and touch event handling for interactive depth effects
• Android Support Library (v4, Design) — Provides backward compatibility (minSdkVersion 21), Material Design components, and Fragment support for modular demo screens
• Facebook Rebound library (inferred) — Physics-based spring animations for natural, elastic tweening of depth and menu transitions (mentioned in README)
• Property animation framework (ValueAnimator, ObjectAnimator) — Time-based animation of view properties (translation, rotation, scale, alpha) with customizable interpolators

• Custom shadow implementation instead of Android elevation/shadows

  • Why: Default Android shadows misbehave when views are rotated; custom solution provides predictable appearance under transformation
  • Consequence: Additional complexity in shadow rendering and manual elevation management, but visual consistency and control gained

• Canvas-based particle systems instead of GPU acceleration (OpenGL/Vulkan)

  • Why: Faster prototyping, simpler code, adequate performance for demo; matches stated design goal 'quick prototype'
  • Consequence: Limited to 2D, potential performance ceiling on older devices; not suitable for heavy 3D particle counts

• Demo app bundled with library in single repo

  • Why: Simplifies showcase and example discovery; single build process for both library and demo
  • Consequence: Library (lib/) and app (app/) are coupled at repo level; changes to one may affect the other's CI/CD

• Minimum SDK 21 (Android 5.0+)

  • Why: Enables Material Design, modern animation APIs, and reasonable baseline for depth effects
  • Consequence: Excludes ~5–10% of Android devices still on KitKat; simplifies API usage

• Real-time 3D depth (not a 3D graphics library; uses 2D Canvas rendering)
• Network/cloud integration (local rendering only)
• Data persistence or state management beyond activity lifecycle

Missing :lib module: The file list does not include the actual library code in a lib/ directory—it's referenced in app/build.gradle as implementation project(':lib') but not provided. You must ensure the :lib folder exists with its own build.gradle. Deprecated support libraries: Dependencies use old support-v4 and design (v28), not AndroidX; migration needed for modern devices. Canvas rendering assumptions: Custom depth is achieved via Canvas painting, not View elevation—may not interop with native elevation shadows. Facebook Rebound dependency: Not listed in app/build.gradle but implied by TransitionHelper/MenuAnimation; may require manual addition.

• Custom View Shadow Rendering via Canvas — The core innovation of this library—Android's elevation/shadow system breaks under rotation, so this repo implements its own shadow painting logic via Canvas drawPath/drawCircle to achieve depth without relying on default shadows
• Particle Systems (Canvas-based) — Foam, Smoke, and Water are custom particle emitters rendered via Canvas loops; understanding spawn rates, lifecycle, and overdraw is essential to modify effects or add new ones
• Physics-Based Animation Tweens (Rebound) — TransitionHelper and MenuAnimation use Facebook Rebound library's spring physics instead of linear tweens for realistic motion; critical for understanding animation behavior in this demo
• View Transformation Composition (Rotation + Translation) — Depth-LIB's main problem statement: default shadows fail under rotation. The library handles composed transforms via custom rendering, relevant for MenuAnimation and TransitionHelper
• Canvas Clipping & Layering — Particle systems and water waves use Canvas.save()/restore() and clipPath() for efficient redraw; understanding invalidation + clipping is key to optimizing custom Views
• Texture-Based Effects (Noise & Grunge Textures) — Assets like noise.png, grunge.png, and noise_scratch.png are blended via Canvas to create organic visual detail in water and foam; texture sampling is a rendering technique used throughout
• Android Support Library Versioning (Deprecated v28) — This repo is frozen at support-v4:28.0.0, now deprecated in favor of AndroidX; understanding this migration path is critical for bringing the library into modern Android development

• danielzeller/Blur-LIB-Android — Sister project by same author providing complementary blur effects for Android Views, often paired with depth effects
• danielzeller/MetaBalls-LIB-Android — Another visual effect library by same author using Canvas-based rendering for morphing blob animations
• facebook/rebound — Dependency used in this repo for physics-based spring animations via TransitionHelper and MenuAnimation
• android/architecture-components-samples — Reference for modern Android View and animation patterns; Depth-LIB uses older approaches that could adopt MVVM/LiveData
• rengwuxian/MaterialEditText — Similar-era Material Design enhancement library for Android Views, good reference for custom View development patterns

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.

Migrate from Support Library to AndroidX

The project currently uses deprecated Android Support Library v28 (com.android.support:) which has reached end-of-life. Migrating to AndroidX equivalents (androidx.appcompat:, androidx.design:*) is critical for future Android compatibility, security patches, and to reduce build warnings. This is a high-impact change that will future-proof the library.

• [ ] Update app/build.gradle: Replace 'com.android.support:support-v4:28.0.0' with 'androidx.appcompat:appcompat:1.x.x'
• [ ] Update app/build.gradle: Replace 'com.android.support:design:28.0.0' with 'androidx.design:design:1.x.x'
• [ ] Add gradle.properties: 'android.useAndroidX=true' and 'android.enableJetifier=true'
• [ ] Update imports in all Java files in app/src/main/java/no/agens/depth/.java from 'android.support.' to 'androidx.*'
• [ ] Test all Activities and Fragments (RootActivity, PlayGroundActivity, WaterFragment, WindFragment) to verify no regressions

Add instrumented unit tests for depth animation core functionality

The ApplicationTest.java file exists but appears to be a stub. The core animation and depth logic (MenuAnimation.java, TransitionHelper.java, RenderableBear.java, RenderableTree.java) lacks test coverage. Adding instrumented tests will validate the library's behavior across different API levels and device configurations.

• [ ] Create app/src/androidTest/java/no/agens/depth/MenuAnimationTest.java to test animation state transitions and lifecycle
• [ ] Create app/src/androidTest/java/no/agens/depth/TransitionHelperTest.java to test transition timing and interpolation
• [ ] Create app/src/androidTest/java/no/agens/depth/RenderableObjectTest.java to test rendering state for Bear and Tree variants
• [ ] Use AndroidJUnit4 runner and add test utilities to verify View depth, shadow calculations, and animation progress
• [ ] Expand app/src/androidTest/java/no/agens/depth/ApplicationTest.java to be a comprehensive integration test

Add GitHub Actions CI workflow for automated builds and tests

The project has .travis.yml (outdated Travis CI config) but needs modern GitHub Actions for reliable CI/CD. A GitHub Actions workflow will automatically validate PRs, run tests on multiple API levels, catch build failures early, and provide faster feedback to contributors. This is critical for maintaining code quality without external CI service dependency.

• [ ] Create .github/workflows/android-build.yml with jobs for: checkout, setup JDK, build app module, build lib module
• [ ] Configure matrix strategy to test against Android API levels 21, 24, 28, and latest (currently 34+)
• [ ] Add step to run ./gradlew test and ./gradlew connectedAndroidTest with emulator setup
• [ ] Add step to run lint checks: ./gradlew lint
• [ ] Add workflow_dispatch and push/pull_request triggers; set minifyEnabled=true in release build to catch ProGuard issues

• Write AndroidInstrumented tests for Foam, Smoke, and Water particle systems in app/src/androidTest/ (currently only ApplicationTest.java stub exists). Verify particle spawn rates, animation timing, and Canvas bounds.
• Add Javadoc comments to all public methods in BearSceneView.java, WaterSceneView.java, and TransitionHelper.java to document the depth rendering API and animation parameters.
• Migrate from deprecated support-v4:28.0.0 and design:28.0.0 to AndroidX equivalents (androidx.appcompat, androidx.design) in app/build.gradle and update import statements accordingly.

The codebase has moderate to high security concerns primarily related to outdated dependencies and SDK versions. The use of deprecated Android Support Library 28.0.0, targeting Android 9.0 (2018), and lack of code obfuscation in release builds are the most critical issues. The project requires modernization to meet current Android security standards and Google Play requirements. No hardcoded secrets, injection vulnerabilities, or infrastructure issues were identified in the visible codebase, but the outdated platform components present significant risk for users.

• High · Outdated Android Support Libraries — app/build.gradle - dependencies section. The project uses Android Support Library version 28.0.0, which is deprecated and no longer receives security updates. Google has migrated to AndroidX, and the support library is no longer maintained. This may expose the application to known security vulnerabilities in the support library components. Fix: Migrate to AndroidX libraries (androidx.appcompat:appcompat, androidx.design:design) and update to the latest stable versions. Run Android Studio's migration tool: Refactor > Migrate to AndroidX.
• High · Outdated Compile and Target SDK Version — app/build.gradle - compileSdkVersion and targetSdkVersion. The project targets Android SDK 28 (Android 9.0), released in 2018. Modern security standards require targeting recent Android versions. Google Play requires apps to target Android 14 (API 34) or higher as of 2024. This exposes users to unpatched security vulnerabilities and missing modern security features. Fix: Update compileSdkVersion and targetSdkVersion to at least 34 (Android 14). Review and implement runtime permissions (API 23+), scoped storage (API 30+), and other security features.
• Medium · ProGuard Obfuscation Disabled in Release Build — app/build.gradle - release buildTypes. The release build has minifyEnabled set to false, meaning code obfuscation is disabled. This makes reverse engineering the application significantly easier, exposing proprietary logic, algorithms, and potentially hardcoded credentials to attackers. Fix: Enable code obfuscation by setting minifyEnabled to true. Configure appropriate ProGuard/R8 rules in proguard-rules.pro to protect sensitive code while maintaining app functionality.
• Medium · Low Minimum SDK Version — app/build.gradle - minSdkVersion. The minimum SDK version is set to 21 (Android 5.0), released in 2014. This version predates modern security features like hardware-backed keystore support, improved SSL/TLS defaults, and other security enhancements available in newer APIs. Fix: Increase minSdkVersion to at least 24 (Android 7.0) or higher to ensure users have access to modern security features and reduce the attack surface of legacy API vulnerabilities.
• Medium · Lint Warnings Suppressed with abortOnError false — app/build.gradle - lintOptions. The lintOptions configuration sets abortOnError to false, which suppresses critical lint warnings during build. This could hide security issues, manifest problems, or API misuse that the Android lint checker identifies. Fix: Remove or set abortOnError to true and address all lint warnings. Use specific lint disable rules only when absolutely necessary and well-documented.

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.