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/Jacksgong/JKeyboardPanelSwitch 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 6y ago

• 4 active contributors
• Apache-2.0 licensed
• CI configured
• ⚠ Stale — last commit 6y ago
• ⚠ Small team — 4 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 94% of recent commits
• ⚠ No test directory 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 Jacksgong/JKeyboardPanelSwitch repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Jacksgong/JKeyboardPanelSwitch.

What it runs against: a local clone of Jacksgong/JKeyboardPanelSwitch — 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 Jacksgong/JKeyboardPanelSwitch | 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 ≤ 2119 days ago | Catches sudden abandonment since generation |

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Jacksgong/JKeyboardPanelSwitch(\\.git)?\\b" \\
  && ok "origin remote is Jacksgong/JKeyboardPanelSwitch" \\
  || miss "origin remote is not Jacksgong/JKeyboardPanelSwitch (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/main/java/cn/dreamtobe/kpswitch/IPanelConflictLayout.java" \\
  && ok "library/src/main/java/cn/dreamtobe/kpswitch/IPanelConflictLayout.java" \\
  || miss "missing critical file: library/src/main/java/cn/dreamtobe/kpswitch/IPanelConflictLayout.java"
test -f "library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchPanelLayoutHandler.java" \\
  && ok "library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchPanelLayoutHandler.java" \\
  || miss "missing critical file: library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchPanelLayoutHandler.java"
test -f "library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchFSPanelLayoutHandler.java" \\
  && ok "library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchFSPanelLayoutHandler.java" \\
  || miss "missing critical file: library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchFSPanelLayoutHandler.java"
test -f "library/src/main/java/cn/dreamtobe/kpswitch/IFSPanelConflictLayout.java" \\
  && ok "library/src/main/java/cn/dreamtobe/kpswitch/IFSPanelConflictLayout.java" \\
  || miss "missing critical file: library/src/main/java/cn/dreamtobe/kpswitch/IFSPanelConflictLayout.java"
test -f "app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java" \\
  && ok "app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java" \\
  || miss "missing critical file: app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java"

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

JKeyboardPanelSwitch is an Android library that resolves layout conflicts and prevents UI flickering when switching between the soft keyboard and custom emoji/function panels (as used in WeChat). It intelligently detects keyboard height, manages panel visibility, and adjusts parent layouts to eliminate the visual jank that typically occurs during these transitions. Single-module Maven library structure: core logic in library/ directory with handlers (KPSwitchRootLayoutHandler, KPSwitchPanelLayoutHandler) and utilities (KeyboardUtil for keyboard height calculation). Companion app/ module contains 5 demo Activities (ChattingResolvedActivity, ChattingResolvedFragmentActivity, etc.) showcasing fullscreen and non-fullscreen integration patterns.

Android developers building messaging or chat applications who need to handle smooth keyboard-to-panel switching without layout displacement. Used by developers integrating features like emoji pickers and quick-action panels alongside soft keyboard input.

Production-ready and moderately mature. The library has been open-source for years with multiple stable releases (currently at 1.6.1+), includes comprehensive CI via Travis CI (.travis.yml present), and demonstrates real-world battle-testing from WeChat's implementation. However, commits appear less frequent in recent years, suggesting stable maintenance rather than active feature development.

Low-to-moderate risk: single maintainer (Jacksgong) with no visible alternate maintainers, targeting older Android API levels (minSdkVersion 14, now legacy), and dependency on deprecated Android Support libraries (androidx migration not yet visible). The library relies on window layout callback interception which is fragile across Android OS versions.

Library appears in maintenance mode. No active feature development visible in the file snapshot. Documentation is comprehensive with separate tutorials for non-fullscreen (NON-FULLSCREEN_TUTORIAL.md) and fullscreen (FULLSCREEN_TUTORIAL.md) themes, plus bilingual README files suggesting recent polish.

Check README for instructions.

Daily commands:

./gradlew :app:run  # Via Android Studio or
./gradlew :app:assembleDebug && adb install app/build/outputs/apk/debug/jkpswitch-debug.apk

• library/src/main/java/cn/dreamtobe/kpswitch/IPanelConflictLayout.java — Core interface that defines the contract for handling keyboard/panel conflict resolution; all panel layouts must implement this
• library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchPanelLayoutHandler.java — Main handler that orchestrates the keyboard-to-panel switching logic for non-fullscreen mode; central to the library's functionality
• library/src/main/java/cn/dreamtobe/kpswitch/handler/KPSwitchFSPanelLayoutHandler.java — Handler specialized for fullscreen mode panel switching; provides alternative implementation for immersive layouts
• library/src/main/java/cn/dreamtobe/kpswitch/IFSPanelConflictLayout.java — Interface for fullscreen-specific panel conflict resolution; extends core functionality for immersive experiences
• app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java — Primary demo implementation showing resolved keyboard/panel conflict; reference implementation for developers integrating the library
• library/build.gradle — Library build configuration defining dependencies and publishing targets; essential for understanding library scope and Android API requirements
• README.md — Complete documentation of the keyboard-panel switching solution; must read to understand the library's purpose and usage patterns

Implement Keyboard/Panel Switching in a New Activity

1. Create a new activity layout XML extending IPanelConflictLayout in your activity (app/src/main/res/layout/activity_chatting_resolved.xml)
2. In your activity, extend the appropriate handler (KPSwitchPanelLayoutHandler for standard or KPSwitchFSPanelLayoutHandler for fullscreen) (app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java)
3. Initialize the handler in onCreate() passing the root layout and panel height target (app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java)
4. Register input listeners on EditText to trigger keyboard/panel visibility changes (app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java)

Add a New Emoji or Function Panel

1. Create a new panel layout XML file in res/layout with your panel content (app/src/main/res/layout/merge_panel_content.xml)
2. Implement IPanelHeightTarget interface in your activity to define panel height (library/src/main/java/cn/dreamtobe/kpswitch/IPanelHeightTarget.java)
3. Add panel view reference to your activity's layout and connect via handler's showPanel() method (app/src/main/res/layout/activity_multiple_sub_panel_chatting_resolved.xml)
4. Reference the sample multi-panel implementation for handling multiple emoji/function panels (app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java)

Migrate from Unresolved to Resolved Layout

1. Compare unresolved vs resolved layout to identify the placeholder needed (app/src/main/res/layout/activity_chatting_unresolved.xml)
2. Add a placeholder FrameLayout below your EditText with the expected panel height (app/src/main/res/layout/activity_chatting_resolved.xml)
3. Follow the tutorial for your mode (fullscreen or non-fullscreen) to integrate the handler (FULLSCREEN_TUTORIAL.md)
4. Test with the resolved demo activity as reference implementation (app/src/main/java/cn/dreamtobe/kpswitch/demo/activity/ChattingResolvedActivity.java)

• Android InputMethodManager — Needed to control keyboard visibility and listen for keyboard height changes; essential for detecting when to show/hide panels
• ViewTreeObserver & OnGlobalLayoutListener — Used to monitor layout changes and measure actual keyboard/panel heights at runtime; no other Android API provides this visibility
• Handler & Runnable — Manages timing between keyboard hide and panel show to prevent visual jarring; necessary for smooth 300ms transitions
• Support Library (AppCompat, RecyclerView) — Provides backward compatibility to API 14; enables use in legacy Android applications

• Separate handlers for fullscreen vs non-fullscreen modes

  • Why: Fullscreen activities (FLAG_LAYOUT_IN_SCREEN) have different keyboard/panel behavior due to how the system composites windows
  • Consequence: Developers must choose correct handler class; wrong choice leads to incorrect layout behavior in immersive mode

• Placeholder-based height management instead of dynamic measurement only

  • Why: Reduces layout jank by allocating space upfront; prevents RecyclerView jump when panel appears
  • Consequence: Developers must explicitly declare expected panel height in layouts; less flexible but more predictable visual experience

• Global layout listener for keyboard height detection

  • Why: InputMethodManager does not expose keyboard height directly; only alternative is layout observation
  • Consequence: Small overhead on every layout pass; acceptable because fires infrequently (only on keyboard/panel transitions)

• Manual caching of keyboard height between show/hide cycles

  • Why: Avoids remeasuring on every toggle; improves transition smoothness
  • Consequence: Height cache can become stale if keyboard changes (rare scenario); developers should understand cache semantics

• Does not handle multi-window or split-screen scenarios
• Does not provide automatic panel size calculation; developers must specify heights
• Does not support animated transitions between keyboard and panel
• Does not work with hardware keyboards; focuses only on soft input method
• Does not manage panel content creation; library handles layout switching only

WindowManager layout callback timing is highly sensitive across Android versions—keyboard height calculations may fail silently on devices with custom ROM keyboard implementations. The library assumes a single root FrameLayout or container; deeply nested layouts may not receive layout updates correctly. Fragment-based implementations (ChattingResolvedFragmentActivity) require manual lifecycle wiring—the library does not auto-manage Fragment creation/destruction. Material Design and Jetpack Compose compatibility untested. Support Library dependencies (not androidx) means apps must avoid androidx migration conflicts.

• Window Layout Inflation & ViewTreeObserver callbacks — This library hooks into ViewTreeObserver.OnGlobalLayoutListener to detect keyboard show/hide without polling; understanding this callback chain is essential to extending the library
• Soft Input Method Manager (IMM) visibility states — The library infers keyboard visibility by comparing screen dimensions before/after; knowing IMM state machine (showing vs. hidden) clarifies why this heuristic works
• Android Window Insets (translucent statusbar, fitsSystemWindows) — Layout conflicts occur differently under fitsSystemWindows=true vs. false; the two separate tutorials exist because inset handling changes root layout behavior
• FrameLayout measure & layout cycle optimization — The library reduces layout pass thrashing by adjusting container height once per keyboard transition rather than frame-by-frame; inefficient measure() calls cause the flickering this library prevents
• Panel vs. keyboard mutual exclusivity pattern — Core innovation: showing emoji panel auto-hides keyboard and vice versa using the same height calculations; this state machine prevents overlapping UI

• google/material-components-android — Provides Material Design BottomSheet which handles keyboard conflicts natively in newer Android; alternative for modern apps
• InsertKoinIO/koin — No direct relation but commonly paired with this library for dependency injection in Android chat applications
• android/architecture-samples — Google's architecture reference; useful for modernizing this codebase from legacy Android Support Library to MVVM + Jetpack
• chrisbanes/insetter — Modern alternative using WindowInsetsCompat for handling system insets (keyboard, status bar); addresses similar problem with contemporary APIs

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 instrumentation tests for keyboard/panel switching scenarios

The repo lacks automated UI tests for its core functionality (keyboard & panel switching). Currently only demo activities exist. Adding instrumentation tests would validate the solution works across different Android versions (API 14+) and screen configurations, catching regressions early.

• [ ] Create app/src/androidTest/java/cn/dreamtobe/kpswitch/demo/ directory structure
• [ ] Add instrumentation tests for ChattingResolvedActivity.java covering: keyboard show/hide, panel toggle, and layout conflict scenarios
• [ ] Add tests for ChattingResolvedFragmentActivity.java to verify Fragment lifecycle compatibility
• [ ] Configure androidTest dependencies in app/build.gradle (AndroidJUnit4, Espresso)
• [ ] Verify tests run on API 14 (minSdkVersion) and modern API levels

Create GitHub Actions CI workflow replacing Travis CI

The repo uses .travis.yml (outdated), but lacks a GitHub Actions workflow. This modernizes CI, improves build speed, and integrates better with GitHub. The workflow should build the library and run tests across multiple Android API levels.

• [ ] Create .github/workflows/android-ci.yml with gradle build steps
• [ ] Configure matrix testing for minSdkVersion (API 14) and modern APIs (API 28+)
• [ ] Add steps to build library module and app module with proper caching
• [ ] Ensure ProGuard rules (app/proguard-rules.pro) are validated in CI
• [ ] Add workflow status badge to README.md

Extract and document the library's public API with code examples

While FULLSCREEN_TUTORIAL.md and NON-FULLSCREEN_TUTORIAL.md exist, there's no dedicated API reference document. The library module's core classes (referenced in demo activities) lack inline documentation of key methods. This makes it harder for new contributors to understand what to extend.

• [ ] Review library/src/main/java structure to identify core public classes (e.g., KPSwitchPanelManager, KPSwitchConflictUtil)
• [ ] Create API_REFERENCE.md documenting: class hierarchy, public methods, lifecycle hooks, and required callbacks
• [ ] Add JavaDoc comments to public methods in library classes (minimum @param, @return, @throws)
• [ ] Include code snippets in API_REFERENCE.md showing common usage patterns from demo activities
• [ ] Cross-reference API_REFERENCE.md from README.md and tutorial files

• Add unit tests for KeyboardUtil#calculateKeyboardHeight() with mock WindowInsets; currently no test files visible in repo structure
• Migrate from Android Support Library (27.1.1) to androidx equivalents (androidx.recyclerview:recyclerview, androidx.appcompat:appcompat) to future-proof the library
• Document the exact Android OS versions and keyboard implementations tested against; add device compatibility matrix to README.md given complexity of keyboard detection

The codebase is a well-structured Android library project with moderate security concerns. The primary vulnerabilities are outdated dependencies (Android Support Library instead of AndroidX), disabled code obfuscation in release builds, and an extremely low minimum SDK version targeting devices from 2011. These issues increase the attack surface and make reverse engineering easier. The project lacks obvious injection vulnerabilities, hardcoded secrets, or infrastructure misconfigurations, but dependency and build configuration updates are critical for improving security posture.

• High · Outdated Android Support Library Dependencies — app/build.gradle - dependencies section. The project uses com.android.support libraries version 27.1.1, which is deprecated and no longer maintained by Google since 2019. These libraries no longer receive security updates and bug fixes. Google migrated to AndroidX as the official replacement. Fix: Migrate to AndroidX libraries (androidx.appcompat:appcompat and androidx.recyclerview:recyclerview) and use the latest stable versions.
• Medium · Minification Disabled in Release Build — app/build.gradle - buildTypes.release section. The release build has minifyEnabled set to false, which means ProGuard/R8 obfuscation is disabled. This makes the compiled APK larger and easier to reverse engineer, exposing more implementation details and potentially intellectual property. Fix: Set minifyEnabled to true and ensure proper ProGuard rules are configured in proguard-rules.pro to enable code obfuscation and shrinking for release builds.
• Medium · Low Minimum SDK Version — app/build.gradle - defaultConfig section. The project targets minSdkVersion 14 (Android 4.0 IceCreamSandwich released in 2011). This is extremely outdated and exposes the application to numerous security vulnerabilities present in older Android versions. Modern standards recommend minSdkVersion 21 or higher. Fix: Increase minSdkVersion to at least 21 (Android 5.0 Lollipop) or higher to benefit from modern security features and reduce exposure to known vulnerabilities.
• Low · IDE Configuration Files Tracked in Version Control — .idea/ directory structure. IDE configuration files (.idea directory and related files) are present in the repository. While .gitignore exists, having IDE-specific configurations committed can expose development environment details and local settings that may contain sensitive information. Fix: Ensure .idea/ directory is properly added to .gitignore to prevent IDE configuration files from being tracked in version control.

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.