MakeMyDriveFun

Architecture Overview

The application follows a layered architecture pattern with clear separation of concerns:

📂 Project Structure

MakeMyDriveFun/
├── Domain/                    # Business Logic Layer
│   ├── Entities/             # Domain models
│   ├── UseCases/             # Business use cases
│   └── Repositories/         # Repository protocols
├── Data/                     # Data Layer
│   ├── DataSources/          # Remote/Local data sources
│   ├── Models/               # Data Transfer Objects (DTOs)
│   └── Repositories/         # Repository implementations
├── Infrastructure/           # External Dependencies
│   ├── Network/              # Network services
│   └── Location/             # Location services
├── Presentation/             # UI Layer
│   ├── RouteSearch/          # Route search feature
│   ├── FunLocations/         # Fun locations feature
│   └── Common/               # Shared UI components
└── DI/                       # Dependency Injection

🏗️ Clean Architecture Layers

1. Domain Layer

• Entities: Core business objects (Route, RoutePoint, RouteRequest)
• Use Cases: Business logic implementations (GetRouteUseCase)
• Repository Protocols: Abstractions for data access

2. Data Layer

• DTOs: Data transfer objects for API communication
• Data Sources: Remote API data sources
• Repository Implementations: Concrete repository implementations

3. Infrastructure Layer

• Network Service: HTTP client for API communication
• Location Service: Core Location wrapper

4. Presentation Layer

• View Controllers: UIKit view controllers
• View Models: MVVM pattern implementation
• UI Components: Custom UI elements

5. Dependency Injection

• DependencyContainer: Service locator pattern for dependency management

🧹 Clean Code Principles Applied

1. Single Responsibility Principle (SRP)

• Each class has a single, well-defined purpose
• View controllers only handle UI logic
• Use cases contain only business logic
• Data sources only handle data fetching

2. Open/Closed Principle (OCP)

• Classes are open for extension but closed for modification
• Protocol-based architecture allows easy testing and mocking

3. Dependency Inversion Principle (DIP)

• High-level modules don't depend on low-level modules
• Both depend on abstractions (protocols)
• Dependencies are injected, not created

4. Interface Segregation Principle (ISP)

• Protocols are focused and specific
• Clients depend only on interfaces they use

5. Liskov Substitution Principle (LSP)

• Implementations can be substituted without breaking functionality
• Mock implementations for testing

🔧 Key Improvements

Before Refactoring

• Monolithic view controllers with mixed responsibilities
• Direct API calls from UI components
• Tight coupling between layers
• Difficult to test and maintain

After Refactoring

• ✅ Separation of Concerns: Each layer has a clear responsibility
• ✅ Testability: Protocol-based design enables easy unit testing
• ✅ Maintainability: Code is organized and follows consistent patterns
• ✅ Scalability: New features can be added without affecting existing code
• ✅ Error Handling: Comprehensive error handling throughout the application
• ✅ Async/Await: Modern Swift concurrency patterns
• ✅ Constants: Centralized configuration and constants

📱 Features

Route Search

• Input start and end addresses
• Select departure and return dates
• Specify maximum route deviation
• Real-time location services integration

Fun Locations

• Display points of interest along the route
• Categorized location types
• Detailed location information

🏃‍♂️ How to Run

1. Open MakeMyDriveFun.xcodeproj in Xcode
2. Select your development team in Signing & Capabilities (if needed)
3. Choose a simulator or device
4. Build and run the project

✅ Build Status: The project compiles successfully with no errors!

🧪 Testing

The new architecture makes testing straightforward:

// Example unit test for GetRouteUseCase
class GetRouteUseCaseTests: XCTestCase {
    func testExecuteWithValidRequest() async throws {
        // Given
        let mockRepository = MockRouteRepository()
        let useCase = GetRouteUseCase(repository: mockRepository)
        let request = RouteRequest(...)
        
        // When
        let result = try await useCase.execute(request: request)
        
        // Then
        XCTAssertEqual(result.points.count, 5)
    }
}

🔄 Data Flow

1. User Interaction → View Controller
2. View Controller → View Model
3. View Model → Use Case
4. Use Case → Repository (Protocol)
5. Repository → Data Source
6. Data Source → Network Service
7. Network Service → API
8. Response flows back through the same layers

🛠️ Technologies Used

• Swift 5.0+
• UIKit - UI framework
• MapKit - Map integration
• Core Location - Location services
• URLSession - Network requests
• Async/Await - Concurrency
• MVVM - Presentation pattern

🎯 Benefits

1. Maintainability: Easy to modify and extend
2. Testability: Each layer can be tested independently
3. Readability: Clear code structure and naming conventions
4. Scalability: Easy to add new features
5. Reusability: Components can be reused across features
6. Flexibility: Easy to swap implementations

🔮 Future Enhancements

• Add Core Data for local persistence
• Implement Combine for reactive programming
• Add unit and integration tests
• Implement caching strategies
• Add analytics and logging
• Implement offline support

🐛 Recent Bug Fixes

Fixed Issues:

• ✅ Loading Indicator: Added proper loading state with button text changes and user interaction blocking
• ✅ API Response Format: Fixed decoding error by updating DTOs to match API response structure
• ✅ Input Validation: Added validation to prevent API calls with empty required fields
• ✅ Debug Logging: Added network request/response logging for easier debugging
• ✅ Location Permissions: Fixed Info.plist location permission keys
• ✅ Keyboard Handling: Added proper keyboard dismissal and text field navigation

API Integration:

The app now correctly handles the API response format from https://makedrivefunbr.vercel.app/get-route which returns data wrapped in an ai_response object.

🧪 Testing the API

You can test the API directly using:

curl -X POST \
  https://makedrivefunbr.vercel.app/get-route \
  -H 'Content-Type: application/json' \
  -d '{
    "start_address": "Praça da Sé, São Paulo, SP",
    "end_address": "Praia de Copacabana, Rio de Janeiro, RJ",
    "date_of_going": "2025-07-01",
    "date_of_returning": "2025-07-10",
    "max_route_desviation": "30"
  }'

---

This refactored architecture provides a solid foundation for building scalable iOS applications while maintaining clean, testable, and maintainable code.