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/huangyanbin/smartTable 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 4y 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 huangyanbin/smartTable repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/huangyanbin/smartTable.

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

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "huangyanbin/smartTable(\\.git)?\\b" \\
  && ok "origin remote is huangyanbin/smartTable" \\
  || miss "origin remote is not huangyanbin/smartTable (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 "app/src/main/java/com/bin/david/smarttable/MainActivity.java" \\
  && ok "app/src/main/java/com/bin/david/smarttable/MainActivity.java" \\
  || miss "missing critical file: app/src/main/java/com/bin/david/smarttable/MainActivity.java"
test -f "app/build.gradle" \\
  && ok "app/build.gradle" \\
  || miss "missing critical file: app/build.gradle"
test -f "app/src/main/java/com/bin/david/smarttable/excel/BaseExcel2Table.java" \\
  && ok "app/src/main/java/com/bin/david/smarttable/excel/BaseExcel2Table.java" \\
  || miss "missing critical file: app/src/main/java/com/bin/david/smarttable/excel/BaseExcel2Table.java"
test -f "app/src/main/java/com/bin/david/smarttable/utils/ExcelHelper.java" \\
  && ok "app/src/main/java/com/bin/david/smarttable/utils/ExcelHelper.java" \\
  || miss "missing critical file: app/src/main/java/com/bin/david/smarttable/utils/ExcelHelper.java"
test -f "app/src/main/java/com/bin/david/smarttable/bean/StudentInfo.java" \\
  && ok "app/src/main/java/com/bin/david/smarttable/bean/StudentInfo.java" \\
  || miss "missing critical file: app/src/main/java/com/bin/david/smarttable/bean/StudentInfo.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 1549 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1519d)"
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/huangyanbin/smartTable"
  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).

SmartTable is an Android framework that automatically generates tables from Java objects, data structures, or Excel files with minimal boilerplate configuration. It handles layout calculations, styling, cell formatting, sorting, merging, pagination, and import/export of Excel data—turning annotated POJOs or Column definitions into fully interactive table views. Single-module Android app structure: core table library logic resides in form/ module (imported via compile project(':form')), demo activities live in app/src/main/java/com/bin/david/smarttable/ (13 example Activities like AnnotationModeActivity, MapModeActivity, POIExcelModeActivity), and external libraries (POI, JXL) are bundled in app/libs/.

Android developers building enterprise apps or data-heavy UIs who need rapid table rendering without manual layout management. Specifically useful for dashboards, inventory systems, class schedules, and any app requiring dynamic tabular data display with Excel interoperability.

Actively maintained and production-ready. The project has multiple versions (current 2.2.0), comprehensive demo activities covering 15+ use cases, includes Apache 2.0 license, and uses JitPack for distribution. However, last visible commit age and test suite coverage are not explicitly shown in the file list.

Moderate risk: single maintainer (huangyanbin), external dependencies on POI (poi-3.17.jar) and JXL (jxl.jar) for Excel support add Java library bloat to Android APK, and some dependencies (like SmartRefreshLayout) are optional integrations that could break if unmaintained. No CI/CD pipeline visible in repo structure.

No specific active PRs or commit dates visible in provided data, but the README references version 2.2.0 with array-to-column conversion, form generation, and improved Excel import (supporting colors, fonts, backgrounds, annotations). Documentation notes format configuration changes in 2.0 and active Q&A in a QQ group.

git clone https://github.com/huangyanbin/smartTable.git
cd smartTable
# Open in Android Studio or build via:
./gradlew assembleDebug
# Run demo app on emulator/device
./gradlew installDebug

Daily commands: Open Android Studio, sync Gradle, run configuration 'app', and select target emulator. The MainActivity entry point displays example selection menu. For CLI: ./gradlew build produces APK in app/build/outputs/apk/.

• app/src/main/java/com/bin/david/smarttable/MainActivity.java — Entry point demonstrating all major table generation modes and patterns; essential for understanding the framework's API surface.
• app/build.gradle — Declares all runtime dependencies (POI, JXL for Excel, AppCompat) and build configuration; critical for environment setup.
• app/src/main/java/com/bin/david/smarttable/excel/BaseExcel2Table.java — Abstract base for Excel-to-table conversion logic; core abstraction used by both JXL and POI implementations.
• app/src/main/java/com/bin/david/smarttable/utils/ExcelHelper.java — Utility layer wrapping Excel parsing; handles file I/O and format detection for both JXL and POI backends.
• app/src/main/java/com/bin/david/smarttable/bean/StudentInfo.java — Example data model demonstrating annotation-based table generation conventions; reference pattern for custom data binding.
• app/src/main/java/com/bin/david/smarttable/adapter/ItemAdapter.java — Adapter pattern for item binding in table rows; shows how custom formatting and click handling integrate with table rendering.
• app/libs/poi-3.17.jar — Heavy dependency for Excel parsing (POI library); enables advanced Excel feature support (colors, fonts, images).

Add a New Table Display Mode (Activity)

1. Create a new Activity class extending AppCompatActivity in app/src/main/java/com/bin/david/smarttable/ (app/src/main/java/com/bin/david/smarttable/NewModeActivity.java)
2. Define data model with @SmartColumn annotations (or use array/list) following the StudentInfo pattern (app/src/main/java/com/bin/david/smarttable/bean/NewDataModel.java)
3. Instantiate table and call setData() with your model instances; configure styling via TableConfig API (app/src/main/java/com/bin/david/smarttable/NewModeActivity.java)
4. Add menu entry and navigation in MainActivity to launch the new activity (app/src/main/java/com/bin/david/smarttable/MainActivity.java)

Import and Display an Excel File

1. Choose Excel parser: use JXLExcel2Table for lightweight reads or POIExcel2Table for advanced formatting (app/src/main/java/com/bin/david/smarttable/excel/BaseExcel2Table.java)
2. Call ExcelHelper.startParse() with file path and ExcelCallback to handle parsed table data asynchronously (app/src/main/java/com/bin/david/smarttable/utils/ExcelHelper.java)
3. In the callback onSuccess(), receive the parsed table structure and bind it to the SmartTable UI view (app/src/main/java/com/bin/david/smarttable/excel/ExcelCallback.java)
4. Reference ChoiceExcelActivity or JXLExcelModeActivity for complete implementation patterns (app/src/main/java/com/bin/david/smarttable/ChoiceExcelActivity.java)

Add Custom Cell Formatting (Icons, Colors, Multi-line Text)

1. Define a data model with @SmartColumn on fields; optionally annotate with @ColumnFormat for styling hints (app/src/main/java/com/bin/david/smarttable/bean/StudentInfo.java)
2. Create a custom ItemAdapter or use TableConfig.setContentFormat() callback to intercept cell rendering (app/src/main/java/com/bin/david/smarttable/adapter/ItemAdapter.java)
3. In the formatting callback, manipulate cell data (apply colors, load images via Glide, wrap text) using DrawHelper utilities (app/src/main/java/com/bin/david/smarttable/utils/DrawHelper.java)
4. See AvatorModeActivity or DesktopModeActivity for examples of image and custom formatting integration (app/src/main/java/com/bin/david/smarttable/AvatorModeActivity.java)

Convert JSON Data to a Table

1. Prepare JSON string or file containing array of objects with consistent key-value pairs (app/src/main/java/com/bin/david/smarttable/utils/JsonHelper.java)
2. Call JsonHelper methods to parse JSON into a List<Map<String, Object>> or annotated Java objects (app/src/main/java/com/bin/david/smarttable/utils/JsonHelper.java)
3. Pass converted data to SmartTable.setData() and configure column headers via TableConfig (app/src/main/java/com/bin/david/smarttable/MapModeActivity.java)
4. See MapModeActivity for a complete JSON-to-table example (app/src/main/java/com/bin/david/smarttable/MapModeActivity.java)

1. The core 'form' module is imported via compile project(':form') but not shown in the file list—new contributors must examine that module separately for table rendering logic. 2. Excel import requires both jxl.jar and poi-*.jar in app/libs/—removing either breaks JXLExcelModeActivity or POIExcelModeActivity. 3. Android minSdkVersion is 15 (very old), limiting use of modern APIs; compatibility layer may be fragile. 4. APK includes large libraries (POI, JXL) which inflate package size—recommend gradle-based import alternatives in build.gradle if available.

• Annotation Processing (APT) — @SmartTable and @SmartColumn leverage compile-time annotation processing to auto-generate table metadata—understanding how Java annotations drive code generation is key to extending the framework
• Reflection and Introspection — SmartTable uses reflection to extract field values from POJOs and navigate nested object graphs (e.g., 'class.className')—critical for dynamic table population without manual mapping
• Cell Merging and Span Logic — The framework supports both annotation-driven and automatic cell merging—requires understanding grid coordinate systems, span calculations, and layout recalculation on merge events
• Excel Format Preservation — POI/JXL import preserves colors, fonts, alignment, borders, and images—requires understanding Excel's internal format model (CellStyle, Workbook, Sheet objects) to map to Android Views
• RecyclerView Adapter Pattern — SmartTable likely extends RecyclerView under the hood for efficient scrolling—contributors need to understand ViewHolder recycling, DiffUtil updates, and payload-based partial binding
• Multi-level Object Navigation (Dot Notation) — Column definitions like 'class.className' require deep introspection traversal—implementing safe null-checking, type coercion, and caching for nested paths is non-trivial
• Layout Measurement & Pass System — SmartTable auto-calculates table width/height from content—requires two-pass Android View measurement, custom ViewGroup layout logic, and caching to avoid performance regression

• alibaba/AliSQL — Distributed data visualization and table handling—different domain but shares table-rendering architecture patterns
• tbruyelle/RxPermissions — Permission handling utility for Android; SmartTable apps often need file I/O permissions for Excel import, so this is a companion library
• SimpleMobileTools/Simple-Commons — Android utility library for tables, dialogs, and UI components—provides reusable patterns used in SmartTable-based apps
• number179/TableView — Alternative Android table library; direct competitor solving similar UI rendering problem with different API
• huangyanbin/SmartChart — Sibling library by same author; often used alongside SmartTable for charting data exported from tables

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 instrumented tests for core table rendering logic in smartTable library module

The repo has only one basic ExampleInstrumentedTest.java in the app module. The core 'form' library module (referenced in build.gradle as 'compile project(:form')') lacks any instrumented tests. Given the complexity of table rendering, cell merging, column spanning, and Excel import features, adding comprehensive instrumented tests would catch regressions in core functionality. This is especially critical since the library handles multiple layout modes (Grid, Desktop, Form, Pager, Annotation) and various data sources (arrays, maps, Excel files).

• [ ] Create app/src/androidTest/java/com/bin/david/smarttable/ test classes for table rendering modes
• [ ] Add tests for TableData initialization and layout calculation in different modes (GridMode, DesktopMode, etc.)
• [ ] Add tests for cell merging logic (both annotation-based and auto-merge) to validate TableMergeCell functionality
• [ ] Add tests for Excel import functionality (POI and JXL) to ensure color, font, and cell properties are correctly parsed
• [ ] Run tests with ./gradlew connectedAndroidTest to verify against the minSdkVersion 15 target

Add GitHub Actions CI workflow for automated builds and APK testing

The repo lacks any CI/CD pipeline. With multiple dependencies (Glide, SmartRefreshLayout, Gson, POI), build variants (app, form module), and support for minSdkVersion 15 through targetSdkVersion 25, an automated CI workflow would catch dependency conflicts and build failures early. The presence of app/.gitignore and proguard-rules.pro suggests release builds are important but untested in CI.

• [ ] Create .github/workflows/android-build.yml to run './gradlew build' on push and PRs
• [ ] Add a step to run './gradlew lint' to catch Android lint warnings (especially important given deprecated Android API usage)
• [ ] Add a step to build a release APK with './gradlew assembleRelease' to validate ProGuard rules in proguard-rules.pro
• [ ] Consider adding './gradlew connectedAndroidTest' step to run instrumented tests on Android emulator (after PR #1 is completed)
• [ ] Configure workflow to test on multiple Android SDK levels given the wide minSdk-targetSdk range

Create comprehensive documentation for Excel import features in use.md with code examples

The README lists '导入excel(支持颜色，字体，背景，批注，对齐，图片等基本Excel属性)' and '支持Json数据直接转换成表格' as features, and the file structure shows POIExcelModeActivity.java, JXLExcelModeActivity.java, and ChoiceExcelActivity.java exist. However, the referenced use.md file is incomplete ('持续更新中'). Contributors cannot easily understand how to use Excel import with POI vs JXL, how to handle different Excel formats, or how to configure Excel cell styling preservation.

• [ ] Create or update use.md with a dedicated 'Excel Import' section explaining POI vs JXL trade-offs
• [ ] Add code examples from POIExcelModeActivity.java and JXLExcelModeActivity.java showing how to parse .xls files from assets/c.xls and assets/ic_class.xls
• [ ] Document the Excel cell property support matrix (colors, fonts, background, comments/批注, alignment, images) with API examples
• [ ] Add troubleshooting section for common Excel import issues (e.g., handling META-INF/LICENSE exclusions in packagingOptions)
• [ ] Include JSON conversion example referencing the com.google.code.gson:gson dependency and MapModeActivity.java usage pattern

• Add unit tests for ExampleInstrumentedTest.java: currently only a skeleton exists. Contribute data-driven tests for each demo Activity (AnnotationModeActivity, MapModeActivity, etc.) to verify table rendering output.
• Document the 'form' module API: create Markdown file explaining core Column, TableData, and SmartTable classes since they're referenced in README but their actual signatures live in the hidden form/ module. Include code examples for each public method.
• Create a Gradle-based Excel import alternative: replace bundled POI/JXL jars with Maven Central dependencies in build.gradle to reduce APK size, then update POIExcelModeActivity and JXLExcelModeActivity to test both approaches.

• High · Outdated Apache POI Library with Known Vulnerabilities — app/build.gradle (poi-3.17.jar, poi-scratchpad-3.17.jar), app/libs/. The project uses Apache POI 3.17 (from 2017) which contains multiple known security vulnerabilities including XML External Entity (XXE) injection and other CVEs. This library is used for Excel file parsing without apparent security controls. Fix: Upgrade to the latest POI version (5.x or later). Current version is over 6 years old. Implement XML parsing security controls such as disabling external entity resolution.
• High · Outdated JXL Library — app/libs/jxl.jar, app/build.gradle. JXL.jar is an outdated Excel parsing library with unknown maintenance status and potential security vulnerabilities. The library appears abandoned and may contain unpatched security issues. Fix: Replace JXL with a maintained library like Apache POI (after updating). Remove jxl.jar from the project.
• High · Insecure OkHttp Client Version — app/build.gradle (com.zhy:okhttputils:2.6.2). The project uses OkHttpUtils 2.6.2 from 2016, which is significantly outdated. This version may contain unpatched vulnerabilities in SSL/TLS handling and other HTTP security features. Fix: Update to the latest OkHttp version (4.10.0+) or use official OkHttp library instead of the wrapper. Ensure proper certificate pinning and TLS 1.2+ enforcement.
• Medium · Outdated Android Support Libraries — app/build.gradle (compileSdkVersion 25, targetSdkVersion 25). The project uses Android Support Library 25.3.1 (from 2017) instead of modern AndroidX. These libraries no longer receive security updates. The targetSdkVersion is also outdated at 25. Fix: Migrate to AndroidX and update to latest support libraries. Target SDK should be 33+ for Google Play compliance. Update compileSdkVersion to 33 or later.
• Medium · Outdated Gradle Build Tools — app/build.gradle (buildToolsVersion '26.0.2'). Build tools version 26.0.2 is from 2017 and no longer receives security updates. This can impact the security of the build process. Fix: Update buildToolsVersion to 33.0.0 or later to receive latest security patches and improvements.
• Medium · ProGuard Minification Disabled in Release Build — app/build.gradle (release block). The release build has minifyEnabled set to false, which means the code is not obfuscated. This makes reverse engineering significantly easier and exposes logic, API keys, and proprietary algorithms. Fix: Set minifyEnabled to true in release builds. Configure proper ProGuard rules in proguard-rules.pro to preserve necessary classes while obfuscating sensitive code.
• Medium · Use of Outdated Gson Library — app/build.gradle (com.google.code.gson:gson:2.8.0). Gson 2.8.0 from 2017 is outdated and may contain vulnerabilities. While Gson is generally safe, deserialization of untrusted JSON data could be risky without proper validation. Fix: Update to Gson 2.10+ (latest version). Implement input validation for all deserialized data, especially from network sources.
• Medium · Potential Unsafe HTTP Data Handling — app/src/main/java/com/bin/david/smarttable/NetHttpActivity.java. NetHttpActivity.java suggests network data operations. Combined with outdated OkHttpUtils and no visible certificate pinning configuration, this poses MITM risks. Fix: Implement certificate pinning for network requests. Use HTTPS exclusively. Validate all data received from network sources. Consider using modern Retrofit with OkHttp instead of OkHttpUtils.
• Low · Minimum SDK Version Too Low — undefined. minSdkVersion Fix: undefined

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.