Cubex Mobile App Technical Architecture

Clean Architecture Overview

The application implements clean architecture principles, separating concerns into distinct layers to ensure maintainability and scalability.

Project Structure

Root Directory Organization

lib/
├── core/
├── router/
├── api_setup/
├── general_components/
├── modules/
│   ├── auth/
│   ├── crypto/
│   ├── fiat-money/
│   └── utils/
└── firebase/

Module Structure

Each feature module follows a three-layer architecture:

modules/
└── Module Folder
    ├── data/
    │   ├── data_source/
    │   ├── repo/
    │   └── models/
    ├── domain/
    │   ├── params/
    │   ├── repo/
    │   └── usecases/
    └── presentation/
        ├── bloc/
        └── ui/

Architectural Layers

Data Layer

• Purpose: External data interaction
• Components:
• Data models for serialization
• Repository implementations
• Data source interfaces
• API integration

Domain Layer

• Purpose: Business logic
• Components:
• Business entities
• Use case definitions
• Repository interfaces
• Request parameters

Presentation Layer

• Purpose: User interface
• Components:
• Bloc state management
• UI screens
• Reusable widgets

Core Components

Network Service

class NetworkService {
    final Dio _dio = Dio();

    NetworkService() {
        _dio.options.baseUrl = 'https://api.example.com';
        _dio.interceptors.add(InterceptorsWrapper(
            onRequest: (options, handler) {
                // Token management
                return handler.next(options);
            },
            onResponse: (response, handler) {
                return handler.next(response);
            },
            onError: (DioError e, handler) {
                // Error handling
                return handler.next(e);
            },
        ));
    }
}

Navigation Setup

final GoRouter _router = GoRouter(
    routes: [
        GoRoute(
            path: '/',
            builder: (context, state) => HomeScreen(),
        ),
        GoRoute(
            path: '/auth',
            builder: (context, state) => AuthScreen(),
        ),
    ],
);

State Management

• Uses Bloc pattern for state management
• Components:
• Cubit/Bloc for state logic
• State definitions
• Event handling

Module Implementation Details

Authentication Module

• Token management
• Session handling
• User data persistence
• Authentication state management

Crypto Module

• Market data integration
• Transaction processing
• Balance tracking
• Price updates

Fiat Money Module

• Currency conversion
• Transaction processing
• Balance management
• Exchange rate updates

Utilities Module

• Service integration
• Payment processing
• Transaction validation
• Service status management

Firebase Configuration

• FCM token management
• Notification handling
• Message display
• Background message processing

Development Guidelines

1. Follow clean architecture principles
2. Implement proper error handling
3. Use dependency injection
4. Write unit tests for each layer
5. Maintain module independence