backburner(WIP)

This is an app I've been thinking about making for a while. Its purpose is to remind the user of notes left on the back-burner without desensitizing the user to the notifications (insta-dismiss). It does this by making sure the time interval between notifications is fairly long (7-14 days), and random. It also serves as a demonstration of my current understanding of Android architecture. The UI is taken from my favorite note taking app, Google Keep.

TODO

• Setup Data Access Layer(DAL)
  • Setup SQLite db using SQLDelight
    • Create Note table
    • Write CRUD queries
    • Create virtual table using FTS4 + triggers to sync data
    • Write Search query
    • Random note query
  • Create Note model class
  • Implement NoteRepository
    • CRUD + Search
    • Random note
  • Wrap everything up in a Dagger module
• Implement View Notes screen
  • Fetch Notes and display them
  • Search notes
  • Navigate to Write Note screen when fab is tapped
  • Navigate to Write Note screen when a note is tapped with shared element animations
  • Use Dagger to inject dependencies
  • Create Dagger Subcomponent
  • Wrap everything up in a Dagger module
  • XML layout for landscape mode
• Implement Write Note screen
  • Create note
  • Proper enter transition animation
  • Refine UI
    • Have EditText take up whole screen
    • Proper transition animation w/ shared elements on back navigation
    • Remove "Add Note" button
  • Save note on back navigation
  • Edit note
  • Delete note
  • Use Dagger to inject dependencies
  • Create Dagger Subcomponent
  • Wrap everything up in a Dagger module
• Implement random notifications
  • Implement Notifier service
    • Implement notify()
    • Define notification channel id
  • Implement Scheduler service
    • scheduleReminder()
      • Queue RemindUserWorker
      • Check if RemindUserWorker has already been queued before queuing
    • makeSureReminderIsScheduled()
      • Queue ScheduleReminderWorker
      • Check if ScheduleReminderWorker has already been queued before queuing
  • Create scaffolding to allow Dagger to inject into Workers
  • Implement RemindUserWorker
    • Inject Notifier service
    • Inject NoteRepository
    • Implement logic
  • Implement ScheduleReminderWorker
• Use dagger.android to cleanup injection code
• Import pinned Google Keep notes
• Allow User to customize the range of time interval between notifications.
• Experiment porting over to Composable Architecture

General architecture

• UI interface: Implementers emit UI events and read off the State that has been computed, turning them into side-effects that render to screen.

• events :: Unit -> Observable<UI.Event>
  

• render :: Observable<UI.UIState> -> Unit
  

• VM interface: Implementers (usually subclasses of lifecycle ViewModel) transform UI events into business-logic Msgs and reduce on those Msgs w/ current state.

• processEvents :: Observable<UI.Event> -> Unit
  

• states :: Unit -> Observable<UI.UIState>
  

• Dependency graph for a given feature (Interactors, VM, UI):

• UI -> VM -> Interactors -> Repositories -> Data sources