Cast: Implement connectionless (Cast.API_CXLESS) device controller

[peterhel]

Cast: Implement connectionless (Cast.API_CXLESS) device controller

Summary

Modern Cast SDK clients — and real apps such as Amazon Prime Video, YouTube,
Netflix — drive the Cast device over the connectionless Cast API
(Cast.API_CXLESS) rather than the classic connection-based path that microG
implemented. As a result, casting from these apps never worked on microG: the
session would start and then stall indefinitely.

This PR implements the connectionless device-controller surface. With it, the
real Amazon Prime Video and Netflix apps launch their own receiver and play a
DRM title end to end on a Chromecast, cast from a de-Googled phone.

Builds on #3567 (which makes the framework start a session when a Cast route is
selected); that session is the trigger that binds the device controller this PR
completes.

The problem

The connectionless client binds the same ICastDeviceController service, but
its handshake differs from the classic client:

• The classic client passes its listener in the GetServiceRequest "listener"
  extra and connects lazily on the first launch/sendMessage.
• The connectionless client instead delivers its listener out-of-band via
  setListener(), then calls connect(), and waits for the service to call
  ICastDeviceControllerListener.onConnectedWithResult before it will launch an
  application. It is otherwise purely reactive.

microG implemented only the classic path. So a connectionless client bound the
service, called setListener/connect (transactions microG didn't handle, and
which were silently dropped because they are oneway), never received
onConnectedWithResult, and stayed "not connected" forever. Withholding the
cxless_* features to force the classic path instead just made the SDK decide
microG was too old and fail with ConnectionResult=2.

There is also a second gate, at the bind itself. The connectionless client
issues its GetServiceRequest with serviceId = CAST_API (161), not
CAST (10). The broker resolves that id against each service's supported ids;
the device-controller service declared only CAST, so the id matched nothing
and the broker rejected the bind with "Service not supported" — which the
sender surfaces to the user as "No devices found", before any of the
handshake above can even run.

The fix

The transaction numbers in microG's AIDL already matched the framework — the
connectionless methods were simply absent. The change is additive:

• ICastDeviceController.aidl — add connect() (txn 17),
  setListener(ICastDeviceControllerListener) (18), unregisterListener() (19).
• ICastDeviceControllerListener.aidl — add onConnectedWithResult(int)
  (txn 14), the readiness signal.
• CastDeviceControllerImpl.java:
  • connect() opens the CastV2 channel and emits
    onConnectedWithResult(SUCCESS).
  • setListener() stores the out-of-band listener.
  • onSendMessageSuccess is now reported from the outgoing sendMessage,
    keyed by that send's requestId. Previously it was reported from inbound
    messages using the response's id, which completed a non-existent client task
    and threw a RemoteException. Inbound messages now go solely through
    onTextMessageReceived.
  • The client's listener binder is watched with linkToDeath; if the client
    process dies without a clean disconnect(), the device connection (and its
    reader thread) is torn down instead of leaked.
• CastDeviceControllerService.java:
  • Advertise the requested API features via ConnectionInfo so the client's
    availability check passes.
  • Accept serviceId CAST_API (161) on the bind, alongside CAST (10),
    so the broker no longer rejects the connectionless client with "Service not
    supported". The same CastDeviceControllerImpl serves both ids — the
    connectionless connect/setListener path handles the request — so no new
    service or implementation is introduced.

Connectionless handshake (for reference)

bind CAST service (serviceId CAST_API, cxless features, EXTRA_CAST_DEVICE, connectionless_client_record_id)
  → setListener(listener)              [txn 18]
  → connect()                          [txn 17]
  ← onConnectedWithResult(0)           [listener txn 14]   // session becomes "connected"
  → launchApplication(appId, opts)     [txn 13]
  ← onApplicationConnectionSuccess     [listener txn 2]
  → sendMessage(LOAD, media namespace) [txn 9]             // + per-app namespaces
  ← onSendMessageSuccess / onTextMessageReceived

Testing

Validated on a Pixel 2 (LineageOS-for-microG, Android 15) against a Chromecast:

• The real, logged-in Amazon Prime Video app selects the device, microG
  launches Prime's own receiver (appId 17608BC8), Prime completes its
  proprietary registration/settings handshake on
  urn:x-cast:com.amazon.primevideo.cast, LOADs a DRM title, and the title
  plays on the TV — with zero failed listener callbacks.
• The real, logged-in Netflix app selects the device, microG accepts the
  CAST_API bind, drives the connectionless setListener/connect handshake
  to onConnectedWithResult(0), launches Netflix's receiver, relays its
  private-namespace traffic, LOADs a DRM title, and the title plays on the
  TV.
• The real, logged-in Disney+ app selects the device over the same
  connectionless path, launches its receiver, and the title plays on the
  TV.
• A minimal first-party Cast sender plays a clip end to end
  (playerState=PLAYING, currentTime advancing).
• Force-killing the sender mid-session triggers the linkToDeath cleanup
  (device disconnected, no leaked connection).

Notes / scope

• CastMediaRouteController.onSelect remains a stub; it is a separate legacy
  route-control path and does not gate the connectionless flow (the framework's
  session manager binds the device controller directly).
• The CAST_API (161) id is accepted at the bind (see above), but no
  additional CAST_API-specific surface (settings/relay/logging) is
  implemented. Netflix and Prime carry their app traffic over the device
  controller's namespaces, so that surface was not needed for casting in
  testing; registerNamespace/unregisterNamespace remain logged no-ops and
  did not block playback.