AeroToss v0.4.0: полная реализация M1-M4
- KMP проект: Kotlin 2.3.21, Compose 1.11.1, Gradle 8.13, AGP 8.13.2 - Обнаружение устройств: mDNS (JMDNS/Android NSD) + Wi-Fi Direct P2P - Передача файлов: Java Socket, стриминг чанками, SHA-256 checksum - UI: HomeScreen, SendScreen, ReceiveScreen, навигация - Защита: санитизация имён файлов (path traversal) - 65+ тестов (WireProtocol, Transfer, FileUtils, Wi-Fi Direct)
This commit is contained in:
@@ -0,0 +1,97 @@
|
||||
package com.aerotoss
|
||||
|
||||
import android.Manifest
|
||||
import android.content.pm.PackageManager
|
||||
import android.os.Build
|
||||
import android.os.Bundle
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.activity.result.contract.ActivityResultContracts
|
||||
import androidx.core.content.ContextCompat
|
||||
import androidx.lifecycle.lifecycleScope
|
||||
import com.aerotoss.core.AeroTossManager
|
||||
import com.aerotoss.discovery.AndroidNsdDiscovery
|
||||
import com.aerotoss.discovery.CompositeAndroidDiscovery
|
||||
import com.aerotoss.transfer.AndroidFileTransferManager
|
||||
import com.aerotoss.ui.App
|
||||
import com.aerotoss.wifi.WifiDirectManager
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
|
||||
class MainActivity : ComponentActivity() {
|
||||
|
||||
private var manager: AeroTossManager? = null
|
||||
|
||||
private val requiredPermissions: Array<String>
|
||||
get() {
|
||||
val perms = mutableListOf(
|
||||
Manifest.permission.INTERNET,
|
||||
Manifest.permission.ACCESS_WIFI_STATE,
|
||||
Manifest.permission.CHANGE_WIFI_STATE,
|
||||
Manifest.permission.ACCESS_NETWORK_STATE,
|
||||
Manifest.permission.ACCESS_FINE_LOCATION,
|
||||
Manifest.permission.ACCESS_COARSE_LOCATION,
|
||||
Manifest.permission.CHANGE_WIFI_MULTICAST_STATE,
|
||||
)
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||||
perms.add(Manifest.permission.NEARBY_WIFI_DEVICES)
|
||||
}
|
||||
return perms.toTypedArray()
|
||||
}
|
||||
|
||||
private val permissionLauncher = registerForActivityResult(
|
||||
ActivityResultContracts.RequestMultiplePermissions()
|
||||
) { permissions ->
|
||||
val allGranted = permissions.values.all { it }
|
||||
if (allGranted && manager == null) {
|
||||
initializeApp()
|
||||
}
|
||||
}
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
|
||||
if (manager != null) return
|
||||
|
||||
if (hasAllPermissions()) {
|
||||
initializeApp()
|
||||
} else {
|
||||
permissionLauncher.launch(requiredPermissions)
|
||||
}
|
||||
}
|
||||
|
||||
private fun hasAllPermissions(): Boolean {
|
||||
return requiredPermissions.all {
|
||||
ContextCompat.checkSelfPermission(this, it) == PackageManager.PERMISSION_GRANTED
|
||||
}
|
||||
}
|
||||
|
||||
private fun initializeApp() {
|
||||
if (manager != null) return
|
||||
|
||||
val transferManager = AndroidFileTransferManager(applicationContext)
|
||||
val nsdDiscovery = AndroidNsdDiscovery(applicationContext)
|
||||
val wifiDirectManager = WifiDirectManager(applicationContext)
|
||||
val discoveryManager = CompositeAndroidDiscovery(nsdDiscovery, wifiDirectManager)
|
||||
val mgr = AeroTossManager(discoveryManager, transferManager)
|
||||
manager = mgr
|
||||
|
||||
lifecycleScope.launch {
|
||||
val port = withContext(Dispatchers.IO) {
|
||||
transferManager.startServer(0)
|
||||
}
|
||||
mgr.start(port)
|
||||
}
|
||||
|
||||
setContent {
|
||||
App(mgr)
|
||||
}
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
super.onDestroy()
|
||||
manager?.dispose()
|
||||
manager = null
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
package com.aerotoss.discovery
|
||||
|
||||
import android.content.Context
|
||||
import android.net.nsd.NsdManager
|
||||
import android.net.nsd.NsdServiceInfo
|
||||
import android.util.Log
|
||||
import com.aerotoss.model.Device
|
||||
import com.aerotoss.model.DeviceType
|
||||
import com.aerotoss.util.generateDeviceId
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
class AndroidNsdDiscovery(context: Context) : DiscoveryManager {
|
||||
private val _devices = MutableStateFlow<List<Device>>(emptyList())
|
||||
override val devices: Flow<List<Device>> = _devices.asStateFlow()
|
||||
|
||||
private val nsdManager = context.getSystemService(Context.NSD_SERVICE) as NsdManager
|
||||
private var registrationListener: NsdManager.RegistrationListener? = null
|
||||
private var discoveryListener: NsdManager.DiscoveryListener? = null
|
||||
private val deviceId = generateDeviceId()
|
||||
private val discoveredDevices = ConcurrentHashMap<String, Device>()
|
||||
private val resolvingServices = ConcurrentHashMap.newKeySet<String>()
|
||||
|
||||
override fun startDiscovery(servicePort: Int) {
|
||||
registerService(servicePort)
|
||||
startServiceDiscovery()
|
||||
}
|
||||
|
||||
private fun registerService(port: Int) {
|
||||
val serviceInfo = NsdServiceInfo().apply {
|
||||
serviceName = SERVICE_NAME
|
||||
serviceType = SERVICE_TYPE
|
||||
setPort(port)
|
||||
}
|
||||
|
||||
registrationListener = object : NsdManager.RegistrationListener {
|
||||
override fun onServiceRegistered(info: NsdServiceInfo) {
|
||||
Log.d(TAG, "Service registered: ${info.serviceName}")
|
||||
}
|
||||
|
||||
override fun onRegistrationFailed(info: NsdServiceInfo, errorCode: Int) {
|
||||
Log.e(TAG, "Registration failed: $errorCode")
|
||||
}
|
||||
|
||||
override fun onServiceUnregistered(info: NsdServiceInfo) {
|
||||
Log.d(TAG, "Service unregistered")
|
||||
}
|
||||
|
||||
override fun onUnregistrationFailed(info: NsdServiceInfo, errorCode: Int) {
|
||||
Log.e(TAG, "Unregistration failed: $errorCode")
|
||||
}
|
||||
}
|
||||
|
||||
nsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, registrationListener)
|
||||
}
|
||||
|
||||
private fun startServiceDiscovery() {
|
||||
discoveryListener = object : NsdManager.DiscoveryListener {
|
||||
override fun onDiscoveryStarted(serviceType: String) {
|
||||
Log.d(TAG, "Discovery started")
|
||||
}
|
||||
|
||||
override fun onServiceFound(serviceInfo: NsdServiceInfo) {
|
||||
if (serviceInfo.serviceType == SERVICE_TYPE &&
|
||||
serviceInfo.serviceName != SERVICE_NAME &&
|
||||
resolvingServices.add(serviceInfo.serviceName)
|
||||
) {
|
||||
nsdManager.resolveService(serviceInfo, object : NsdManager.ResolveListener {
|
||||
override fun onResolveFailed(info: NsdServiceInfo, errorCode: Int) {
|
||||
resolvingServices.remove(info.serviceName)
|
||||
Log.e(TAG, "Resolve failed: $errorCode")
|
||||
}
|
||||
|
||||
override fun onServiceResolved(info: NsdServiceInfo) {
|
||||
resolvingServices.remove(info.serviceName)
|
||||
val host = info.host?.hostAddress ?: return
|
||||
val device = Device(
|
||||
id = info.serviceName,
|
||||
name = info.serviceName,
|
||||
type = DeviceType.PHONE,
|
||||
hostAddress = host,
|
||||
port = info.port
|
||||
)
|
||||
discoveredDevices[info.serviceName] = device
|
||||
_devices.value = discoveredDevices.values.toList()
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
override fun onServiceLost(serviceInfo: NsdServiceInfo) {
|
||||
discoveredDevices.remove(serviceInfo.serviceName)
|
||||
resolvingServices.remove(serviceInfo.serviceName)
|
||||
_devices.value = discoveredDevices.values.toList()
|
||||
}
|
||||
|
||||
override fun onDiscoveryStopped(serviceType: String) {
|
||||
Log.d(TAG, "Discovery stopped")
|
||||
}
|
||||
|
||||
override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
|
||||
Log.e(TAG, "Discovery start failed: $errorCode")
|
||||
}
|
||||
|
||||
override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {
|
||||
Log.e(TAG, "Discovery stop failed: $errorCode")
|
||||
}
|
||||
}
|
||||
|
||||
nsdManager.discoverServices(SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, discoveryListener)
|
||||
}
|
||||
|
||||
override fun stopDiscovery() {
|
||||
try {
|
||||
discoveryListener?.let { nsdManager.stopServiceDiscovery(it) }
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
try {
|
||||
registrationListener?.let { nsdManager.unregisterService(it) }
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
discoveryListener = null
|
||||
registrationListener = null
|
||||
discoveredDevices.clear()
|
||||
resolvingServices.clear()
|
||||
_devices.value = emptyList()
|
||||
}
|
||||
|
||||
override fun dispose() {
|
||||
stopDiscovery()
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "AndroidNsdDiscovery"
|
||||
private const val SERVICE_TYPE = "_aerotoss._tcp."
|
||||
private const val SERVICE_NAME = "AeroToss"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package com.aerotoss.discovery
|
||||
|
||||
import android.content.Context
|
||||
import com.aerotoss.model.Device
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.cancel
|
||||
import kotlinx.coroutines.flow.*
|
||||
import kotlinx.coroutines.launch
|
||||
import com.aerotoss.wifi.WifiDirectManager
|
||||
|
||||
class CompositeAndroidDiscovery(
|
||||
private val nsdDiscovery: AndroidNsdDiscovery,
|
||||
private val wifiDirectManager: WifiDirectManager
|
||||
) : DiscoveryManager {
|
||||
|
||||
private val _devices = MutableStateFlow<List<Device>>(emptyList())
|
||||
override val devices: Flow<List<Device>> = _devices.asStateFlow()
|
||||
|
||||
private var scope: CoroutineScope? = null
|
||||
private var discoveryJob: kotlinx.coroutines.Job? = null
|
||||
|
||||
override fun startDiscovery(servicePort: Int) {
|
||||
if (discoveryJob != null) return
|
||||
|
||||
nsdDiscovery.startDiscovery(servicePort)
|
||||
wifiDirectManager.initialize()
|
||||
wifiDirectManager.discoverPeers()
|
||||
|
||||
scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
|
||||
discoveryJob = scope?.launch {
|
||||
combine(
|
||||
nsdDiscovery.devices,
|
||||
wifiDirectManager.devices
|
||||
) { nsdDevices, wifiDirectDevices ->
|
||||
val allDevices = mutableMapOf<String, Device>()
|
||||
nsdDevices.forEach { allDevices["nsd:${it.id}"] = it }
|
||||
wifiDirectDevices.forEach { allDevices["wifi:${it.id}"] = it }
|
||||
allDevices.values.toList()
|
||||
}.collect { devices ->
|
||||
_devices.value = devices
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun stopDiscovery() {
|
||||
discoveryJob?.cancel()
|
||||
discoveryJob = null
|
||||
nsdDiscovery.stopDiscovery()
|
||||
wifiDirectManager.stopDiscovery()
|
||||
_devices.value = emptyList()
|
||||
}
|
||||
|
||||
override fun dispose() {
|
||||
stopDiscovery()
|
||||
scope?.cancel()
|
||||
scope = null
|
||||
nsdDiscovery.dispose()
|
||||
wifiDirectManager.cleanup()
|
||||
}
|
||||
|
||||
fun connectWifiDirect(deviceAddress: String) {
|
||||
wifiDirectManager.connect(deviceAddress, groupOwnerIntent = 0)
|
||||
}
|
||||
|
||||
fun disconnectWifiDirect() {
|
||||
wifiDirectManager.disconnect()
|
||||
}
|
||||
|
||||
fun getWifiDirectManager(): WifiDirectManager = wifiDirectManager
|
||||
}
|
||||
@@ -0,0 +1,314 @@
|
||||
package com.aerotoss.transfer
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Environment
|
||||
import com.aerotoss.model.TransferProgress
|
||||
import com.aerotoss.model.TransferRequest
|
||||
import com.aerotoss.model.TransferState
|
||||
import com.aerotoss.util.FileUtils
|
||||
import com.aerotoss.util.getDeviceName
|
||||
import kotlinx.coroutines.*
|
||||
import kotlinx.coroutines.flow.*
|
||||
import kotlinx.serialization.json.Json
|
||||
import java.io.*
|
||||
import java.net.ServerSocket
|
||||
import java.net.Socket
|
||||
import java.security.MessageDigest
|
||||
import java.util.UUID
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
|
||||
@OptIn(ExperimentalCoroutinesApi::class)
|
||||
|
||||
class AndroidFileTransferManager(private val context: Context) : TransferManager {
|
||||
private val _incomingTransfers = MutableStateFlow<List<TransferProgress>>(emptyList())
|
||||
override val incomingTransfers: Flow<TransferProgress> = _incomingTransfers.mapLatest { list ->
|
||||
list.lastOrNull()
|
||||
}.filterNotNull()
|
||||
|
||||
private val _outgoingTransfers = MutableStateFlow<List<TransferProgress>>(emptyList())
|
||||
override val outgoingTransfers: Flow<TransferProgress> = _outgoingTransfers.mapLatest { list ->
|
||||
list.lastOrNull()
|
||||
}.filterNotNull()
|
||||
|
||||
private var serverSocket: ServerSocket? = null
|
||||
private var serverThread: Thread? = null
|
||||
private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
|
||||
private val activeJobs = ConcurrentHashMap<String, Job>()
|
||||
private val running = AtomicBoolean(false)
|
||||
|
||||
private val downloadsDir: File = run {
|
||||
val dir = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)
|
||||
?: context.filesDir
|
||||
File(dir, "AeroToss").apply { mkdirs() }
|
||||
}
|
||||
|
||||
override fun getServerPort(): Int = serverSocket?.localPort ?: 0
|
||||
|
||||
fun startServer(port: Int = 0): Int {
|
||||
if (running.get()) return serverSocket?.localPort ?: 0
|
||||
|
||||
try {
|
||||
val socket = ServerSocket(port)
|
||||
serverSocket = socket
|
||||
running.set(true)
|
||||
|
||||
serverThread = Thread {
|
||||
while (running.get() && !socket.isClosed) {
|
||||
try {
|
||||
val clientSocket = socket.accept()
|
||||
scope.launch { handleIncomingConnection(clientSocket) }
|
||||
} catch (_: Exception) {
|
||||
if (running.get()) break
|
||||
}
|
||||
}
|
||||
}.apply {
|
||||
isDaemon = true
|
||||
name = "aerotoss-server"
|
||||
start()
|
||||
}
|
||||
|
||||
return socket.localPort
|
||||
} catch (e: Exception) {
|
||||
e.printStackTrace()
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun handleIncomingConnection(socket: Socket) {
|
||||
withContext(Dispatchers.IO) {
|
||||
val progressId = UUID.randomUUID().toString()
|
||||
try {
|
||||
socket.use { sock ->
|
||||
sock.soTimeout = 30_000
|
||||
val input = DataInputStream(sock.getInputStream())
|
||||
val output = DataOutputStream(sock.getOutputStream())
|
||||
|
||||
val requestJson = input.readUTF()
|
||||
val request = Json.decodeFromString<TransferRequest>(requestJson)
|
||||
|
||||
val progress = TransferProgress(
|
||||
id = progressId,
|
||||
request = request,
|
||||
bytesTransferred = 0,
|
||||
totalBytes = request.fileSize,
|
||||
state = TransferState.PENDING
|
||||
)
|
||||
updateIncoming(progress)
|
||||
|
||||
output.writeUTF(Json.encodeToString(TransferRequest.serializer(), request))
|
||||
|
||||
val accepted = input.readBoolean()
|
||||
if (!accepted) {
|
||||
updateIncoming(progress.copy(state = TransferState.CANCELLED))
|
||||
return@withContext
|
||||
}
|
||||
|
||||
val file = FileUtils.resolveUniqueFile(downloadsDir, request.fileName)
|
||||
val sha256 = MessageDigest.getInstance("SHA-256")
|
||||
var bytesWritten = 0L
|
||||
|
||||
updateIncoming(progress.copy(state = TransferState.TRANSFERRING))
|
||||
|
||||
file.outputStream().use { fos ->
|
||||
val buffer = ByteArray(65536)
|
||||
var remaining = request.fileSize
|
||||
while (remaining > 0) {
|
||||
val toRead = minOf(buffer.size.toLong(), remaining).toInt()
|
||||
val read = input.read(buffer, 0, toRead)
|
||||
if (read == -1) break
|
||||
fos.write(buffer, 0, read)
|
||||
sha256.update(buffer, 0, read)
|
||||
bytesWritten += read
|
||||
remaining -= read
|
||||
updateIncomingById(progressId, TransferProgress(
|
||||
id = progressId,
|
||||
request = request,
|
||||
bytesTransferred = bytesWritten,
|
||||
totalBytes = request.fileSize,
|
||||
state = TransferState.TRANSFERRING
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
val checksum = "sha256:${sha256.digest().joinToString("") { "%02x".format(it) }}"
|
||||
output.writeUTF(checksum)
|
||||
output.writeLong(bytesWritten)
|
||||
|
||||
if (bytesWritten == request.fileSize) {
|
||||
updateIncomingById(progressId, TransferProgress(
|
||||
id = progressId,
|
||||
request = request,
|
||||
bytesTransferred = bytesWritten,
|
||||
totalBytes = request.fileSize,
|
||||
state = TransferState.COMPLETED
|
||||
))
|
||||
} else {
|
||||
FileUtils.deleteIfExists(file)
|
||||
updateIncomingById(progressId, TransferProgress(
|
||||
id = progressId,
|
||||
request = request,
|
||||
bytesTransferred = bytesWritten,
|
||||
totalBytes = request.fileSize,
|
||||
state = TransferState.FAILED,
|
||||
error = "Incomplete transfer: expected ${request.fileSize}, got $bytesWritten"
|
||||
))
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
e.printStackTrace()
|
||||
val current = _incomingTransfers.value.find { it.id == progressId }
|
||||
if (current != null && current.state != TransferState.COMPLETED &&
|
||||
current.state != TransferState.FAILED && current.state != TransferState.CANCELLED
|
||||
) {
|
||||
FileUtils.deleteIfExists(File(downloadsDir, FileUtils.sanitizeFileName(current.request.fileName)))
|
||||
updateIncomingById(progressId, current.copy(
|
||||
state = TransferState.FAILED,
|
||||
error = e.message ?: "Unknown error"
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun sendFile(file: File, targetHost: String, targetPort: Int): Flow<TransferProgress> {
|
||||
val requestId = UUID.randomUUID().toString()
|
||||
val request = TransferRequest(
|
||||
fileName = file.name,
|
||||
fileSize = file.length(),
|
||||
mimeType = "application/octet-stream",
|
||||
senderId = "",
|
||||
senderName = getDeviceName()
|
||||
)
|
||||
|
||||
val initialProgress = TransferProgress(
|
||||
id = requestId,
|
||||
request = request,
|
||||
bytesTransferred = 0,
|
||||
totalBytes = file.length(),
|
||||
state = TransferState.PENDING
|
||||
)
|
||||
updateOutgoing(initialProgress)
|
||||
|
||||
val job = scope.launch {
|
||||
try {
|
||||
val socket = Socket(targetHost, targetPort)
|
||||
socket.use { sock ->
|
||||
sock.soTimeout = 30_000
|
||||
val input = DataInputStream(sock.getInputStream())
|
||||
val output = DataOutputStream(sock.getOutputStream())
|
||||
|
||||
output.writeUTF(Json.encodeToString(TransferRequest.serializer(), request))
|
||||
|
||||
val serverResponseJson = input.readUTF()
|
||||
val serverRequest = try {
|
||||
Json.decodeFromString<TransferRequest>(serverResponseJson)
|
||||
} catch (_: Exception) {
|
||||
request
|
||||
}
|
||||
|
||||
output.writeBoolean(true)
|
||||
|
||||
updateOutgoingById(requestId, initialProgress.copy(state = TransferState.TRANSFERRING))
|
||||
|
||||
val sha256 = MessageDigest.getInstance("SHA-256")
|
||||
var bytesSent = 0L
|
||||
val buffer = ByteArray(65536)
|
||||
file.inputStream().use { fis ->
|
||||
while (true) {
|
||||
val read = fis.read(buffer)
|
||||
if (read == -1) break
|
||||
output.write(buffer, 0, read)
|
||||
sha256.update(buffer, 0, read)
|
||||
bytesSent += read
|
||||
updateOutgoingById(requestId, TransferProgress(
|
||||
id = requestId,
|
||||
request = request,
|
||||
bytesTransferred = bytesSent,
|
||||
totalBytes = file.length(),
|
||||
state = TransferState.TRANSFERRING
|
||||
))
|
||||
}
|
||||
}
|
||||
output.flush()
|
||||
|
||||
val serverChecksum = input.readUTF()
|
||||
val bytesReceived = input.readLong()
|
||||
|
||||
val localChecksum = "sha256:${sha256.digest().joinToString("") { "%02x".format(it) }}"
|
||||
|
||||
if (bytesReceived == file.length() && serverChecksum == localChecksum) {
|
||||
updateOutgoingById(requestId, TransferProgress(
|
||||
id = requestId,
|
||||
request = request,
|
||||
bytesTransferred = file.length(),
|
||||
totalBytes = file.length(),
|
||||
state = TransferState.COMPLETED
|
||||
))
|
||||
} else {
|
||||
updateOutgoingById(requestId, TransferProgress(
|
||||
id = requestId,
|
||||
request = request,
|
||||
bytesTransferred = bytesSent,
|
||||
totalBytes = file.length(),
|
||||
state = TransferState.FAILED,
|
||||
error = "Checksum mismatch or incomplete transfer"
|
||||
))
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
e.printStackTrace()
|
||||
updateOutgoingById(requestId, initialProgress.copy(
|
||||
state = TransferState.FAILED,
|
||||
error = e.message ?: "Unknown error"
|
||||
))
|
||||
} finally {
|
||||
activeJobs.remove(requestId)
|
||||
}
|
||||
}
|
||||
|
||||
activeJobs[requestId] = job
|
||||
return outgoingTransfers.filter { it.id == requestId }
|
||||
}
|
||||
|
||||
override fun cancelTransfer(requestId: String) {
|
||||
activeJobs[requestId]?.cancel()
|
||||
activeJobs.remove(requestId)
|
||||
updateOutgoingById(requestId, _outgoingTransfers.value.find { it.id == requestId }?.copy(
|
||||
state = TransferState.CANCELLED
|
||||
) ?: return)
|
||||
}
|
||||
|
||||
override fun dispose() {
|
||||
running.set(false)
|
||||
activeJobs.values.forEach { it.cancel() }
|
||||
activeJobs.clear()
|
||||
scope.cancel()
|
||||
try { serverSocket?.close() } catch (_: Exception) {}
|
||||
serverThread?.interrupt()
|
||||
}
|
||||
|
||||
private fun updateIncoming(progress: TransferProgress) {
|
||||
_incomingTransfers.update { list ->
|
||||
list.filter { it.id != progress.id }.plus(progress)
|
||||
}
|
||||
}
|
||||
|
||||
private fun updateIncomingById(id: String, progress: TransferProgress) {
|
||||
_incomingTransfers.update { list ->
|
||||
list.filter { it.id != id }.plus(progress)
|
||||
}
|
||||
}
|
||||
|
||||
private fun updateOutgoing(progress: TransferProgress) {
|
||||
_outgoingTransfers.update { list ->
|
||||
list.filter { it.id != progress.id }.plus(progress)
|
||||
}
|
||||
}
|
||||
|
||||
private fun updateOutgoingById(id: String, progress: TransferProgress) {
|
||||
_outgoingTransfers.update { list ->
|
||||
list.filter { it.id != id }.plus(progress)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package com.aerotoss.util
|
||||
|
||||
import android.os.Build
|
||||
import java.util.UUID
|
||||
|
||||
actual fun generateDeviceId(): String = UUID.randomUUID().toString()
|
||||
|
||||
actual fun getDeviceName(): String = "${Build.MANUFACTURER} ${Build.MODEL}"
|
||||
@@ -0,0 +1,238 @@
|
||||
package com.aerotoss.wifi
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.IntentFilter
|
||||
import android.net.NetworkInfo
|
||||
import android.net.wifi.WpsInfo
|
||||
import android.net.wifi.p2p.*
|
||||
import android.os.Build
|
||||
import android.util.Log
|
||||
import com.aerotoss.model.Device
|
||||
import com.aerotoss.model.DeviceType
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
|
||||
class WifiDirectManager(private val context: Context) {
|
||||
|
||||
private val manager = context.getSystemService(Context.WIFI_P2P_SERVICE) as? WifiP2pManager
|
||||
private var channel: WifiP2pManager.Channel? = null
|
||||
private var receiver: BroadcastReceiver? = null
|
||||
|
||||
private val _peers = MutableStateFlow<List<WifiP2pDevice>>(emptyList())
|
||||
val peers: StateFlow<List<WifiP2pDevice>> = _peers.asStateFlow()
|
||||
|
||||
private val _devices = MutableStateFlow<List<Device>>(emptyList())
|
||||
val devices: StateFlow<List<Device>> = _devices.asStateFlow()
|
||||
|
||||
private val _connectionInfo = MutableStateFlow<WifiP2pInfo?>(null)
|
||||
val connectionInfo: StateFlow<WifiP2pInfo?> = _connectionInfo.asStateFlow()
|
||||
|
||||
private val _groupInfo = MutableStateFlow<WifiP2pGroup?>(null)
|
||||
val groupInfo: StateFlow<WifiP2pGroup?> = _groupInfo.asStateFlow()
|
||||
|
||||
private val _isDiscovering = MutableStateFlow(false)
|
||||
val isDiscovering: StateFlow<Boolean> = _isDiscovering.asStateFlow()
|
||||
|
||||
private val _isConnected = MutableStateFlow(false)
|
||||
val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
|
||||
|
||||
private val _error = MutableStateFlow<String?>(null)
|
||||
val error: StateFlow<String?> = _error.asStateFlow()
|
||||
|
||||
private val knownDevices = ConcurrentHashMap<String, WifiP2pDevice>()
|
||||
|
||||
private val peerListListener = WifiP2pManager.PeerListListener { peerList ->
|
||||
val devices = peerList.deviceList.toList()
|
||||
_peers.value = devices
|
||||
|
||||
devices.forEach { knownDevices[it.deviceAddress] = it }
|
||||
|
||||
_devices.value = devices.map { peer ->
|
||||
Device(
|
||||
id = peer.deviceAddress,
|
||||
name = peer.deviceName.ifEmpty { "Wi-Fi Direct: ${peer.deviceAddress.takeLast(8)}" },
|
||||
type = DeviceType.PHONE,
|
||||
hostAddress = "",
|
||||
port = 0
|
||||
)
|
||||
}
|
||||
Log.d(TAG, "Peers found: ${devices.size}")
|
||||
}
|
||||
|
||||
private val connectionInfoListener = WifiP2pManager.ConnectionInfoListener { info ->
|
||||
_connectionInfo.value = info
|
||||
_isConnected.value = info?.groupFormed == true
|
||||
Log.d(TAG, "Connection info: groupFormed=${info?.groupFormed}, isGroupOwner=${info?.isGroupOwner}")
|
||||
}
|
||||
|
||||
private val groupInfoListener = WifiP2pManager.GroupInfoListener { group ->
|
||||
_groupInfo.value = group
|
||||
if (group != null) {
|
||||
Log.d(TAG, "Group info: owner=${group.owner?.deviceAddress}, clients=${group.clientList.size}")
|
||||
}
|
||||
}
|
||||
|
||||
fun initialize() {
|
||||
if (channel != null) return
|
||||
channel = manager?.initialize(context, context.mainLooper, null)
|
||||
registerReceiver()
|
||||
}
|
||||
|
||||
private fun registerReceiver() {
|
||||
val intentFilter = IntentFilter().apply {
|
||||
addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)
|
||||
addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)
|
||||
addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)
|
||||
addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
|
||||
}
|
||||
|
||||
receiver = object : BroadcastReceiver() {
|
||||
override fun onReceive(ctx: Context, intent: Intent) {
|
||||
when (intent.action) {
|
||||
WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION -> {
|
||||
val state = intent.getIntExtra(
|
||||
WifiP2pManager.EXTRA_WIFI_STATE,
|
||||
WifiP2pManager.WIFI_P2P_STATE_DISABLED
|
||||
)
|
||||
if (state != WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
|
||||
_error.value = "Wi-Fi Direct отключён"
|
||||
_isDiscovering.value = false
|
||||
} else {
|
||||
_error.value = null
|
||||
}
|
||||
}
|
||||
WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> {
|
||||
manager?.requestPeers(channel, peerListListener)
|
||||
}
|
||||
WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> {
|
||||
manager?.requestConnectionInfo(channel, connectionInfoListener)
|
||||
manager?.requestGroupInfo(channel, groupInfoListener)
|
||||
}
|
||||
WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION -> {
|
||||
// Device info changed
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||||
context.registerReceiver(receiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
|
||||
} else {
|
||||
context.registerReceiver(receiver, intentFilter)
|
||||
}
|
||||
}
|
||||
|
||||
fun discoverPeers() {
|
||||
if (channel == null) {
|
||||
_error.value = "Wi-Fi Direct не инициализирован"
|
||||
return
|
||||
}
|
||||
|
||||
_isDiscovering.value = true
|
||||
_error.value = null
|
||||
|
||||
manager?.discoverPeers(channel, object : WifiP2pManager.ActionListener {
|
||||
override fun onSuccess() {
|
||||
Log.d(TAG, "Peer discovery started")
|
||||
}
|
||||
|
||||
override fun onFailure(reason: Int) {
|
||||
_isDiscovering.value = false
|
||||
_error.value = when (reason) {
|
||||
WifiP2pManager.P2P_UNSUPPORTED -> "Wi-Fi Direct не поддерживается"
|
||||
WifiP2pManager.BUSY -> "Wi-Fi Direct занят"
|
||||
WifiP2pManager.ERROR -> "Ошибка Wi-Fi Direct"
|
||||
else -> "Ошибка: $reason"
|
||||
}
|
||||
Log.e(TAG, "Peer discovery failed: $reason")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fun stopDiscovery() {
|
||||
manager?.stopPeerDiscovery(channel, object : WifiP2pManager.ActionListener {
|
||||
override fun onSuccess() {
|
||||
_isDiscovering.value = false
|
||||
Log.d(TAG, "Peer discovery stopped")
|
||||
}
|
||||
|
||||
override fun onFailure(reason: Int) {
|
||||
Log.e(TAG, "Stop discovery failed: $reason")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fun connect(deviceAddress: String, groupOwnerIntent: Int = 0) {
|
||||
val config = WifiP2pConfig().apply {
|
||||
this.deviceAddress = deviceAddress
|
||||
this.groupOwnerIntent = groupOwnerIntent
|
||||
}
|
||||
|
||||
manager?.connect(channel, config, object : WifiP2pManager.ActionListener {
|
||||
override fun onSuccess() {
|
||||
Log.d(TAG, "Connection initiated to $deviceAddress")
|
||||
}
|
||||
|
||||
override fun onFailure(reason: Int) {
|
||||
_error.value = "Ошибка подключения: $reason"
|
||||
Log.e(TAG, "Connection failed: $reason")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fun disconnect() {
|
||||
manager?.removeGroup(channel, object : WifiP2pManager.ActionListener {
|
||||
override fun onSuccess() {
|
||||
_isConnected.value = false
|
||||
_connectionInfo.value = null
|
||||
_groupInfo.value = null
|
||||
Log.d(TAG, "Disconnected")
|
||||
}
|
||||
|
||||
override fun onFailure(reason: Int) {
|
||||
Log.e(TAG, "Disconnect failed: $reason")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fun getConnectionAddress(): String? {
|
||||
val info = _connectionInfo.value ?: return null
|
||||
if (!info.groupFormed) return null
|
||||
|
||||
return if (info.isGroupOwner) {
|
||||
GROUP_OWNER_ADDRESS
|
||||
} else {
|
||||
info.groupOwnerAddress?.hostAddress
|
||||
}
|
||||
}
|
||||
|
||||
fun isGroupOwner(): Boolean {
|
||||
return _connectionInfo.value?.isGroupOwner == true
|
||||
}
|
||||
|
||||
fun cleanup() {
|
||||
try {
|
||||
receiver?.let { context.unregisterReceiver(it) }
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
receiver = null
|
||||
disconnect()
|
||||
knownDevices.clear()
|
||||
_peers.value = emptyList()
|
||||
_devices.value = emptyList()
|
||||
_connectionInfo.value = null
|
||||
_groupInfo.value = null
|
||||
_isConnected.value = false
|
||||
_isDiscovering.value = false
|
||||
_error.value = null
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "WifiDirectManager"
|
||||
const val GROUP_OWNER_ADDRESS = "192.168.49.1"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user