jonalmeida
commented
5 years ago EDIT: Renamed 'Share Manager' to 'Nearby Manager' to avoid immediate confusion with android sharing.
There are two major parts for local sharing controlled by the main entry point, Nearby Manager:
- Discoverability
- Transfer Protocol
The 'Nearby Manager' co-ordinates the Discovery Manager and the Tunnel Manager and allows the app to be notified of connections established/failed and turning services on/off.
```mermaid
graph TD;
A[Nearby Manager] --> B[Discovery Manager]
A --> C[Tunnel Manager]
B --> D[Wifi]
B --> E[Bluetooth]
C --> F[Wifi]
C --> G[Bluetooth]
F --> H[Server]
F --> I[Client]
G --> J[Server]
G --> K[Client]
```
Discoverability
Discovery Manager
- Controls which bearers are turned on/off.
- Manages/Listens to those bearers to notify listeners that we have
- This is how the device broadcasts the services available for transport.
- WiFi uses DNS-SD (local network service discovery) - it broadcasts the services it has which other devices listen to.
- Bluetooth has service scan filtering by UUID - we use a hardcoded UUID to scan for across devices.
- These service discovery bearers need to be abstracted out so that if we want to add more we can do that in the future.
- We would hard code a sensible bearer priority if multiple are available. (e.g. Wi-Fi > Bluetooth > USB)
Interface
interface DiscoveryService {
fun scanningStarted()
fun scanningStopped()
fun deviceFound(Service device)
fun deviceLost(Service device)
val bearerType: ServiecType
val deviceName: String /* Update discovable name of device */
}
sealed class Service(val deviceType: DeviceType) {
data WifiDevice(val uuid: String, val host: String, val port: Int)
data BluetoothDevice(val uuid: String, val macAddress: String)
}
enum class ServiceType {
Wifi,
Bluetooth,
Unknown
}
enum class DeviceType {
Mobile,
Desktop,
Unknown
}
class DiscoveryManager(discoveryBearers: List<DiscoveryBearer>) {
fun init(enableWifi: Boolean, enableBluetooth: Boolean)
fun enableService(/* TBD */)
fun disableService(/* TBD */)
fun deviceFound(device: Bearer, type: BearerType)
fun deviceLost(device: Bearer, type: BearerType)
}Transfer Protocol
Tunnel Manager
-
V1:
- For each bearer that broadcasts itself, we need a transport that would allow us to transfer data across it - 1-1 mapping.
- WiFi uses mDNS to broadcast; WebSocket server for transport layer.
- BluetoothLE to broadcast; BluetoothServer for transport layer.
- When in "discovery" mode, we should be starting a the same service's tunnel server for accepting connections.
-
Future:
- Discovery and transport don’t need to be tied together. e.g. Discovery on bluetooth, transport over WiFi Direct.
- More discovery possibilities; Google's Nearby API, USB, quantum tunneling.
interface TunnelServer {
fun start()
fun stop()
fun tunnelOpened(tunnel: Tunnel)
fun tunnelClosed(tunnel: Tunnel)
fun broadcast(data: ByteArray) = Unit // not required
fun broadcast(data: String) = Unit // not required
}
interface Tunnel {
fun close()
fun send(data: ByteArray)
fun send(data: String)
fun isOpen()
}
abstract class TunnelClient implements Tunnel {
abstract fun onConnect(tunnel: Tunnel)
abstract fun onClose(tunnel: Tunnel)
abstract fun onMessage(tunnel: Tunnel, data: ByteArray)
abstract fun onMessage(tunnel: Tunnel, data: String)
}
class TunnelManager(val servers: List<TunnelServer>) {
fun init() = servers.forEach{ it.start() }
}Nearby Manager
Connects the DiscoveryManager and TunnelManager together.
class NearbyManager(
val discoveryManager: DiscoveryManager,
val tunnelManager: TunnelManager
) {
val priorityList: List<BearerType> = listOf(Wifi, Bluetooth)
val deviceName
get() = field.value
set(value) { /* notify discovery service */ }
/* various notifiers for the app; tbd */
discoveryManager.onServiceSelected ( service -> service.connect() )
tunnelManager.onConnected { tunnel -> notifyObservers { connected(Tunnel) } }
}User Flows
- User A has Wi-Fi; app has enabled Wi-Fi service:
- Wifi tunnel server started.
- User A discovers User B.
- User B selected and WebSocket client connection attempted and established (app notified to send data)
- User A has Bluetooth; app has enabled Bluetooth service:
- Bluetooth tunnel server started.
- User A discovers User B.
- User B selected and Bluetooth client connection attempted and established (app notified to send data)
- User A has Wifi and Bluetooth enabled, app has enabled both services:
- User finds and selects User B on Wi-Fi and Bluetooth.
- Nearby Manager considers the priority list to choose which service to use.
- Connects to [insert higher priority device].
- User fails to connect to a service:
- User A finds and selects User B.
- A client connection attempted and failed (app notified of failure).
- Note: Do we try again? If there are multiple services available, do we try the second one?
pocmo
justindarc
We want to be able to find devices in the area that we may not already be paired to so we can share sessions.
This component would mostly be for discovering/connecting to other devices. The data itself can be figured out later (separately?).
┆Issue is synchronized with this Jira Task