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/grantland/android-autofittextview 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 7y ago

• 5 active contributors
• Apache-2.0 licensed
• ⚠ Stale — last commit 7y ago
• ⚠ Single-maintainer risk — top contributor 93% of recent commits
• ⚠ No CI workflows detected
• ⚠ 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 grantland/android-autofittextview repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/grantland/android-autofittextview.

What it runs against: a local clone of grantland/android-autofittextview — 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 grantland/android-autofittextview | 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 ≤ 2703 days ago | Catches sudden abandonment since generation |

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "grantland/android-autofittextview(\\.git)?\\b" \\
  && ok "origin remote is grantland/android-autofittextview" \\
  || miss "origin remote is not grantland/android-autofittextview (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/me/grantland/widget/AutofitHelper.java" \\
  && ok "library/src/main/java/me/grantland/widget/AutofitHelper.java" \\
  || miss "missing critical file: library/src/main/java/me/grantland/widget/AutofitHelper.java"
test -f "library/src/main/java/me/grantland/widget/AutofitTextView.java" \\
  && ok "library/src/main/java/me/grantland/widget/AutofitTextView.java" \\
  || miss "missing critical file: library/src/main/java/me/grantland/widget/AutofitTextView.java"
test -f "library/src/main/java/me/grantland/widget/AutofitLayout.java" \\
  && ok "library/src/main/java/me/grantland/widget/AutofitLayout.java" \\
  || miss "missing critical file: library/src/main/java/me/grantland/widget/AutofitLayout.java"
test -f "library/src/main/res/values/attrs.xml" \\
  && ok "library/src/main/res/values/attrs.xml" \\
  || miss "missing critical file: library/src/main/res/values/attrs.xml"
test -f "library/build.gradle" \\
  && ok "library/build.gradle" \\
  || miss "missing critical file: library/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 2703 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~2673d)"
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/grantland/android-autofittextview"
  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).

AutoFitTextView is an Android library that automatically resizes TextView text size to fit perfectly within its bounds, ensuring text never overflows or underutilizes available space. It provides three integration points: AutofitHelper (attach to any TextView in code), AutofitLayout (wrap any text-displaying View in XML), and AutofitTextView (a drop-in TextView subclass with XML attribute support for minTextSize). The core algorithm calculates the largest font size that allows all text to display without clipping. Two-module Gradle build: library/ contains the core (AutofitHelper.java, AutofitTextView.java, AutofitLayout.java in me.grantland.widget package) and XML attribute definitions (library/src/main/res/values/attrs.xml), while sample/ demonstrates usage with SampleActivity.java and layout examples in sample/src/main/res/layout/ and sample/src/main/res/layout-land/. No tests, no CI, pure source with resource assets.

Android app developers building UIs with dynamic text content (search results, chat messages, product titles) who need responsive text sizing without manual dimension calculations or custom drawing code. Used by teams wanting to fill variable container sizes elegantly without hardcoding font sizes per screen.

Moderately mature: published to Maven Central with semantic versioning (0.2.x), supports minSdkVersion 14 through targetSdkVersion 23, but shows signs of age—last visible commit activity in early 2010s era (Gradle 2.0.0 is from 2015), and no test files present in the repo. Not abandoned but not actively maintained; suitable for stable production use if requirements haven't changed dramatically.

Low risk for basic use cases: single maintainer (grantland), minimal external dependencies (only Android SDK), but zero automated test coverage is concerning for long-term maintenance. No visible CI configuration and lack of recent commits mean bug fixes or Android version compatibility patches rely on old Gradle tooling (classpath 'com.android.tools.build:gradle:2.0.0' is severely outdated). No dependency management risk since it has none, but integrating into modern projects (Gradle 7+, Android 12+) may require build.gradle updates.

No active development is visible from the repository structure; the project appears stable but unmaintained. No PRs, milestones, or recent commit history are evident. The last meaningful activity was publishing v0.2.x to Maven Central.

Clone the repo and build the library module:

git clone https://github.com/grantland/android-autofittextview.git
cd android-autofittextview
./gradlew build

To run the sample app: ./gradlew :sample:installDebug (requires Android emulator or device).

Daily commands: Build and install the sample: ./gradlew :sample:installDebug deploys to connected emulator/device. Run ./gradlew :library:build to build just the library AAR without sample. No server, no CLI—this is a library consumed by other projects.

• library/src/main/java/me/grantland/widget/AutofitHelper.java — Core engine that implements the text-resizing algorithm; all other components depend on this logic
• library/src/main/java/me/grantland/widget/AutofitTextView.java — Primary public API widget that extends TextView; the most direct entry point for users
• library/src/main/java/me/grantland/widget/AutofitLayout.java — Container wrapper that enables autofit on any child TextView; required for XML-based configuration
• library/src/main/res/values/attrs.xml — Defines custom XML attributes (autofit:, android:) that control resizing behavior in layout files
• library/build.gradle — Library module configuration; controls SDK version, dependencies, and artifact publishing

• AutofitTextView (Android TextView, TextPaint) — Public-facing TextView subclass that owns an AutofitHelper instance and delegates onMeasure() to it; exposes XML attribute configuration
  • Failure mode: If text cannot fit even at minTextSize, text is truncated by TextView's ellipsize behavior; no error thrown
• AutofitHelper (TextPaint, binary search algorithm) — Stateful measurement engine that executes binary search to find optimal font size; caches paint and measurement state
  • Failure mode: If refitText() is called with invalid width/height (0 or negative

Add AutofitTextView to an XML Layout

1. Add the AutofitTextView namespace declaration to your root layout element (sample/src/main/res/layout/main.xml)
2. Replace a standard TextView with me.grantland.widget.AutofitTextView and set android:singleLine or maxLines attribute (sample/src/main/res/layout/main.xml)
3. Optionally configure autofit:maxTextSize, autofit:minTextSize, and autofit:precision in the widget attributes (library/src/main/res/values/attrs.xml)

Enable Autofit on Any Custom TextView Programmatically

1. Import AutofitHelper from me.grantland.widget package in your Activity or Fragment (sample/src/main/java/me/grantland/autofittextview/sample/SampleActivity.java)
2. Call AutofitHelper.create(myTextView) on any TextView instance after binding or inflating (sample/src/main/java/me/grantland/autofittextview/sample/SampleActivity.java)
3. Optionally chain .setMaxTextSize(sp), .setMinTextSize(sp), or .setPrecision(decimals) before layout rendering (library/src/main/java/me/grantland/widget/AutofitHelper.java)

Add Custom Autofit Attributes to a New XML Attribute

1. Open library/src/main/res/values/attrs.xml and add a new declare-styleable or attr entry under the AutofitTextView or AutofitLayout declare-styleable block (library/src/main/res/values/attrs.xml)
2. Read the attribute in AutofitHelper.create() or AutofitTextView.init() using TypedArray.getXxx() methods (library/src/main/java/me/grantland/widget/AutofitHelper.java)
3. Pass the value to the relevant setter method (e.g., setMaxTextSize, setMinTextSize) before measurement (library/src/main/java/me/grantland/widget/AutofitHelper.java)

Wrap Multiple TextViews in a Single Autofit Container

1. Replace your layout container (LinearLayout, FrameLayout) with me.grantland.widget.AutofitLayout as the root or parent (sample/src/main/res/layout/main.xml)
2. Nest all Button and TextView children inside the AutofitLayout; they will all inherit autofit behavior (sample/src/main/res/layout/main.xml)
3. Set android:singleLine or maxLines on each child; AutofitLayout will call AutofitHelper.create() on all TextView descendants during onMeasure() (library/src/main/java/me/grantland/widget/AutofitLayout.java)

• Android TextView & TextPaint — Native Android text measurement APIs provide accurate font metrics and glyph bounds without external dependencies
• Custom XML Attributes (attrs.xml) — Allows declarative configuration in layout files without requiring programmatic setup; integrates seamlessly with Android's style system
• ViewGroup.onMeasure() override — Provides the correct lifecycle hook to measure text size constraints before layout, ensuring autofit happens before drawing
• Gradle + Maven Central — Enables binary distribution and dependency management; developers can import via standard gradle dependency syntax

• Binary search algorithm for font size vs. linear iteration

  • Why: Binary search is O(log n) instead of O(n), reducing measurement passes from ~40 to ~5–8 on a typical 100px range
  • Consequence: Faster layout inflation but slightly more complex code; precision parameter trades off speed for accuracy

• Single AutofitHelper instance shared per TextView vs. stateless utility functions

  • Why: Stateful helper caches measurement state and allows method chaining for fluent configuration
  • Consequence: Easier API but requires careful state management; users must call create() after layout inflation, not before

• Supports only single-line or bounded multi-line text, not fully dynamic text reflow

  • Why: Simpler algorithm and predictable performance; Android's built-in multi-line text layout is complex and expensive to measure repeatedly
  • Consequence: Not suitable for free-flowing paragraph text; requires explicit maxLines or singleLine for deterministic sizing

• Measurement happens synchronously in onMeasure() vs. background thread

  • Why: Avoids race conditions and simplifies API; onMeasure() is already expected to be synchronous
  • Consequence: Potential jank if text resizing is called repeatedly during layout pass; best practice is to set text once and let view resize

• Does not support right-to-left (RTL) text layout optimization
• Does not provide animation or transitions between text sizes
• Does not handle custom Typeface loading or font fallbacks
• Not a drop-in replacement for TextAutoResizeUtil or other third-party autofit libraries

Gradle version mismatch: classpath 'com.android.tools.build:gradle:2.0.0' and buildscript dependencies are from 2015; modern Android Studio (2021+) requires Gradle 7.x. Will likely fail on recent machines—requires updating gradle/wrapper/gradle-wrapper.properties and build.gradle. No ProGuard/R8 config provided; minification may break reflection if used elsewhere. No explicit minSdkVersion guard code, so targeting API 14 assumes no use of newer Android APIs in measurement code.

• Binary search text sizing — AutofitHelper likely uses binary search to efficiently find the maximum font size fitting bounds; understanding this algorithm is key to optimizing or modifying the resizing logic
• Paint.getTextBounds() and TextPaint measurement — Core Android APIs used to calculate text dimensions; essential to understand how the library measures whether text fits without actually drawing it
• StaticLayout and line breaking — Android's StaticLayout handles multi-line text wrapping and line measurement; the library uses it to respect maxLines and single-line constraints while resizing
• TypedArray and XML attribute inflation — AutofitTextView reads custom XML attributes (minTextSize) via TypedArray in the constructor; this pattern is fundamental to creating configurable Android widgets
• LayoutParams and ViewGroup measurement constraints — AutofitLayout wraps views and must respect parent layout constraints; understanding MeasureSpec and how layouts propagate size constraints is critical for the wrapper pattern
• Density-independent pixels (dp) and font size units — AutofitHelper works with both sp (scale-independent pixels for fonts) and dp; correct unit handling is essential for cross-device consistency

• AndroidLiveData/AutoResizeTextView — Similar auto-sizing approach using different measurement strategy; provides alternative implementation reference
• google/android-textlayoutbuilder — Google's text measurement library used in modern Android apps; relevant for understanding official text sizing APIs beyond this library's custom solution
• material-components/material-components-android — Modern Material Design TextInputLayout and related components handle text sizing; shows how Google evolved auto-fitting in the official framework
• android/platform_frameworks_base — Android framework source; contains TextView and Paint APIs that AutofitHelper wraps; useful for understanding measurement constraints
• square/picasso — Example of a mature, well-tested Android library with similar modular architecture (core + adapters); reference for production-grade 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.

Add AndroidX migration and update deprecated Gradle build config

The project uses outdated Android Gradle plugin (2.0.0) and support libraries. This prevents compatibility with modern Android tooling. Updating to AndroidX and current Gradle plugin enables use in modern Android projects and removes deprecation warnings.

• [ ] Update gradle/wrapper/gradle-wrapper.properties to use Gradle 6.7.1 or later
• [ ] Update build.gradle classpath from 'com.android.tools.build:gradle:2.0.0' to at least 3.6.0 or current stable version
• [ ] Add gradle.properties: android.useAndroidX=true and android.enableJetifier=true
• [ ] Update library/build.gradle and sample/build.gradle to use androidX dependencies instead of android.support.*
• [ ] Update library/src/main/AndroidManifest.xml and sample/src/main/AndroidManifest.xml for AndroidX compatibility
• [ ] Test sample application builds and runs on modern emulators/devices

Add unit tests for AutofitHelper.java core resizing logic

The library/src/main/java/me/grantland/widget/AutofitHelper.java contains critical text resizing calculations but has no corresponding test coverage. Unit tests would verify edge cases (empty text, very small bounds, unicode characters, etc.) and prevent regressions.

• [ ] Create library/src/test/java/me/grantland/widget/AutofitHelperTest.java
• [ ] Add test cases for resizeText() with various text lengths and TextView dimensions
• [ ] Add test cases for boundary conditions (zero width/height, single character, very long text)
• [ ] Add test cases for different maxLines configurations
• [ ] Add tests for enable/disable behavior of AutofitHelper.create()
• [ ] Update library/build.gradle to include testImplementation 'junit:junit:4.13.2' and robolectric for Android UI testing

Add comprehensive Javadoc documentation to public API classes

The three main classes (AutofitHelper, AutofitLayout, AutofitTextView) lack Javadoc documentation. Documenting the public API with method descriptions, parameters, and usage examples improves discoverability and reduces integration issues for library users.

• [ ] Add class-level Javadoc to library/src/main/java/me/grantland/widget/AutofitHelper.java describing its purpose and linking to usage examples
• [ ] Add Javadoc to AutofitHelper.create() methods documenting parameters and behavior
• [ ] Add Javadoc to AutofitHelper configuration methods (setMinTextSize, setMaxTextSize, setMaxLines, etc.)
• [ ] Add class-level Javadoc to library/src/main/java/me/grantland/widget/AutofitLayout.java and AutofitTextView.java
• [ ] Add Javadoc to all public methods in AutofitLayout and AutofitTextView
• [ ] Update README.md with a 'Configuration' section documenting available attributes from library/src/main/res/values/attrs.xml

• Add unit tests for AutofitHelper.java text sizing algorithm: Zero test coverage exists; a contributor could create JUnit tests in library/src/test/ covering edge cases (empty text, very long text, single-line vs multi-line, extreme font sizes)
• Upgrade Gradle to 7.x and AGP to 7.x for modern Android Studio compatibility: Current gradle/wrapper/gradle-wrapper.properties and build.gradle are from 2015; updating enables builds on current machines and prepares for targetSdkVersion 31+ requirements
• Document XML attribute behavior with JavaDoc in AutofitTextView and AutofitLayout: attrs.xml defines minTextSize but no developer-facing documentation explains how it interacts with android:textSize or android:maxLines; a contributor could add method-level docs and a values reference guide

This Android library project has significant security concerns primarily related to outdated dependencies and API levels. The use of Gradle 2.0.0, Build Tools 23.0.3, and target SDK 23 are substantially behind current standards, missing years of security patches and modern Android security features. The codebase itself (a TextView autofitting utility) appears to have minimal injection risks, but the build infrastructure and dependency management require immediate modernization. The project is not suitable for production use without addressing the outdated toolchain and API versions. Immediate action required: update Gradle, Build Tools, and target SDK to current versions.

• High · Outdated Gradle Build Tools — build.gradle (buildscript dependencies). The project uses Gradle 2.0.0 and Android Build Tools 23.0.3, which were released around 2015-2016. These versions contain known security vulnerabilities and are no longer supported. Modern versions include critical security patches, performance improvements, and bug fixes. Fix: Update to the latest stable version of Android Gradle Plugin (currently 8.x). Update buildToolsVersion to at least 34.0.0. Review Android Gradle Plugin release notes for migration guidance.
• High · Outdated Target SDK Version — build.gradle (targetSdkVersion = 23). The project targets SDK 23 (Android 6.0), released in 2015. Modern Google Play Store requires apps to target API level 34 or higher. Running on outdated API levels misses critical security patches, permission handling improvements, and privacy protections introduced in newer Android versions. Fix: Update targetSdkVersion to at least 34. Update minSdkVersion to at least 21 or higher based on project requirements. Test thoroughly with new permission models and runtime behavior changes.
• Medium · Outdated Minimum SDK Version — build.gradle (minSdkVersion = 14). The project supports minSdkVersion 14 (Android 4.0, released in 2011). Supporting such old versions is difficult to maintain securely and excludes modern security features available in newer Android versions. Most apps no longer need to support devices this old. Fix: Increase minSdkVersion to at least 21 (Android 5.0) or higher. This removes support for devices without critical security patches and simplifies dependency management. Check analytics to ensure minimal user impact.
• Medium · Deprecated Maven Repository — build.gradle (repositories block). The build configuration uses 'mavenCentral()' without explicit repository verification. While Maven Central is generally trustworthy, using it alone without additional security measures (like dependency verification, SBOM, or signed artifacts) leaves the build vulnerable to supply chain attacks. Fix: Enable dependency verification in Gradle. Use 'dependencyVerification' block to verify checksums of dependencies. Consider using Google's repository alongside Maven Central. Implement SBOM (Software Bill of Materials) analysis.
• Low · No Explicit Dependency Pinning — README.md (dependencies section). The README shows dependency specification using 'autofittextview:0.2.+', which uses a floating version constraint. This could allow unexpected minor/patch version updates that might introduce breaking changes or security issues. Fix: Use explicit version pinning (e.g., '0.2.1') instead of floating versions. Regularly update dependencies but control when updates occur. Implement dependency lock files or version catalogs.

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.