android-development

SKILL.md

Android Development Best Practices

General Kotlin Guidelines

Basic Principles

Use English for all code and documentation

Always declare variable and function types explicitly

Avoid the any type; create necessary custom types

Eliminate blank lines within function bodies

Naming Standards

PascalCase: Classes, interfaces, enums

camelCase: Variables, functions, methods

underscores_case: Files and directories

UPPERCASE: Environment variables, constants

Avoid magic numbers; define constants instead

Functions should start with action verbs

Boolean variables use prefixes: isLoading, hasError, canDelete

Function Design

Keep functions under 20 instructions with single responsibility

Use verb-based naming

Prefix boolean returns with is, has, or can

Prefix void returns with execute, save, send

Combat nesting through early returns, utility extraction, and higher-order functions

Use default parameters instead of null checks

Consolidate parameters into objects (RO-RO pattern)

Data and Classes

Employ data classes for data structures

Encapsulate primitives in composite types; validate internally

Favor immutability; use val for unchanging values

Follow SOLID principles; prefer composition over inheritance

Keep classes under 200 instructions, 10 public methods, 10 properties

Exception Handling

Reserve exceptions for unexpected errors

Catch exceptions only to fix anticipated issues or add context

Create custom exception types for domain errors

Android Architecture

Clean Architecture

Implement clean architecture with clear layer separation

Use repository pattern for data persistence and caching

Keep business logic in Use Cases or Interactors

Separate concerns between UI, domain, and data layers

Project Structure

app/
├── data/           # Data sources, repositories, models
├── domain/         # Use cases, domain models, interfaces
├── presentation/   # UI components, ViewModels, state
└── di/             # Dependency injection modules

MVI Pattern

Deploy MVI pattern for state and event management

ViewModels manage UI state as a single immutable state object

UI components observe state and render accordingly

Handle user intents/events through a single entry point

Keep side effects predictable and traceable

UI Development

Navigation

Use Navigation Component for fragment and activity routing

Define navigation graph for app flow

Handle deep links through Navigation Component

Implement safe args for type-safe navigation arguments

Main Activity Structure

MainActivity manages primary navigation

Use BottomNavigationView for main destinations (Home, Profile, Settings, etc.)

Handle navigation state properly across configuration changes

View Binding and State

Use ViewBinding for type-safe view access

Use Flow or LiveData for UI state management

Observe state changes in lifecycle-aware manner

Handle loading, error, and success states consistently

UI Framework Preferences

Prefer XML layouts and Fragments over Jetpack Compose (unless Compose is specifically required)

Use ConstraintLayout for complex layouts

Apply Material 3 design guidelines

Follow responsive design practices for different screen sizes

Authentication Flow

Structure authentication screens properly:

Splash Screen - Initial app launch

Login Screen - User authentication

Register Screen - New user registration

Forgot Password Screen - Password recovery

Verify Email Screen - Email verification

Testing

Unit Testing

Follow Arrange-Act-Assert conventions

Test ViewModels, Use Cases, and Repositories

Use test doubles for dependencies

Achieve good coverage of business logic

UI Testing

Implement widget testing for UI components

Write integration tests for API modules

Test navigation flows

Use Espresso for instrumented tests

Best Practices

Lifecycle Management

Handle lifecycle events properly

Avoid memory leaks from improper lifecycle handling

Use lifecycle-aware components

Background Processing

Use Coroutines for async operations

Handle cancellation properly

Use WorkManager for deferrable background work

Dependency Injection

Use Hilt or Dagger for dependency injection

Scope dependencies appropriately

Keep DI configuration organized

Performance

Avoid work on the main thread

Optimize RecyclerView with DiffUtil

Use lazy loading for heavy resources

Profile and optimize memory usage