Android Architecture

Standardize Android project architecture using TEA-based patterns with Store, Reducer, and EffectHandler.

1.3k|65|Updated Jun 9, 2022
One-click install
npx skills add https://github.com/F0x1d/LogFox --skill android-architecture-f0x1d
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Android Architecture
Source: https://github.com/F0x1d/LogFox/tree/main/.opencode/skill/architecture
Command: npx skills add https://github.com/F0x1d/LogFox --skill android-architecture-f0x1d

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Standardizes Android projects by providing a defined TEA-based architecture with conventions for state management, modularization, and UI patterns using Views and Jetpack Compose.

Core Features & Use Cases

  • Establishes State, Command, and SideEffect model with a lifecycle-aware Store, Reducer, and EffectHandlers.
  • Provides a BaseStoreViewModel and ViewState mapping for UI-driven screens.
  • Enables predictable UI with immutable State and pure reducers across large codebases, including support for Jetpack Compose and Views.

Quick Start

Follow the TEA-based architecture to initialize a store-driven Android project.

Frequently Asked Questions about Android Architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I manage stateful Android features across a large team?

Stateful Android features are managed by standardizing project architecture with a TEA-based pattern. This provides a lifecycle-aware Store using immutable State and pure Reducers to enforce predictable state across large codebases.

What is the TEA pattern for Android state management?

The TEA pattern for Android state management models UI logic using State, Commands, and SideEffects. It processes Actions through pure Reducers and handles SideEffects asynchronously via dedicated EffectHandlers.

How do I structure an Android project using modularization and Jetpack Compose?

Android project modularization with Jetpack Compose is structured using a BaseStoreViewModel and ViewStateMapper. This maps immutable State to UI-driven screens within container-based fragments or activities to enforce composition.

Does this Android architecture work with both Views and Jetpack Compose?

This Android architecture works with both Views and Jetpack Compose. It establishes a defined Store-driven architecture with ViewState mapping to support predictable UI rendering across both UI toolkits.

How do I handle side effects in an Android MVVM architecture?

Side effects in an Android MVVM architecture are handled using dedicated EffectHandlers. The Store dispatches Commands processed by pure Reducers, routing SideEffects asynchronously to keep state transitions predictable.

When should I use a Store-based architecture for Android apps?

A Store-based architecture should be used when building Android apps with stateful features at a large team scale. It enforces lifecycle-aware state management and modularization to manage multi-file interdependencies.