devapro/lanwalkietalkie

1. What this repo is

- This is a multi-module Android app for local-network push-to-talk communication.

- It does not depend on a central backend: every app instance can both discover peers and communicate directly over Wi‑Fi LAN.

- The app uses Jetpack Compose for UI and an MVI-style state flow for screen logic.

2. Top-level module boundaries

- app is the Android application shell and entry point.

- core contains shared MVI infrastructure used by feature ViewModels.

- core-ui contains shared Compose theme/styling.

- service-network owns peer discovery and socket-based text/data transport.

- service-voice owns audio capture and playback.

- feature-ptt, feature-chat, and feature-settings are UI feature modules built on top of the shared core/services.

3. Application composition and startup

- PttApplication and MainActivity are the app entry points.

- appDi.kt wires the application graph.

- MainViewModel drives the main shell UI: it handles app initialization, permission checks, and active screen/tab selection.

- MainScreenInitStateFactory, MainTabsFactory, and the reducers under app/reducers define the shell state machine.

4. Shared architecture pattern

- The codebase is organized around MVI:

- Actions represent user intent or system requests.

- Reducers transform state in response to events.

- Action processors coordinate side effects and produce events.

- Init state factories build initial UI state.

- This pattern is implemented once in core/mvi and repeated in each feature module with feature-specific actions/events/state.

5. Core MVI layer

- MviViewModel, Reducer, ActionProcessor, InitStateFactory, and CoroutineContextProvider are the reusable framework pieces.

- Feature ViewModels inherit this infrastructure rather than duplicating coroutine/state handling.

- This is the main architectural boundary between UI intent and side effects.

6. Network subsystem: local discovery and message transport

- service-network is responsible for finding nearby devices and exchanging data over sockets.

- DiscoveryListener and RegistrationListener indicate the use of NsdManager for service discovery/registration on the local network.

- SocketServer and SocketClient represent the bidirectional transport layer.

- ChanelControllerImpl is the orchestration layer that likely coordinates channel lifecycle, peer connections, and routing.

- Repositories such as ConnectedDevicesRepository, DeviceInfoRepository, and TextMessagesRepository hold network-facing state/models.

- ClientInfoResolver and getDeviceID.kt support peer identity and device addressing.

7. Voice subsystem: recording and playback

- service-voice owns audio capture and audio output.

- VoiceRecorder uses recording APIs (MediaRecorder / AudioRecord per README intent) to capture push-to-talk audio.

- VoicePlayer uses AudioTrack-style playback to render incoming voice audio.

- VoiceDi.kt provides dependency wiring for the voice layer.

- This module is isolated so the PTT feature can depend on audio behavior without embedding low-level Android audio code.

8. Foreground/background service boundary

- WalkieService is the app’s runtime service boundary for long-lived communication.

- NotificationController manages the persistent foreground notification required for ongoing mic/network activity.

- This service layer is important because the app needs to keep audio and network operations alive while the UI is backgrounded.

9. PTT feature flow

- feature-ptt is the main push-to-talk screen.

- Its state is modeled by PttScreenState, with PttAction and PttEvent driving changes.

- Reducers such as StartRecordingReducer, StopRecordingReducer, and VoiceDataReceivedReducer connect user interaction and incoming network/audio events.

- ConnectedDevicesUpdatedReducer keeps the UI in sync with the current peer list.

- UI files like PTTContent, PTTContentPortrait, PTTContentLandscape, PTTButton, DeviceItem, and WaveCanvas suggest a responsive screen that adapts to orientation and shows live audio/device feedback.

10. Chat feature flow

- feature-chat is the text-message companion to PTT.

- It has its own MVI slice: ChatScreenState, ChatAction, ChatEvent, and ChatViewModel.

- Reducers cover initialization, loading history, sending, receiving, marking read, and device list updates.

- MessageModelMapper converts between network message models and UI models.

- ChatContent, ChatTab, InputSection, and MessageItem form the Compose UI for message history and input.

11. Main shell UI and navigation

- RootContent and OffContent in the app module are the top-level Compose containers.

- BottomTabs, RailTabs, TabsContent, and RequiredPermissionsNotification are shared shell UI elements.

- MainTab and MainTabItem model the app’s tab/navigation structure across PTT, chat, and settings.

- The UI is responsive: it switches between bottom navigation and rail navigation depending on layout/size.

12. Permissions and app readiness

- PermissionState and the permission-related reducers in the app module indicate that the app gates functionality on runtime permissions.

- Required permissions are part of the main shell state, not buried in each feature, so the app can globally block or warn before activating network/audio features.

- This is especially important because audio capture, foreground service behavior, and local discovery all depend on Android runtime permissions.

13. Settings feature

- feature-settings is lightweight and currently mostly a Compose content module.

- Architecturally it fits the same feature-module pattern, but it is less stateful than PTT/chat.

14. Shared UI/theme and platform config

- core-ui provides the app theme (Color.kt, Theme.kt, Type.kt) used by all Compose screens.

- The app module contains drawables, strings, themes, backup rules, and manifest configuration, while each feature module keeps its own manifest and resources.

- The repository also includes Android test and unit test scaffolding per module, plus a GitHub Actions workflow for APK build automation.

15. End-to-end data flow

- User interacts with a feature screen in Compose.

- UI emits an action into the feature ViewModel.

- The MVI processor/reducers update screen state and trigger side effects.

- Side effects call into service-network and/or service-voice.

- Network/audio services communicate with peer devices and feed events back into feature reducers.

- The updated state is rendered back through Compose, while the app shell keeps permissions, tabs, and service status coherent.