добавь в код отображение лога из logcat на экране в нижней половине приложения package com.example.getfile

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.os.Environment
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.FileProvider
import androidx.lifecycle.lifecycleScope
import io.ktor.http.content.*
import io.ktor.server.application.call
import io.ktor.server.engine.embeddedServer
import io.ktor.server.netty.Netty
import io.ktor.server.request.receiveMultipart
import io.ktor.server.response.respondText
import io.ktor.server.routing.post
import io.ktor.server.routing.routing
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import java.io.File
import java.io.FileOutputStream
import java.net.Inet4Address
import java.net.NetworkInterface
import java.net.SocketException
import java.net.URL

class MainActivity : AppCompatActivity() {

    private lateinit var logTextView: TextView
    private lateinit var fileLinkTextView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        logTextView = findViewById(R.id.logTextView)
        fileLinkTextView = findViewById(R.id.fileLinkTextView)

        // Запустим Ktor сервер в фоновом потоке
        lifecycleScope.launch(Dispatchers.IO) {
            try {
                val server = embeddedServer(Netty, port = 8080) {
                    routing {
                        post("/upload") {
                            logEvent("Поступил запрос на загрузку файла")
                            val multipartData = call.receiveMultipart()
                            multipartData.forEachPart { part ->
                                if (part is PartData.FileItem) {
                                    // Сохраним файл
                                    val fileName = "zlo.apk"
                                    val fileBytes = part.streamProvider().readBytes()

                                    // Определим файл для сохранения в папке Downloads
                                    val downloadsDir = getExternalFilesDir(null)?.absolutePath + "/Download"
                                    val file = File(downloadsDir, fileName)

                                    // Убедимся, что папка Downloads существует
                                    if (!file.parentFile.exists()) {
                                        file.parentFile.mkdirs()
                                    }

                                    // Запишем байты в файл
                                    FileOutputStream(file).use { outputStream ->
                                        outputStream.write(fileBytes)
                                    }

                                    logEvent("Файл получен и сохранен как: $fileName в папке Downloads")
                                    // Обновим TextView ссылкой на файл
                                    runOnUiThread {
                                        fileLinkTextView.text = file.absolutePath
                                    }
                                }
                                part.dispose()
                            }
                            call.respondText("Файл принят")
                        }
                    }
                }

                // Получим внешний IP-адрес
                val externalIp = URL("http://checkip.amazonaws.com").readText().trim()

                // Получим Wi-Fi IPv4 адрес, начиная с 192.168.
                val wifiIpAddress = getWifiIpv4Address()

                // Получим IPv4-адрес во внутренней сети
                val internalIpAddress = getInternalIpv4Address()

                // Отобразим полные URL-адреса сервера в логе событий
                val port = server.environment.connectors[0].port
                val path = "/upload"
                val externalUrl = "http://$externalIp:$port$path"
                val wifiUrl = "http://$wifiIpAddress:$port$path"
                val internalUrl = "http://$internalIpAddress:$port$path"
                logEvent("Сервер запущен по следующим адресам:")
                logEvent("Внешний адрес: $externalUrl")
                logEvent("Wi-Fi адрес: $wifiUrl")
                logEvent("Внутренний адрес: $internalUrl")

                server.start(wait = true)
            } catch (e: Exception) {
                logEvent("Ошибка сервера: ${e.message}")
            }
        }

        fileLinkTextView.setOnClickListener {
            val file = File(fileLinkTextView.text.toString())
            if (file.exists()) {
                openFileInExplorer(file)
            } else {
                logEvent("Файл не найден: ${file.absolutePath}")
            }
        }
    }

    private fun openFileInExplorer(file: File) {
        val intent = Intent(Intent.ACTION_GET_CONTENT)
        val uri = FileProvider.getUriForFile(this, applicationContext.packageName + ".provider", file)
        intent.setDataAndType(uri, "*/*")
        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
        startActivity(Intent.createChooser(intent, "Open with"))
    }

    private fun getWifiIpv4Address(): String {
        var ipAddress: String? = null
        try {
            val en = NetworkInterface.getNetworkInterfaces()
            while (en.hasMoreElements()) {
                val intf = en.nextElement()
                val enumIpAddr = intf.inetAddresses
                while (enumIpAddr.hasMoreElements()) {
                    val inetAddress = enumIpAddr.nextElement()
                    if (!inetAddress.isLoopbackAddress && inetAddress.isSiteLocalAddress && inetAddress is Inet4Address) {
                        if (inetAddress.hostAddress.startsWith("192.168.")) {
                            ipAddress = inetAddress.hostAddress
                            break
                        }
                    }
                }
                if (ipAddress != null) break
            }
        } catch (ex: SocketException) {
            logEvent("Ошибка получения Wi-Fi адреса: ${ex.message}")
        }
        return ipAddress ?: "127.0.0.1"
    }

    private fun getInternalIpv4Address(): String {
        var ipAddress = "127.0.0.1"
        try {
            val en = NetworkInterface.getNetworkInterfaces()
            while (en.hasMoreElements()) {
                val intf = en.nextElement()
                val enumIpAddr = intf.inetAddresses
                while (enumIpAddr.hasMoreElements()) {
                    val inetAddress = enumIpAddr.nextElement()
                    if (!inetAddress.isLoopbackAddress && inetAddress is Inet4Address) {
                        ipAddress = inetAddress.hostAddress
                        break
                    }
                }
            }
        } catch (ex: SocketException) {
            logEvent("Ошибка получения внутреннего адреса: ${ex.message}")
        }
        return ipAddress
    }

    private fun logEvent(message: String) {
        runOnUiThread {
            logTextView.append("$message\n")
        }
    }
}