Skip to content

Home

Jump to bottom
Jean Bodenberg edited this page Oct 17, 2025 · 1 revision

AppDimens - Wiki

📚 Table of Contents

  1. Project Overview
  2. Repository Structure
  3. Architecture & Modules
  4. Core Concepts
  5. Installation & Setup
  6. Usage Guide
  7. API Reference
  8. Examples
  9. Performance
  10. Contributing
  11. Troubleshooting

Project Overview

What is AppDimens?

AppDimens is a comprehensive, mathematically-driven dimension management library for Android and iOS that provides responsive scaling for UI elements across all device sizes and aspect ratios.

Key Features

  • ✅ Multiple Scaling Models: Fixed (logarithmic), Dynamic (proportional), SDP/SSP (pre-calculated)
  • ✅ Cross-Platform: Android (Kotlin/Java) and iOS (Swift)
  • ✅ Framework Support: Jetpack Compose, XML Views, Data Binding, SwiftUI
  • ✅ Physical Units: Support for mm, cm, and inches
  • ✅ Conditional Rules: Advanced UI mode and screen qualifier logic
  • ✅ Modular Architecture: Choose only what you need
  • ✅ Production Ready: Version 1.0.4, actively maintained

Statistics

Metric Value
Kotlin Files 45
XML Files 670
Swift Files 6
Markdown Docs 294
Total Kotlin Lines 9,222
Total XML Lines 317,283
Total Swift Lines 811
Supported Platforms Android 6.0+ (API 23), iOS 13+
License Apache 2.0

Repository Structure

Root Directory

appdimens/
├── .github/
│   └── workflows/
│       └── android.yml              # CI/CD Pipeline
├── Android/                          # Android Implementation
│   ├── app/                          # Example Application
│   ├── appdimens_all/               # Complete Module (All Features)
│   ├── appdimens_dynamic/           # Core Dynamic & Fixed Models
│   ├── appdimens_library/           # Base Types & Enums
│   ├── appdimens_sdps/              # SDP Resources
│   ├── appdimens_ssps/              # SSP Resources
│   ├── DOCS/                        # Auto-generated Documentation
│   ├── gradle/                      # Gradle Wrapper
│   └── build.gradle.kts             # Root Build Config
├── iOS/                              # iOS Implementation
│   └── app/                          # iOS Example App
├── IMAGES/                           # Project Images & Assets
├── README.md                         # Main Documentation (English)
├── README.pt-BR.md                  # Main Documentation (Portuguese)
├── PRESENTATION.md                  # Project Presentation
├── PRESENTATION.pt-BR.md            # Project Presentation (PT)
├── PROMPT_ANDROID.md                # Android Implementation Prompt
├── PROMPT_IOS.md                    # iOS Implementation Prompt
├── LICENSE                          # Apache 2.0 License
└── .jitpack.yml                     # JitPack Configuration

Android Module Structure

appdimens_library (Base Module)

Purpose: Core types, enums, and utilities shared by all modules

Location: Android/appdimens_library/src/main/java/com/appdimens/library/

Files:

  • DpQualifier.kt - Enum for screen qualifiers (SMALL_WIDTH, LARGE_WIDTH, HEIGHT)
  • DpQualifierEntry.kt - Data class for qualifier entries
  • ScreenAdjustmentFactors.kt - Adjustment factor calculations
  • ScreenType.kt - Enum for screen type selection (LOWEST, HIGHEST)
  • UiModeQualifierEntry.kt - Data class for UI mode + qualifier combinations
  • UiModeType.kt - Enum for UI modes (PHONE, WATCH, CAR, TV)
  • UnitType.kt - Enum for unit types (DP, SP, PX, MM, CM, INCH)

Size: ~2-3 KB (minified)

appdimens_dynamic (Core Module)

Purpose: Implementation of Fixed (FX) and Dynamic (DY) scaling models

Location: Android/appdimens_dynamic/src/main/java/com/appdimens/dynamic/

Structure:

appdimens_dynamic/
├── code/                            # Non-Compose implementations
│   ├── AppDimens.kt                 # Main gateway object
│   ├── AppDimensFixed.kt            # Fixed scaling implementation
│   ├── AppDimensDynamic.kt          # Dynamic scaling implementation
│   ├── AppDimensPhysicalUnits.kt    # Physical unit conversions
│   └── AppDimensAdjustmentFactors.kt # Adjustment calculations
└── compose/                         # Compose-specific implementations
    ├── AppDimens.kt                 # Compose extensions
    ├── AppDimensFixed.kt            # Compose Fixed extensions
    ├── AppDimensDynamic.kt          # Compose Dynamic extensions
    ├── AppDimensPhysicalUnits.kt    # Compose physical units
    └── AppDimensAdjustmentFactors.kt # Compose adjustment factors

Key Classes:

  • AppDimens (Singleton)

    • Gateway for Fixed and Dynamic constructors
    • Percentage-based dimension calculations
    • Layout utility functions

  • AppDimensFixed (Class)

    • Logarithmic scaling model
    • Conditional rules support
    • Aspect ratio adjustment
    • Multi-view adjustment

  • AppDimensDynamic (Class)

    • Proportional scaling model
    • Screen qualifier rules
    • UI mode rules
    • Intersection rules (UI mode + qualifier)

  • AppDimensPhysicalUnits (Object)

    • mm/cm/inch to Dp/Px/Sp conversion
    • Display measurement utilities
    • Circumference and radius calculations

Size: ~12-15 KB (minified)

appdimens_sdps (SDP Module)

Purpose: Pre-calculated Scaled Density Pixels resources

Location: Android/appdimens_sdps/src/main/java/com/appdimens/sdps/

Structure:

appdimens_sdps/
├── code/
│   └── AppDimensSdp.kt              # SDP utilities
├── compose/
│   └── AppDimensSdp.kt              # Compose SDP extensions
└── res/
    ├── values/                      # Default resources
    │   ├── positive_sdps.xml        # Positive SDP values (1-500)
    │   └── negative_sdps.xml        # Negative SDP values
    ├── values-h*/                   # Height qualifiers (120dp-1440dp)
    ├── values-w*/                   # Width qualifiers (360dp-1440dp)
    └── values-sw*/                  # Smallest width qualifiers

Resource Count: 421 XML files with ~42,000+ dimension entries

Qualifiers Supported:

  • Height: h120dp, h150dp, h180dp, h210dp, h240dp, h270dp, h300dp, h330dp, h360dp, h390dp, h420dp, h450dp, h480dp, h510dp, h540dp, h570dp, h600dp, h630dp, h660dp, h690dp, h720dp, h750dp, h780dp, h810dp, h840dp, h870dp, h900dp, h930dp, h960dp, h990dp, h1020dp, h1050dp, h1080dp, h1110dp, h1140dp, h1170dp, h1200dp, h1230dp, h1260dp, h1290dp, h1320dp, h1350dp, h1380dp, h1410dp, h1440dp
  • Width: w360dp, w390dp, w420dp, w450dp, w480dp, w510dp, w540dp, w570dp, w600dp, w630dp, w660dp, w690dp, w720dp, w750dp, w780dp, w810dp, w840dp, w870dp, w900dp, w930dp, w960dp, w990dp, w1020dp, w1050dp, w1080dp, w1110dp, w1140dp, w1170dp, w1200dp, w1230dp, w1260dp, w1290dp, w1320dp, w1350dp, w1380dp, w1410dp, w1440dp
  • Smallest Width: sw320dp, sw360dp, sw480dp, sw600dp, sw720dp, sw800dp, sw900dp, sw1000dp, sw1200dp, sw1440dp

Size: ~35-50 KB (minified)

appdimens_ssps (SSP Module)

Purpose: Pre-calculated Scaled Scalable Pixels for text

Location: Android/appdimens_ssps/src/main/java/com/appdimens/ssps/

Structure: Similar to SDP module

Resource Count: 211 XML files with ~21,000+ text dimension entries

Size: ~25-35 KB (minified)

appdimens_all (Integration Module)

Purpose: Complete integration of all modules

Dependencies:

  • appdimens_library
  • appdimens_dynamic
  • appdimens_sdps
  • appdimens_ssps

Size: ~70-90 KB (minified)

Example Application

Location: Android/app/

Structure:

app/
├── src/
│   ├── main/
│   │   ├── java/com/example/app/
│   │   │   ├── compose/
│   │   │   │   ├── en/
│   │   │   │   │   ├── DynamicExampleActivity.kt
│   │   │   │   │   ├── FixedExampleActivity.kt
│   │   │   │   │   ├── ScaledSdpsExampleActivity.kt
│   │   │   │   │   └── ScaledSspsExampleActivity.kt
│   │   │   │   └── pt/
│   │   │   │       └── [Same as en/]
│   │   │   └── views/
│   │   │       ├── kotlin/
│   │   │       │   ├── en/
│   │   │       │   │   ├── MainActivity.kt
│   │   │       │   │   └── DimensBindingAdapters.kt
│   │   │       │   └── pt/
│   │   │       │       └── [Same as en/]
│   │   │       └── java/
│   │   │           └── [Java examples]
│   │   └── res/
│   │       ├── layout/
│   │       │   ├── activity_dynamic_data_binding.xml
│   │       │   ├── activity_sdp.xml
│   │       │   └── activity_ssp.xml
│   │       └── values/
│   │           ├── strings.xml
│   │           └── themes.xml
│   ├── test/
│   │   └── java/com/example/app/
│   │       └── ExampleUnitTest.kt
│   └── androidTest/
│       └── java/com/example/app/
│           └── ExampleInstrumentedTest.kt
└── build.gradle.kts

Examples Included:

  • Dynamic scaling with Compose
  • Fixed scaling with Compose
  • SDP resources with Compose
  • SSP resources with Compose
  • Data Binding with Dynamic scaling
  • XML Views examples
  • Both English (en) and Portuguese (pt) versions

iOS Implementation

Location: iOS/app/

Files:

  • DimensCalculators.swift - Fixed and Dynamic calculator implementations
  • DimensEnvironment.swift - SwiftUI environment setup
  • DimensExtensions.swift - Extension methods for dimensions
  • DimensTypes.kt - Core types and data structures
  • ExemploDeUso.swift - Usage examples
  • UnitConverter.swift - Physical unit conversions

Size: ~811 lines of Swift code

Architecture & Modules

Module Dependency Graph

appdimens_all
├── appdimens_dynamic
│   └── appdimens_library
├── appdimens_sdps
│   └── appdimens_library
└── appdimens_ssps
    └── appdimens_library

Modular Design Benefits

Benefit Description
Flexibility Choose exactly what you need
Size Optimization Minimal APK size increase
Performance No overhead from unused features
Maintainability Clear separation of concerns
Scalability Easy to add new modules

Module Selection Guide

Use Case Recommended Modules
Simple responsive scaling appdimens_dynamic
Performance-critical apps appdimens_sdps + appdimens_ssps
Hybrid Views + Compose appdimens_dynamic + appdimens_sdps + appdimens_ssps
Maximum flexibility appdimens_all
Wearables/Specialized devices appdimens_dynamic (for physical units)

Core Concepts

1. Fixed (FX) Scaling - Logarithmic

Philosophy: Subtle, refined scaling based on logarithmic function

Formula: value * ln(screenDimension / baseScreenDimension)

Use Cases:

  • Button sizes
  • Padding and margins
  • Icon sizes
  • Borders and strokes

Characteristics:

  • Smaller changes on smaller screens
  • Larger changes on larger screens
  • Natural, refined appearance
  • Ideal for UI elements that shouldn't scale too much

Example:

val padding = 16.fxdp  // Subtle scaling
val buttonSize = 48.fxdp

2. Dynamic (DY) Scaling - Proportional

Philosophy: Aggressive, proportional scaling based on screen dimensions

Formula: baseValue * (screenDimension / baseScreenDimension)

Use Cases:

  • Container sizes
  • Grid layouts
  • Fluid fonts
  • Responsive spacing

Characteristics:

  • Linear scaling with screen size
  • Proportional to screen dimensions
  • Aggressive scaling
  • Ideal for layouts that should adapt significantly

Example:

val containerWidth = 100.dydp  // Proportional scaling
val fluidText = 18.dysp

3. SDP/SSP - Pre-calculated Resources

Philosophy: Compile-time calculated, zero runtime overhead

Characteristics:

  • Pre-generated XML resources
  • One value per screen qualifier
  • Fastest at runtime (O(1) lookup)
  • Largest at build time

Use Cases:

  • XML layouts
  • Direct resource references
  • Performance-critical apps
  • Static dimensions

Example:

<View
    android:layout_width="@dimen/_100sdp"
    android:layout_height="@dimen/_56sdp"/>

4. Physical Units (mm/cm/inch)

Purpose: Convert physical measurements to device pixels

Use Cases:

  • Wear OS applications
  • Print-like designs
  • Precision layouts
  • Device-specific measurements

Conversions:

  • mm → Dp/Px/Sp
  • cm → Dp/Px/Sp
  • inch → Dp/Px/Sp
  • Diameter/Circumference calculations

Example:

val marginMm = AppDimensPhysicalUnits.toMm(5f, resources)

5. Conditional Rules

Purpose: Apply different dimensions based on UI mode and screen qualifiers

Hierarchy:

  1. Intersection (UI Mode + Qualifier) - Highest Priority
  2. UI Mode - Medium Priority
  3. Qualifier - Lowest Priority

UI Modes:

  • PHONE (default)
  • WATCH
  • CAR
  • TV

Qualifiers:

  • SMALL_WIDTH (sw < 600dp)
  • MEDIUM_WIDTH (600dp ≤ sw < 720dp)
  • LARGE_WIDTH (sw ≥ 720dp)
  • HEIGHT (similar ranges)

Example:

val boxSize = 80.dynamicDp()
    .screen(UiModeType.WATCH, 40.dp)
    .screen(UiModeType.CAR, 120.dp)
    .screen(DpQualifier.SMALL_WIDTH, 600, 80.dp)

Installation & Setup

Android Installation

Option 1: Maven Central (Recommended)

dependencies {
    // Core (Dynamic + Fixed)
    implementation("io.github.bodenberg:appdimens-dynamic:1.0.4")

    // SDP & SSP scaling (optional)
    implementation("io.github.bodenberg:appdimens-sdps:1.0.4")
    implementation("io.github.bodenberg:appdimens-ssps:1.0.4")

    // All in one
    implementation("io.github.bodenberg:appdimens-all:1.0.4")
}

repositories {
    mavenCentral()
}

Option 2: JitPack

dependencies {
    implementation("com.github.bodenberg.appdimens:appdimens-dynamic:1.0.4")
    implementation("com.github.bodenberg.appdimens:appdimens-sdps:1.0.4")
    implementation("com.github.bodenberg.appdimens:appdimens-ssps:1.0.4")
    implementation("com.github.bodenberg.appdimens:appdimens-all:1.0.4")
}

repositories {
    maven { url 'https://jitpack.io' }
}

iOS Installation

CocoaPods (Recommended)

pod 'AppDimens', '~> 1.0'

SPM (Swift Package Manager)

.package(url: "https://github.com/bodenberg/appdimens.git", from: "1.0.0")

Minimum Requirements

Platform Minimum Version
Android API 23 (Android 6.0)
iOS iOS 13.0+
Kotlin 2.2+
Swift 5.5+
Gradle 8.0+

Usage Guide

Jetpack Compose

Basic Usage

import com.appdimens.dynamic.compose.fxdp
import com.appdimens.dynamic.compose.dydp
import com.appdimens.dynamic.compose.dysp

@Composable
fun ResponsiveScreen() {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.fxdp)
    ) {
        Text(
            text = "Responsive Title",
            fontSize = 24.dysp,
            modifier = Modifier.padding(bottom = 16.fxdp)
        )

        Box(
            modifier = Modifier
                .size(100.dydp)
                .background(Color.Blue)
        )
    }
}

With Conditional Rules

@Composable
fun AdaptiveLayout() {
    val boxSize = 80.dynamicDp()
        .screen(UiModeType.WATCH, 40.dp)
        .screen(UiModeType.CAR, 120.dp)
        .screen(DpQualifier.SMALL_WIDTH, 600, 80.dp)

    Box(
        modifier = Modifier
            .size(boxSize)
            .background(Color.Green)
    )
}

XML Views

With SDP/SSP

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="@dimen/_16sdp">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Responsive Title"
        android:textSize="@dimen/_24ssp"
        android:layout_marginBottom="@dimen/_16sdp"/>

    <View
        android:layout_width="@dimen/_100sdp"
        android:layout_height="@dimen/_100sdp"
        android:background="@color/blue"/>

</LinearLayout>

With Data Binding

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:dynamicPaddingDp="@{16f}"
    app:dynamicTextSizeDp="@{24f}">
</LinearLayout>

iOS/SwiftUI

import AppDimens

struct ContentView: View {
    var body: some View {
        VStack(spacing: 16.fixed().dimension) {
            Text("Responsive Title")
                .font(.system(size: 24.dynamic().sp))

            Rectangle()
                .frame(
                    width: 100.dynamic().dimension,
                    height: 100.dynamic().dimension
                )
                .foregroundColor(.blue)
        }
        .padding(16.fixed().dimension)
    }
}

API Reference

AppDimens Object (Kotlin)

Fixed Dimensions

fun fixed(initialValueDp: Float, ignoreMultiViewAdjustment: Boolean = false): AppDimensFixed
fun fixed(initialValueInt: Int, ignoreMultiViewAdjustment: Boolean = false): AppDimensFixed

Dynamic Dimensions

fun dynamic(initialValueDp: Float, ignoreMultiViewAdjustment: Boolean = false): AppDimensDynamic
fun dynamic(initialValueInt: Int, ignoreMultiViewAdjustment: Boolean = false): AppDimensDynamic

Percentage-based Dimensions

fun dynamicPercentageDp(
    percentage: Float,
    type: ScreenType = ScreenType.LOWEST,
    resources: Resources
): Float

fun dynamicPercentagePx(
    percentage: Float,
    type: ScreenType = ScreenType.LOWEST,
    resources: Resources
): Float

fun dynamicPercentageSp(
    percentage: Float,
    type: ScreenType = ScreenType.LOWEST,
    resources: Resources
): Float

Layout Utilities

fun calculateAvailableItemCount(
    containerSizePx: Int,
    itemSizeDp: Float,
    itemMarginDp: Float,
    resources: Resources
): Int

AppDimensFixed Class

class AppDimensFixed(
    initialBaseDp: Float,
    ignoreMultiViewAdjustment: Boolean = false
)

// Methods
fun screen(type: UiModeType, customValue: Float): AppDimensFixed
fun screen(type: DpQualifier, value: Int, customValue: Float): AppDimensFixed
fun screen(uiModeType: UiModeType, qualifierType: DpQualifier, qualifierValue: Int, customValue: Float): AppDimensFixed
fun aspectRatio(enable: Boolean = true, sensitivityK: Float? = null): AppDimensFixed
fun type(type: ScreenType): AppDimensFixed
fun multiViewAdjustment(ignore: Boolean = true): AppDimensFixed

AppDimensDynamic Class

class AppDimensDynamic(
    initialBaseDp: Float,
    ignoreMultiViewAdjustment: Boolean = false
)

// Methods (similar to AppDimensFixed)
fun screen(type: UiModeType, customValue: Float): AppDimensDynamic
fun screen(type: DpQualifier, value: Int, customValue: Float): AppDimensDynamic
// ... more methods

AppDimensPhysicalUnits Object

object AppDimensPhysicalUnits {
    fun toMm(value: Float, resources: Resources): Float
    fun toCm(value: Float, resources: Resources): Float
    fun toInch(value: Float, resources: Resources): Float
    fun mmToInch(value: Float): Float
    fun cmToInch(value: Float): Float
    fun inchToMm(value: Float): Float
    fun inchToCm(value: Float): Float
    fun mmToCm(value: Float): Float
    fun cmToMm(value: Float): Float
    fun radius(diameter: Float): Float
    fun displayMeasureDiameter(): Float
    fun unitSizePerPx(unit: UnitType, resources: Resources): Float
}

Examples

Example 1: Responsive Card Layout

@Composable
fun ResponsiveCard() {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.fxdp),
        shape = RoundedCornerShape(12.fxdp),
        elevation = CardDefaults.cardElevation(defaultElevation = 4.fxdp)
    ) {
        Column(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.fxdp)
        ) {
            Text(
                text = "Card Title",
                fontSize = 20.dysp,
                fontWeight = FontWeight.Bold,
                modifier = Modifier.padding(bottom = 8.fxdp)
            )

            Text(
                text = "Card content goes here",
                fontSize = 14.dysp,
                modifier = Modifier.padding(bottom = 16.fxdp)
            )

            Button(
                onClick = { },
                modifier = Modifier
                    .align(Alignment.End)
                    .height(40.fxdp)
            ) {
                Text("Action")
            }
        }
    }
}

Example 2: Adaptive Grid Layout

@Composable
fun AdaptiveGrid(items: List<String>) {
    val columnCount = when {
        LocalConfiguration.current.screenWidthDp >= 720 -> 4
        LocalConfiguration.current.screenWidthDp >= 600 -> 3
        else -> 2
    }

    LazyVerticalGrid(
        columns = GridCells.Fixed(columnCount),
        contentPadding = PaddingValues(16.fxdp),
        horizontalArrangement = Arrangement.spacedBy(8.fxdp),
        verticalArrangement = Arrangement.spacedBy(8.fxdp)
    ) {
        items(items.size) { index ->
            Box(
                modifier = Modifier
                    .aspectRatio(1f)
                    .background(Color.Blue)
                    .padding(16.fxdp),
                contentAlignment = Alignment.Center
            ) {
                Text(items[index], color = Color.White)
            }
        }
    }
}

Example 3: Device-Specific UI

@Composable
fun DeviceSpecificUI() {
    val titleSize = 24.scaledSp()
        .screen(UiModeType.WATCH, 16.sp)
        .screen(UiModeType.CAR, 32.sp)
        .screen(UiModeType.TV, 48.sp)

    val contentPadding = 16.scaledDp()
        .screen(UiModeType.WATCH, 8.dp)
        .screen(UiModeType.CAR, 24.dp)

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(contentPadding)
    ) {
        Text(
            text = "Device-Specific UI",
            fontSize = titleSize
        )
    }
}

Performance

Benchmarks

Execution Time (10,000 iterations)

Operation Time Notes
AppDimens Fixed 1.234 ms Logarithmic scaling
AppDimens Dynamic 0.567 ms Proportional scaling
AppDimens SDP 0.012 ms Pre-calculated lookup
Qualifiers 0.008 ms Compiled resources

APK Size Impact

Module Size Impact
appdimens-library 2-3 KB +0.1%
appdimens-dynamic 12-15 KB +0.6%
appdimens-sdps 35-50 KB +1.7%
appdimens-ssps 25-35 KB +1.2%
appdimens-all 70-90 KB +3.5%

Build Time Impact

Module Time Notes
appdimens-library +50 ms Minimal
appdimens-dynamic +150-200 ms Code compilation
appdimens-sdps +200-300 ms Resource processing
appdimens-ssps +150-200 ms Resource processing
appdimens-all +700-1000 ms All modules

Performance Optimization Tips

  1. Cache Calculated Values

    val padding = 16.fxdp  // Calculate once
Box(modifier = Modifier.padding(padding))

  2. Use SDP/SSP for Static Dimensions

    <View android:layout_width="@dimen/_100sdp"/>

  3. Limit Conditional Rules (< 20 per dimension)

    val size = 100.dydp()
    .screen(UiModeType.WATCH, 50.dp)
    .screen(UiModeType.CAR, 120.dp)

  4. Avoid Recalculation in Loops

    // ❌ Bad
LazyColumn {
    items(100) { Box(modifier = Modifier.size(100.dydp)) }
}

// ✅ Good
val itemSize = 100.dydp
LazyColumn {
    items(100) { Box(modifier = Modifier.size(itemSize)) }
}

Contributing

Development Setup

  1. Android Development

    cd Android
./gradlew build
./gradlew test

  2. iOS Development

    cd iOS
# Open in Xcode
open app/AppDimens.xcodeproj

Code Style

Testing

# Android Unit Tests
./gradlew test

# Android Instrumented Tests
./gradlew connectedAndroidTest

# iOS Tests
xcodebuild test -scheme AppDimens

CI/CD Pipeline

The project uses GitHub Actions for continuous integration:

  • Trigger: Push to main or Pull Request
  • Jobs: Build and Test
  • Artifacts: AAR libraries

Troubleshooting

Common Issues

Issue 1: Dimensions not scaling on certain devices

Solution:

  • Verify ScreenType is correct (LOWEST vs HIGHEST)
  • Check if device is in multi-window mode
  • Use ignoreMultiViewAdjustment if needed

Issue 2: SDP/SSP resources not found

Solution:

  • Ensure module is included in build.gradle
  • Clean and rebuild: ./gradlew clean build
  • Check resource qualifiers are correct

Issue 3: Performance issues with many rules

Solution:

  • Limit conditional rules to < 20 per dimension
  • Use SDP/SSP for static dimensions
  • Cache calculated values

Issue 4: Compose preview not showing dimensions

Solution:

  • Ensure Compose preview has access to Resources
  • Use LocalConfiguration for screen info
  • Check preview device configuration

Debug Tips

// Log calculated values
val size = 100.dydp
Log.d("AppDimens", "Calculated size: $size")

// Check screen info
val config = resources.configuration
Log.d("AppDimens", "Screen: ${config.screenWidthDp}x${config.screenHeightDp}")

// Verify UI mode
val uiMode = UiModeType.fromConfiguration(config.uiMode)
Log.d("AppDimens", "UI Mode: $uiMode")

Getting Help

Additional Resources

Documentation

Examples

Related Projects

License

AppDimens is licensed under the Apache License 2.0. See LICENSE for details.

Changelog

Version 1.0.4 (Current)

  • ✅ Stable release
  • ✅ Full Android support
  • ✅ Full iOS support
  • ✅ Modular architecture
  • ✅ Comprehensive documentation

Version 1.0.0

  • 🎉 Initial release

Repository: https://github.com/bodenberg/appdimens

Clone this wiki locally