App Architecture

Pocket Planner is designed using a modular architecture, following Clean Architecture principles and the MVI pattern. Below is a detailed breakdown of the file structure:

                    ─ presentation
                       ├── navigation
                       │     └── AppNavigation.kt
                       ├── screen
                       │     ├── categorymonthdetail
                       │     │     ├── content
                       │     │     │    └── CategoryMonthDetailContent.kt
                       │     │     └── observer
                       │     │          └── CategoryMonthDetailObserver.kt
                       │     ├── createexpense
                       │     │     ├── content
                       │     │     │    └── CreateExpenseContent.kt
                       │     │     └── observer
                       │     │          └── CreateExpenseObserver.kt
                       │     └── home
                       │           ├── content
                       │           │    ├── HomeBodyContent.kt
                       │           │    └── HomeHeaderContent.kt
                       │           └── observer
                       │                └── HomeObserver.kt
                       └── viewmodel
                             ├── createincome
                             │     └── CreateIncomeViewModel.kt
                             ├── editexpense
                             │     └── EditExpenseViewModel.kt
                             └── months
                                   ├── MonthsScreenState.kt
                                   └── MonthsViewModel.kt
                

                    ─ navigation
                       ├── di
                       │     ├── AppModule.kt
                       │     └── PlatformModule.kt
                       └── impl
                             └── AppNavigationImpl.kt
                

                    ─ theme
                       ├── Color.kt
                       ├── Dimen.kt
                       ├── Shape.kt
                       └── Type.kt
                

                    ─ core
                       ├── mapper
                       │     └── ResultMapper.kt
                       ├── network
                       │     └── ResponseResult.kt
                       ├── navigation
                       │     └── LocalNavController.kt
                       └── utils
                             ├── Extensions.kt
                             └── NoRippleInteractionSource.kt
                

                    ─ data
                       ├── database
                       │     ├── expense
                       │     │     └── ExpenseFunctions.kt
                       │     ├── income
                       │     │     └── IncomeFunctions.kt
                       │     └── month
                       │           └── MonthFunctions.kt
                       ├── repository
                       │     └── FinanceRepositoryImpl.kt
                       └── sqldelight
                             ├── expense
                             │     └── Expense.sq
                             └── month
                                   └── Month.sq
                

                    ─ domain
                       ├── model
                       │     ├── FinanceModel.kt
                       │     ├── MonthModel.kt
                       │     └── FinanceLocalDate.kt
                       ├── repository
                       │     └── FinanceRepository.kt
                       └── usecase
                             ├── CreateExpenseUseCase.kt
                             └── GetExpenseUseCase.kt
                

                    ─ components
                       ├── alertdialog
                       │     └── AlertDialog.kt
                       ├── button
                       │     └── Button.kt
                       ├── chart
                       │     ├── FinanceBarChart.kt
                       │     └── FinanceLineChart.kt
                       ├── textfield
                             └── AmountOutlineTextField.kt
                

                    ─ androidMain
                       ├── kotlin
                       │     └── com
                       │           └── daviekim
                       │                 └── myfinance
                       │                       └── app
                       │                             └── MainActivity.kt
                       └── res
                             ├── mipmap-anydpi-v26
                             │     └── ic_launcher.xml
                             └── values
                                   └── strings.xml
                

                    ─ test
                       ├── data
                       │     ├── repository
                       │     │     ├── database
                       │     │     │     └── FakeDatabaseFinanceDataSource.kt
                       │     │     └── impl
                       │     │           └── FinanceRepositoryImplTest.kt
                       │     └── impl
                       │           └── FakeFinanceRepositoryImpl.kt
                       ├── domain
                       │     └── usecase
                       │           ├── GetExpenseUseCaseTest.kt
                       │           ├── GetFinanceUseCaseTest.kt
                       │           └── GetMonthsUseCaseTest.kt
                       ├── mock
                       │     └── DatabaseFinanceDataSourceMock.kt
                       └── presentation
                             └── viewmodel
                                   ├── createexpense
                                   │     └── CreateExpenseViewModelTest.kt
                                   ├── home
                                   │     └── HomeViewModelTest.kt
                                   └── months
                                         └── MonthsViewModelTest.kt
                

Technologies Used

During the development of Pocket Planner, the following technologies and tools were utilized:

• Kotlin Multiplatform: Enabled cross-platform development for both Android and iOS, ensuring smooth functionality across devices.
• Koin: Dependency injection framework for efficiently managing dependencies.
• SQLDelight: Provided type-safe SQL database interactions across platforms.
• Orbit Core for MVI: Used to implement the Model-View-Intent (MVI) architecture, ensuring a reactive and predictable UI.
• Kotlinm-Charts: Library used for visualizing financial data with various chart types.
• Kotlinx Coroutines: Enabled smooth and efficient handling of asynchronous tasks.
• GitHub Actions: Automated CI processes, including running unit tests and enforcing consistent code styles.

Challenges Faced

Some of the major challenges encountered during development were:

• Cross-Platform Development: Integrating the same codebase for Android and iOS while maintaining platform-specific features required careful planning and testing.
• State Management: Managing complex UI states with the MVI architecture posed challenges in synchronizing states across different components.
• Database Synchronization: Implementing SQLDelight for seamless offline functionality while ensuring data consistency across devices.
• UI Responsiveness: Creating responsive and interactive chart visualizations that could handle large datasets on different screen sizes.

Achievements

The development of Pocket Planner led to several significant achievements:

• Successful Cross-Platform Functionality: Pocket Planner is fully functional on both Android and iOS, offering a seamless experience across platforms.
• Comprehensive Testing: The use of unit tests and GitHub Actions for continuous integration ensured the app’s reliability and performance.
• Offline Capabilities: Achieved full offline functionality, allowing users to manage their finances without an internet connection.
• Interactive Data Visualization: Successfully implemented interactive charts, providing users with clear insights into their spending habits.
• Multi Module and Clean Architecture Successfully developed the application professionally using Multimodule and Clean architecture