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/wuhaoyu1990/MagicCamera 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.

AVOID — Looks unmaintained — solo project with stale commits

• Tests present
• ⚠ Stale — last commit 6y ago
• ⚠ Solo or near-solo (1 contributor active in recent commits)
• ⚠ No license — legally unclear to depend on
• ⚠ No CI workflows detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live wuhaoyu1990/MagicCamera repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/wuhaoyu1990/MagicCamera.

What it runs against: a local clone of wuhaoyu1990/MagicCamera — 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 wuhaoyu1990/MagicCamera | Confirms the artifact applies here, not a fork | | 2 | Default branch master exists | Catches branch renames | | 3 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 4 | Last commit ≤ 2054 days ago | Catches sudden abandonment since generation |

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

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

# 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 "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/MainActivity.java" \\
  && ok "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/MainActivity.java" \\
  || miss "missing critical file: Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/MainActivity.java"
test -f "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java" \\
  && ok "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java" \\
  || miss "missing critical file: Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java"
test -f "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/helper/FilterTypeHelper.java" \\
  && ok "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/helper/FilterTypeHelper.java" \\
  || miss "missing critical file: Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/helper/FilterTypeHelper.java"
test -f "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/adapter/FilterAdapter.java" \\
  && ok "Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/adapter/FilterAdapter.java" \\
  || miss "missing critical file: Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/adapter/FilterAdapter.java"
test -f "Project-AndroidStudio/app/build.gradle" \\
  && ok "Project-AndroidStudio/app/build.gradle" \\
  || miss "missing critical file: Project-AndroidStudio/app/build.gradle"

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

MagicCamera is an Android camera app built on OpenGL ES (GPU) rendering that provides 40+ real-time Instagram-style filters, face beauty effects (skin smoothing and whitening), and photo/video editing capabilities. It uses GLSL fragment shaders and lookup table textures (stored in assets/filter/) to apply aesthetic transformations at camera frame rate without CPU bottlenecks. Single Android app module structure: Project-AndroidStudio/app/ contains all source code. Assets-driven filter system: 40+ filter definitions live as .png lookup tables and .jpg masks in src/main/assets/filter/ (amaro_mask1.jpg, brannan_contrast.png, etc.). Custom ':magicfilter' is a local Gradle dependency (likely a JAR or another module) providing the OpenGL rendering engine. No separation of business logic, presentation, or data layers visible.

Android developers building consumer photography apps who need a battle-tested real-time filter pipeline; product teams adding beauty/filter features to camera or social apps; photography app enthusiasts wanting to customize or extend filter chains.

Experimental/partially maintained. The project is 7+ years old (2016 commit visible in README) with no recent CI/test framework (only one ApplicationTest.java stub exists). The AndroidStudio project structure is incomplete (note: 'find it in Project_eclipse' comment suggests dual-project state). No evidence of active development, release tags, or issue management visible in provided data.

High risk for production use: (1) Minimal test coverage (only one test stub; no unit or integration tests), (2) Ancient build config (compileSdkVersion=23, buildToolsVersion=23.0.3 from 2016; targets API 23 which is 8 years old), (3) Single maintainer apparent (wuhaoyu1990), (4) Likely unmaintained (no visible commit history post-2016). Dependency on custom ':magicfilter' module with no version pinning. App would fail modern Play Store requirements.

Nothing visible. No recent commits, open PRs, or active development signals in provided file list. README notes 'This project is still under coding and will be updated later' (from 2016), but no evidence of updates. Last concrete activity was 2016-5-22 AndroidStudio project migration.

Clone and open in Android Studio (recommended over Eclipse per 2016 notes): git clone https://github.com/wuhaoyu1990/MagicCamera.git && cd Project-AndroidStudio && open . (or 'code .') && import into Android Studio. Build: ./gradlew assembleDebug from Project-AndroidStudio/. Note: Will require updating build tools and compileSdkVersion for modern Android.

Daily commands: From Project-AndroidStudio/: ./gradlew installDebug then launch app on device/emulator. Or build APK: ./gradlew assembleDebug (output: app/build/outputs/apk/app-debug.apk). No dev server—this is a standalone Android app. Requires Android device API 18+.

• Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/MainActivity.java — Main entry point of the application; establishes navigation between camera, album, and image editor workflows.
• Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java — Core real-time camera implementation with filter preview pipeline; must understand this to modify camera behavior or add new filters.
• Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/helper/FilterTypeHelper.java — Central registry and factory for all 40+ filter types; essential for adding, removing, or configuring filters.
• Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/adapter/FilterAdapter.java — Bridges filter definitions to UI rendering; controls how filters are displayed and selected in the camera interface.
• Project-AndroidStudio/app/build.gradle — Build configuration and external dependency declarations; manages compileSdkVersion, support libraries, and magicfilter module dependency.
• Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/view/edit/ImageEditFragment.java — Image editor orchestrator handling filter, beauty, and adjustment workflows; primary entry point for post-capture image modifications.
• Project-AndroidStudio/app/src/main/AndroidManifest.xml — Android manifest declaring permissions (camera, storage), activities, and app metadata; required for understanding app capabilities and runtime permissions.

Add a new real-time filter to the camera

1. Add a new filter asset (lookup table or mask image) to Project-AndroidStudio/app/src/main/assets/filter/ (e.g., my_filter.png) (Project-AndroidStudio/app/src/main/assets/filter/)
2. Register the filter in FilterTypeHelper.java by adding a new FILTER_* constant and mapping it to the asset path (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/helper/FilterTypeHelper.java)
3. Add the filter type enum case to FilterTypeHelper and bind its display name and asset path in the factory method (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/helper/FilterTypeHelper.java)
4. The FilterAdapter will automatically pick up the new filter type for UI rendering via the updated FilterTypeHelper registry (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/adapter/FilterAdapter.java)

Add a new image adjustment control to the editor

1. Create a new adjustment handler method or UI control in ImageEditAdjustView.java (e.g., saturation slider) (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/view/edit/adjust/ImageEditAdjustView.java)
2. Add a TwoLineSeekBar widget or standard SeekBar to the view layout to capture user input (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/widget/TwoLineSeekBar.java)
3. Wire the slider callback to modify the underlying image bitmap via the magicfilter rendering pipeline (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/view/edit/adjust/ImageEditAdjustView.java)
4. Integrate the adjustment view into ImageEditFragment.java to ensure it is accessible from the editor tab navigation (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/view/edit/ImageEditFragment.java)

Modify camera capture or preview behavior

1. Edit CameraActivity.java to adjust camera preview size, frame rate, or capture resolution (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java)
2. Declare or modify camera permissions in AndroidManifest.xml (android.permission.CAMERA, WRITE_EXTERNAL_STORAGE) (Project-AndroidStudio/app/src/main/AndroidManifest.xml)
3. Update onPreviewFrame or onPictureTaken callbacks in CameraActivity to apply new filter or processing logic (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java)

Add face detection or beauty algorithm enhancement

1. Extend or modify ImageEditBeautyView.java to add new slider controls for smoothing or skin tone adjustments (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/view/edit/beauty/ImageEditBeautyView.java)
2. Integrate a face detection library (e.g., Google ML Kit or OpenCV) in CameraActivity for real-time face region masking (Project-AndroidStudio/app/src/main/java/com/seu/magiccamera/activity/CameraActivity.java)
3. Add dependency to build.gradle and declare required permissions in AndroidManifest.xml (Project-AndroidStudio/app/build.gradle)

• OpenGL ES (via magicfilter module) — GPU-accelerated real-time filter rendering; essential for smooth 30+ FPS camera preview with 40+ concurrent filters
• Android Camera API (Camera1 / Camera2) — Direct hardware camera access; enables preview frames and capture in CameraActivity
• Bitmap & Canvas rendering — Post-capture image manipulation in editor; simpler CPU-based drawing for non-real-time adjustments
• Android Support Library (appcompat-v7, design) — Material Design components and backward compatibility down to API 18
• Lookup Tables (LUT) & Curve Maps (PNG assets) — Pre-baked filter effects; 100+ assets enable filter variety without runtime computation

• Dependency on magicfilter external module vs. built-in only

  • Why: Decouples filter engine from app logic; allows rapid filter addition and reuse
  • Consequence: Requires compilation of separate native/Java module; increases build complexity but improves maintainability

• GPU-based preview but CPU-based editor adjustments

  • Why: Real-time preview demands GPU; post-capture editing can tolerate CPU latency for simplicity
  • Consequence: Fast camera UX but slower image editor responsiveness; no frame-accurate playback in editor

• Asset-driven filter system (LUTs) vs. algorithmic filters

  • Why: Asset approach allows designers to tune filters without code; supports Instagram-like presets
  • Consequence: Large asset footprint (~50–100 MB); limited dynamic parameter tuning per filter in real-time

• Fragment-based editor

  • Why: undefined
  • Consequence: undefined

No explicit documentation of the ':magicfilter' module location—it's imported via compile project(':magicfilter') but the actual source is not in the file list; likely a sibling directory or separate Git submodule not shown. Build tools are pinned to 2016 (buildToolsVersion=23.0.3); modern Android Studio will auto-upgrade but may introduce incompatibilities in deprecated Camera API usage. Face detection/beauty algorithms likely depend on OpenCV or similar native library (not visible in dependencies)—must investigate magicfilter module for native .so files. App targets API 23 (Android 6.0) but compileSdkVersion=23 is deprecated; runtime permissions (Camera, storage) may not be properly requested on Android 6.0+.

• Lookup Table (LUT) Filters — MagicCamera's core visual effect mechanism: .png/.jpg files in assets/filter/ encode color transformations as 3D LUTs sampled in GLSL; understanding LUT indexing and interpolation is essential to adding or debugging filters.
• OpenGL ES 2.0 Fragment Shaders — All real-time filtering happens in GLSL fragment shaders running on GPU; you must write or modify .glsl code to customize effects or optimize performance.
• SurfaceTexture — Android's bridge between camera frames and OpenGL rendering; camera preview frames are written into a SurfaceTexture, which the shader pipeline samples to apply filters in real-time.
• Texture Blending Modes — Many filters in assets/filter/ (brannan_screen.png, hefesoftlight.png) implement specific blend modes (Screen, Overlay, Soft Light); understanding blend math is required to layer filters or debug color shifts.
• MediaRecorder Video Encoding — App records filtered video in real-time; MediaRecorder setup, surface binding, and frame rate synchronization with OpenGL rendering pipeline are non-trivial and error-prone.
• Face Detection and Skin Smoothing — The 'face beauty' feature (skin smoothing, whitening) likely uses computer vision (OpenCV or similar) to identify face regions before applying selective filters; essential for understanding image editor pipeline.
• Texture Coordinate Mapping — Filters achieve distortion and artistic effects by remapping UV texture coordinates in shaders; understanding st (s,t) coordinate transforms is critical for effects like vignetting (edgeburn.png) and radial blur.

• android-gpuimage/android-gpuimage — Direct predecessor/inspiration (explicitly cited in README 'Idea from:android-gpuimage'); reference implementation of GPU-based image processing pipeline on Android.
• CyberAgent/android-gpuimage — Another widely-used GPU image filter library for Android with similar GLSL + texture-based filter design; drop-in alternative if MagicCamera maintenance stalls.
• Bilibili/DanmakuFlameMaster — Reference for Android OpenGL ES 2.0 rendering patterns and real-time frame processing; shares similar graphics pipeline architecture.
• google/grafika — Google's reference implementation for Android Camera2, OpenGL ES, and MediaCodec; essential for modernizing video recording and camera integration in this project.
• pinterest/PINRemoteImage — Advanced image processing and caching strategies relevant for handling large filter asset pipelines and live preview performance optimization.

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 deprecated Android Gradle plugin to modern DSL

The project uses the old 'com.android.model.application' plugin (Android Gradle Model) which was deprecated in Android Gradle Plugin 3.0 (2017) and removed in 4.0. This prevents developers from using modern Android tooling, applying security patches, and building with recent SDK versions. The build.gradle uses obsolete syntax like 'model { android { } }' instead of current DSL. This is a high-impact change enabling future maintenance.

• [ ] Replace 'apply plugin: "com.android.model.application"' with 'apply plugin: "com.android.application"' in Project-AndroidStudio/app/build.gradle
• [ ] Convert the model {} block to standard android {} block (move compileSdkVersion, buildToolsVersion, defaultConfig, buildTypes outside model wrapper)
• [ ] Update deprecated dependency syntax from 'compile' to 'implementation' and 'testCompile' to 'testImplementation'
• [ ] Verify magicfilter submodule also uses modern Gradle syntax; update if needed
• [ ] Test build with Android Gradle Plugin 7.x or 8.x and update buildToolsVersion to 33+ in the process

Add unit tests for filter image asset loading from assets/filter directory

The project has 60+ filter image assets (masks, lookup tables, curves) in Project-AndroidStudio/app/src/main/assets/filter/ but no tests verify these assets load correctly or validate filter configurations. Add tests to ensure filter assets are present, properly formatted, and can be loaded without corruption. This prevents runtime crashes from missing or corrupted filter resources.

• [ ] Create Project-AndroidStudio/app/src/androidTest/java/com/seu/magiccamera/FilterAssetsTest.java
• [ ] Add test to verify all expected filter image files exist (amaro_mask1.jpg, brannan_process.png, lookup_amatorka_02.png, etc.)
• [ ] Add test to validate filter image dimensions and formats match expected specifications
• [ ] Add test to ensure filter asset files can be opened and read from assets without IOException
• [ ] Run tests with existing ApplicationTest.java as reference for androidTest setup

Add GitHub Actions CI workflow for automated builds and testing

The repository has no CI/CD pipeline (no .github/workflows directory). This means pull requests cannot be automatically validated for compilation errors or test failures. Adding a GitHub Actions workflow to build the Android project on every push/PR will catch regressions early, ensure the deprecated Gradle migration doesn't break builds, and establish quality gates for contributors.

• [ ] Create .github/workflows/android-build.yml with standard Android build steps (setup Java, Android SDK, run ./gradlew build)
• [ ] Configure workflow to trigger on push to main/master and all pull requests
• [ ] Add build cache for Gradle to speed up CI runs
• [ ] Set minSdkVersion test target to 23 (matching current targetSdkVersion) or add matrix testing for multiple API levels
• [ ] Add step to run existing androidTest tests (ApplicationTest.java and new FilterAssetsTest.java) if emulator setup is feasible, or ensure unit tests run

• Add unit tests for filter LUT texture loading: Create a test in src/androidTest/ that verifies each .png/.jpg in assets/filter/ loads without corruption and matches expected dimensions (e.g., 256x256 or 512x512). Approximately 5 filters to validate.
• Update build config to modern Android: Bump compileSdkVersion from 23 to 34, buildToolsVersion to latest, migrate from android.model plugin (deprecated) to standard com.android.application, and add targetSdk=34. Identify and fix any Camera API deprecations.
• Document filter architecture with a design guide: Create a README explaining how to add a new filter (shader + LUT texture), with concrete example: list existing filters (Amaro, Brannan, Hudson, Kelvin) and show step-by-step how to create 'MyFilter' shader + myfilter_map.png. This closes the gap in current documentation.

The codebase has critical security issues stemming from its age and outdated dependencies. The most severe concerns are: (1) Targeting Android 6.0 (API 23) from 2015

• High · Outdated Android SDK and Build Tools — Project-AndroidStudio/app/build.gradle. The project targets Android SDK 23 (Android 6.0, released 2015) with build tools 23.0.3. This is significantly outdated and missing critical security patches. Modern Android versions include numerous security improvements, vulnerability fixes, and better permission models. Fix: Update compileSdkVersion to at least 34 (Android 14) and buildToolsVersion to the latest available. Update targetSdkVersion to 34 or higher to meet current Play Store requirements.
• High · Outdated Support Libraries — Project-AndroidStudio/app/build.gradle. The project uses appcompat-v7:23.3.0 and design:23.3.0, released in 2016. These libraries contain known security vulnerabilities and lack security patches from the past 8+ years. Fix: Update to the latest versions of androidx.appcompat:appcompat and androidx.material:material. Use AndroidX instead of legacy support libraries.
• High · ProGuard Minification Disabled in Release Build — Project-AndroidStudio/app/build.gradle. The release build has 'minifyEnabled = false', meaning the app is not obfuscated. This allows attackers to easily reverse engineer the application code, extract sensitive logic, hardcoded credentials, or API endpoints. Fix: Enable minification by setting 'minifyEnabled = true' in release builds. Configure appropriate ProGuard/R8 rules to protect sensitive code while maintaining functionality.
• Medium · Low Minimum SDK Version — Project-AndroidStudio/app/build.gradle. The minimum SDK version is set to 18 (Android 4.3, released 2013). This includes devices with outdated security models and missing security features like proper enforcement of runtime permissions introduced in Android 6.0. Fix: Increase minSdkVersion to at least 21 or higher (ideally 24+) to ensure users have access to modern security features and reduce the attack surface.
• Medium · Missing Dependency Version Pinning — Project-AndroidStudio/app/build.gradle. The build.gradle uses 'compile' dependencies with specific versions, but the project structure shows it includes a local ':magicfilter' module. Without version pinning and dependency verification, there's risk of transitive dependency vulnerabilities. Fix: Use 'implementation' instead of 'compile' (deprecated). Audit the ':magicfilter' module for vulnerabilities. Consider using dependency locking or constraints to manage transitive dependencies securely.
• Medium · Deprecated Gradle Plugin — Project-AndroidStudio/app/build.gradle. The project uses the deprecated 'com.android.model.application' plugin (Android Gradle Model). This plugin is no longer supported and lacks security updates. Fix: Migrate to the standard Android Gradle Plugin (com.android.application). Update the Gradle DSL to the current format.
• Low · Potential Camera and Media Permissions — Project-AndroidStudio/app/src/main/AndroidManifest.xml. Based on the project description (camera app with video recording and image editing), the app likely requests camera, storage, and microphone permissions. Without reviewing AndroidManifest.xml, there's a risk of excessive permissions or improper runtime permission handling. Fix: Review and implement the principle of least privilege. Request only necessary permissions, use scoped storage for file access (API 30+), and implement proper runtime permission checks with user consent dialogs.
• Low · Missing Security Configuration — Project-AndroidStudio/app/src/main. No network security configuration file (network_security_config.xml) is visible in the file structure. This could allow insecure HTTP connections or improper certificate pinning. Fix: Create a network_security_config.xml to enforce HTTPS, disable cleartext traffic, and implement certificate pinning if the app communicates with backend servers.

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.