AndroidAuto/com.benomad.msdk.androidauto.callback/PhoneAppCallback

PhoneAppCallback

interface PhoneAppCallback : AAConnectionCallback, AASurfaceLifecycleCallback, AANavigationCallback, AARouteCallback

Combined callback interface for the phone app to receive all events from Android Auto.

This interface aggregates all AA callback categories into a single interface for convenience. It extends the four focused callback interfaces that follow the Interface Segregation Principle (ISP):

AAConnectionCallback: Session connection and screen state events
AASurfaceLifecycleCallback: MapView surface initialization/release events
AANavigationCallback: Turn-by-turn guidance lifecycle events
AARouteCallback: Route preview and destination selection events

Purpose

Convenience: Single interface to implement all AA callbacks
Backward Compatibility: Existing code using PhoneAppCallback continues to work
Flexibility: Callers can also use individual interfaces when needed

Interface Hierarchy

PhoneAppCallback
  ├── AAConnectionCallback (3 methods)
  │     ├── onAAConnected()
  │     ├── onAADisconnected()
  │     └── onAAScreenStateChanged(state)
  │
  ├── AASurfaceLifecycleCallback (2 methods)
  │     ├── onAARequestingInit()
  │     └── onAAReleasing()
  │
  ├── AANavigationCallback (4 methods)
  │     ├── onAANavigationStarted(useDemoMode)
  │     ├── onAANavigationEnded()
  │     ├── onAARequestsMapReset()
  │     └── isDemoModeEnabled()
  │
  └── AARouteCallback (4 methods)
        ├── onDestinationSelected(lat, lon, title)
        ├── onAARouteSelected(index)
        ├── onAARouteCancelled()
        └── onAARecenterOnRoute()

Usage

Implement this interface in your MainActivity and register it with the manager:

class MainActivity : ComponentActivity() {
    private val aaCallback = object : PhoneAppCallback {
        // Connection events
        override fun onAAConnected() {
            viewModel.onAndroidAutoConnectionChanged(true)
        }
        override fun onAADisconnected() {
            viewModel.onAndroidAutoConnectionChanged(false)
        }
        override fun onAAScreenStateChanged(state: AndroidAutoScreenState) {
            viewModel.onAAScreenStateChanged(state)
        }

        // Surface lifecycle events
        override fun onAARequestingInit() {
            viewModel.onAARequestingInit()
        }
        override fun onAAReleasing() {
            viewModel.onAAReleasing()
        }

        // Navigation events
        override fun onAANavigationStarted(useDemoMode: Boolean) {
            viewModel.onAANavigationStarted(useDemoMode)
        }
        override fun onAANavigationEnded() {
            viewModel.onAANavigationEnded()
        }
        override fun onAARequestsMapReset() {
            viewModel.resetMapViewForTracking()
        }
        override fun isDemoModeEnabled(): Boolean {
            return viewModel.isDemoModeEnabled()
        }

        // Route events
        override fun onDestinationSelected(latitude: Double, longitude: Double, title: String) {
            viewModel.showDestinationOnMap(latitude, longitude, title)
        }
        override fun onAARouteSelected(index: Int) {
            viewModel.onAARouteSelected(index)
        }
        override fun onAARouteCancelled() {
            viewModel.onAARouteCancelled()
        }
        override fun onAARecenterOnRoute() {
            viewModel.onAARecenterOnRoute()
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        AndroidAutoSurfaceManager.setPhoneAppCallback(aaCallback)
    }
}

Why Split Interfaces?

The original single interface had 14 methods, which violated ISP because:

Callers had to know about all methods even if they only used a subset
The interface mixed unrelated responsibilities
Documentation was harder to organize

The split provides:

Clear Responsibilities: Each interface has a focused purpose
Better Documentation: Grouped methods are easier to understand
Future Flexibility: Callers can reference specific interfaces in their types