Как запустить цикл с okhttp3 в фоновом режиме Android?

Question

[uzolenta]

Файл ForegroundService. Всё работает, оповещение появляется и данные отправляются в FirstActivity

class ForegroundService : Service() {
    
    private var myCallback: MyCallback? = null
    // Метод для установки объекта MyCallback
    private fun setCallback(callback: MyCallback, data: String) {
        myCallback = callback
        myCallback!!.updateUI(data)
    }

    private val CHANNEL_ID = "1"
    companion object {
        fun startService(context: Context, message: String) {
            val startIntent = Intent(context, ForegroundService::class.java)
            startIntent.putExtra("inputExtra", message)
            ContextCompat.startForegroundService(context, startIntent)
        }
        fun stopService(context: Context) {
            val stopIntent = Intent(context, ForegroundService::class.java)
            context.stopService(stopIntent)
        }
    }
    @RequiresApi(Build.VERSION_CODES.O)
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        //do heavy work on a background thread
        val input = intent?.getStringExtra("inputExtra")
        createNotificationChannel()
        val notificationIntent = Intent(this, PostingVKActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
        )

        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service Kotlin Example")
            .setContentText(input)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentIntent(pendingIntent)
            .build()

        val firstActivity = PostingVKActivity()
        val activity = ForegroundService()
        activity.setCallback(firstActivity, "9999")

        startForeground(2, notification)

        return START_NOT_STICKY
    }
    override fun onBind(intent: Intent): IBinder? {
        return null
    }
    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
            val serviceChannel = NotificationChannel(CHANNEL_ID, "2",
                NotificationManager.IMPORTANCE_DEFAULT)
            val manager = getSystemService(NotificationManager::class.java)
            manager!!.createNotificationChannel(serviceChannel)
    }
}

файл FirstActivity. При нажатии на Button значение в gEditText Пеняется на "1". Запускается сервис, приходит уведомление. в Функции "updateUI" срабатывает println("data updateUI: $data") и выводит данные из Service. Но в этой функции не хочет срабатывать currentName.value = "8888", точнее значение присваивается и выводится, но не меняется в gEditText, как при нажатии на Button.
Если напрямую делать gEditText.text = data, то выскакивает ошибка об инициализации gEditText.text.

interface MyCallback {
    fun updateUI(data: String)
}

class FirstActivity : AppCompatActivity(), MyCallback {
private lateinit var binding: ActivityFirstBinding

lateinit var gEditText: TextView
lateinit var button: Button


val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

override fun updateUI(data: String){
            // Здесь вы обновляете ваш интерфейс, например, ваш TextView
            println("data updateUI: $data")
            currentName.value = "8888"
            println("currentName.value updateUI: ${currentName.value}")
            }

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityFirstBinding.inflate(layoutInflater)

gEditText = binding.gEditText
Button = binding.Button


val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            gEditText.text = newName
        }
        currentName.observe(this, nameObserver)

Button.setOnClickListener {
currentName.value = "1"
val intentActivity = Intent(this, ForegroundService::class.java)
intentActivity.putExtra("inputExtra", "444");
startService(intentActivity)
}

setContentView(binding.root)
}
}

Comments

[kitcat2004]

Для выполнения фоновых запросов с паузой между ними, вы можете использовать Handler и Runnable. Также, чтобы обеспечить более стабильное выполнение в фоновом режиме, рассмотрите использование службы (Service), чтобы код продолжал работать даже при сворачивании приложения.

Вот пример того, как вы можете изменить ваш код:

import android.app.IntentService
import android.content.Intent
import android.os.Handler
import android.os.Looper

class MyService : IntentService("MyService") {
    private val handler = Handler(Looper.getMainLooper())
    private var g = 0

    override fun onHandleIntent(intent: Intent?) {
        while (g < 10) {
            val api = "https://test.ru/g=$g"
            // Создайте и отправьте запрос

            // Обновите UI через главный поток
            handler.post {
                // Обновите ваш UI здесь
                gEditText.text = "$g"
            }

            g++
            
            // Подождите 2 секунды перед следующим запросом
            try {
                Thread.sleep(2000)
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
        }
    }
}

Этот код создает службу MyService, которая выполняет запросы и обновляет интерфейс в главном потоке с учетом задержки в 2 секунды между запросами.
Вам нужно создать службу, запустить ее из FirstActivity, и передать ей необходимые параметры,
если таковые имеются.

Обратите внимание, что Вам также может потребоваться разрешение на использование сети и интернета в вашем файле манифеста Android. Для ответа я использовал представленный код Kotlin

[uzolenta]

kitcat2004, Спасибо за помощь.
Но сейчас всё-таки более правильно юзать WorkManager или никак разница не почувствуется?

и ещё дилетантский вопрос: код, который Вы дали, как его "поженить" с моим активити?
class Activity : AppCompatActivity() {}

Если без взаимодействия с интерфейсом, то понятно, просто отдельный файл под класс создать и к нему обращаться. Но Вы показали, что из Service возможно взаимодействовать с интерфейсом. Напишите подробнее, пожалуйста, как лучше.

[kitcat2004]

uzolenta,
Для выполнения фоновых задач, включая сетевые запросы с паузами между ними, в Android, есть несколько вариантов, и выбор зависит от ваших конкретных требований и сценариев.

WorkManager и Service - два из них. Рассмотрим их более подробно.

WorkManager - это часть Android Architecture Components, предназначенная для выполнения фоновых задач, включая повторяющиеся и одноразовые.
Он обеспечивает управление задачами, отложенными выполнением и сохранением состояния между перезапусками устройства.

Преимущества использования WorkManager:

Он автоматически управляет выполнением задач в различных условиях, включая ограничения на сеть и состояние устройства.
Позволяет устанавливать задержки между задачами.
Может быть легко интегрирован с вашим приложением и не требует много кода.
Пример использования WorkManager для вашей задачи:

// Создайте рабочего (Worker) для выполнения запросов
class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        var g = 0
        while (g < 10) {
            // Выполняйте запрос и обновляйте UI здесь
            // ...
            g++
            Thread.sleep(2000) // Подождите 2 секунды перед следующим запросом
        }
        return Result.success()
    }
}

Service - это компонент Android, который позволяет выполнять фоновые операции.
В предоставленном вами коде, он может использоваться для асинхронных запросов с задержкой между ними.

Преимущества использования Service:

Более полный контроль над фоновыми задачами.
Может использоваться для взаимодействия с интерфейсом, хотя это требует использования обратных вызовов (callbacks) или широковещательных сообщений.
Для взаимодействия с интерфейсом из службы, вы можете использовать LocalBroadcastManager, чтобы отправлять широковещательные сообщения, которые ваша активность будет прослушивать.

Пример использования Service для вашей задачи:

class MyService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Ваш код выполнения запросов с задержкой
        // ...

        return START_STICKY
    }

    override fun onBind(intent: Intent?): IBinder? {
        return null
    }
}

Оба варианта имеют свои преимущества, и выбор зависит от ваших конкретных потребностей.
Если вам не требуется полный контроль и управление,
WorkManager может быть более простым и надежным выбором.
Если вам нужно более сложное взаимодействие с интерфейсом, Service может быть подходящим вариантом.

[kitcat2004]

uzolenta,
далее отвечая на Ваш вопрос, о "поженить сервисы".

Чтобы "поженить" Ваш активити (назовем его FirstActivity) с другим классом (назовем его Activity),
чтобы последний мог взаимодействовать с UI Вашего активити, Вы можете использовать интерфейсы и обратные вызовы (callbacks).

Вот пример, как это можно сделать:

Создайте интерфейс:

Вам нужно создать интерфейс, который будет определять методы для обратных вызовов из вашего класса Activity.

interface MyCallback {
    fun updateUI(data: String)
}

В вашем классе FirstActivity реализуйте интерфейс:

В FirstActivity, вы реализуете интерфейс и предоставите реализацию метода updateUI, который будет обновлять ваш интерфейс.

class FirstActivity : AppCompatActivity(), MyCallback {
    // ... остальной код активити

    override fun updateUI(data: String) {
        // Здесь вы обновляете ваш интерфейс, например, ваш TextView
        gEditText.text = data
    }
}

В вашем классе Activity, внедрите ссылку на MyCallback:

В классе Activity, внедрите ссылку на объект MyCallback, чтобы он мог вызывать метод updateUI в активности FirstActivity.

class Activity {
    private var myCallback: MyCallback? = null

    // Метод для установки объекта MyCallback
    fun setCallback(callback: MyCallback) {
        myCallback = callback
    }

    // Где-то в вашем коде, когда нужно обновить UI, вызывайте метод updateUI
    private fun someMethod() {
        // ...
        myCallback?.updateUI("Новое значение для UI")
    }
}

Свяжите Activity и FirstActivity:

Где бы вы не создавали экземпляр Activity, установите в него ссылку на объект MyCallback, который будет представлять FirstActivity.

val firstActivity = FirstActivity()
val activity = Activity()

// Свяжите Activity и FirstActivity
activity.setCallback(firstActivity)

Теперь Activity может вызывать метод updateUI через myCallback, и это будет обновлять интерфейс в вашей FirstActivity.

[uzolenta]

kitcat2004, благодарю за развёрнутые ответы. Буду пробовать.

[kitcat2004]

uzolenta, попробуйте пользоваться встроенным в Android Studio 2022 плагином AI Copilot (он платный)
или использовать бесплатный Bito основанный на GPT от OpenAI,
и задавать свои уточняющие вопросы на русском языке, приведя ему пример своего кода,
с которым не можете справиться.

Возможно, что это поможет! Или пользоваться ChatGPT 3.5 Turbo для него требуется VPN (лучше Германия или Франция, иногда помогает решить повседневные задачи в разработке.

spoiler

Всё таки 21 век, технологии и нейронки автоматизируют процессы, в том числе написания кода.

[uzolenta]

kitcat2004,
Что-то не получается вызвать myCallBack
Возможно, как-то неправильно понял куда вставлять

val firstActivity = FirstActivity()
val activity = Activity()

// Свяжите Activity и FirstActivity
activity.setCallback(firstActivity)

class ForegroundService : Service() {

    private var myCallback: MyCallback? = null

    // Метод для установки объекта MyCallback
    private fun setCallback(callback: MyCallback) {
        myCallback = callback
    }

    private val CHANNEL_ID = "1"
    companion object {
        fun startService(context: Context, message: String) {
            val startIntent = Intent(context, ForegroundService::class.java)
            startIntent.putExtra("inputExtra", message)
            ContextCompat.startForegroundService(context, startIntent)
        }
        fun stopService(context: Context) {
            val stopIntent = Intent(context, ForegroundService::class.java)
            context.stopService(stopIntent)
        }
    }
    @RequiresApi(Build.VERSION_CODES.O)
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        //do heavy work on a background thread
        val input = intent?.getStringExtra("inputExtra")
        createNotificationChannel()
        val notificationIntent = Intent(this, PostingVKActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
        )

        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service Kotlin Example")
            .setContentText(input)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentIntent(pendingIntent)
            .build()

        val firstActivity = FirstActivity()
        val activity = ForegroundService()
        activity.setCallback(firstActivity)
        myCallback?.updateUI("TEST DATA")



        startForeground(2, notification)

        return START_NOT_STICKY
    }
    override fun onBind(intent: Intent): IBinder? {
        return null
    }
    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
            val serviceChannel = NotificationChannel(CHANNEL_ID, "2",
                NotificationManager.IMPORTANCE_DEFAULT)
            val manager = getSystemService(NotificationManager::class.java)
            manager!!.createNotificationChannel(serviceChannel)
    }
}

FirstActivity

interface MyCallback {
    fun updateUI(data: String)
}
classFirstActivity : AppCompatActivity(), MyCallback {
override fun updateUI(data: String) {
        // Здесь вы обновляете ваш интерфейс, например, ваш TextView
        println("data: $data")

        gEditText.text = data
    }
}

[uzolenta]

Если делаю так, то myCallback инициализируется и данные передаются. Так правильно?

class ForegroundService : Service() {

    private var myCallback: MyCallback? = null

    // Метод для установки объекта MyCallback
    private fun setCallback(callback: MyCallback) {
        myCallback = callback
myCallback?.updateUI("TEST DATA")
    }
}

но тогда возникает проблема с инициализацией gEditText, это поле я инициализирую через Binding в onCreate

override fun updateUI(data: String) {
        // Здесь вы обновляете ваш интерфейс, например, ваш TextView
        println("data: $data")

        gEditText.text = data
    }

[kitcat2004]

uzolenta, Для выполнения фоновых запросов с использованием OkHttp3 в Android и управления UI обновлениями с использованием MyCallback, вам необходимо выполнить следующие шаги:

Создайте MyWorker для выполнения фоновых задач, включая OkHttp3 запросы и вызовы updateUI:

import android.content.Context
import androidx.work.Worker
import androidx.work.WorkerParameters

class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params), MyCallback {
    override fun doWork(): Result {
        var g = 0
        while (g < 10) {
            // Выполняйте запрос и обновляйте UI здесь
            // ...

            // Обновление UI через callback
            updateUI("Новое значение для UI")

            g++
            Thread.sleep(2000) // Подождите 2 секунды перед следующим запросом
        }
        return Result.success()
    }

    override fun updateUI(data: String) {
        // Обновление UI, например, через LiveData, который прослушивается в вашей активности
        // или каким-либо другим способом, который вы используете для обновления UI.
    }
}

В вашей активности (Activity), создайте экземпляр WorkManager и запустите задачу MyWorker:

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager

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

        // Создайте запрос на выполнение MyWorker
        val workRequest = OneTimeWorkRequest.Builder(MyWorker::class.java).build()

        // Запустите задачу с использованием WorkManager
        WorkManager.getInstance(this).enqueue(workRequest)
    }
}

Теперь, при запуске вашей активности, MyWorker будет выполнять запросы в фоновом режиме и обновлять UI через MyCallback.
Убедитесь, что ваша активность реализует интерфейс MyCallback и правильно обновляет UI в методе updateUI.

[kitcat2004]

uzolenta, В вашем коде myCallback?.updateUI("TEST DATA") в ForegroundService и gEditText.text = data в FirstActivity могут вызвать проблемы с инициализацией.

Для решения этой проблемы, вам следует убедиться, что myCallback и gEditText инициализируются правильно. Вот как это можно сделать:

В классе ForegroundService, вы должны убедиться, что myCallback инициализируется перед использованием. То есть, убедитесь, что у вас есть ссылка на активность, которая реализует MyCallback.
При этом, необходимо удостовериться, что активность действительно существует:

class ForegroundService : Service() {
    private var myCallback: MyCallback? = null

    // Метод для установки объекта MyCallback
    fun setCallback(callback: MyCallback) {
        myCallback = callback
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // ...

        if (myCallback != null) {
            myCallback?.updateUI("TEST DATA")
        }

        // ...
    }
}

В вашей активности FirstActivity, убедитесь, что gEditText инициализируется корректно.
Обычно, инициализация UI элементов происходит в методе onCreate.
Если у вас используется View Binding, то удостоверьтесь, что вы правильно связали элементы UI с вашей активностью:

class FirstActivity : AppCompatActivity(), MyCallback {
    private lateinit var gEditText: EditText

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

        // Инициализация gEditText
        gEditText = findViewById(R.id.your_edit_text_id)

        // ...
    }

    override fun updateUI(data: String) {
        gEditText.text = data
    }
}

Это должно решить проблему с инициализацией myCallback и gEditText
и обеспечить корректную передачу данных и обновление UI.

Прежде чем реализовать, попробуйте понять, что и как решается.
Действительно на стороне Google многое меняется за последнее время.

[kitcat2004]

Вот полный код для вашей ситуации на основе предыдущего Вашего ответа,
с учетом обновлений UI из фонового сервиса:

Создайте MyWorker для выполнения фоновых задач:

import android.content.Context
import androidx.work.Worker
import androidx.work.WorkerParameters

class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params), MyCallback {
    override fun doWork(): Result {
        var g = 0
        while (g < 10) {
            // Выполняйте запрос и обновляйте UI здесь
            // ...

            // Обновление UI через callback
            updateUI("Новое значение для UI")

            g++
            Thread.sleep(2000) // Подождите 2 секунды перед следующим запросом
        }
        return Result.success()
    }

    override fun updateUI(data: String) {
        // Обновление UI, например, через LiveData, который прослушивается в вашей активности
        // или каким-либо другим способом, который вы используете для обновления UI.
    }
}

В вашей активности FirstActivity, убедитесь, что gEditText инициализируется правильно
и у вас есть связь с MyWorker:

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager

class FirstActivity : AppCompatActivity(), MyCallback {
    private lateinit var gEditText: EditText

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

        // Инициализация gEditText
        gEditText = findViewById(R.id.your_edit_text_id)

        // Создайте запрос на выполнение MyWorker
        val workRequest = OneTimeWorkRequest.Builder(MyWorker::class.java).build()

        // Запустите задачу с использованием WorkManager
        WorkManager.getInstance(this).enqueue(workRequest)
    }

    override fun updateUI(data: String) {
        runOnUiThread {
            gEditText.text = data
        }
    }
}

В вашем фоновом сервисе ForegroundService,
убедитесь, что myCallback инициализируется перед использованием:

class ForegroundService : Service() {
    private var myCallback: MyCallback? = null

    // Метод для установки объекта MyCallback
    fun setCallback(callback: MyCallback) {
        myCallback = callback
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // ...

        if (myCallback != null) {
            myCallback?.updateUI("TEST DATA")
        }

        // ...
    }
}

Убедитесь, что вы корректно связываете активность FirstActivity с MyWorker и ForegroundService, как это было описано в предыдущем ответе.

Чтобы ваш фоновый сервис (Foreground Service) продолжал выполняться,
даже если приложение было свернуто, вам необходимо запустить сервис в режиме,
который не зависит от жизненного цикла активности приложения.

Вы можете использовать startForegroundService для запуска сервиса,
который будет работать в фоновом режиме.

Ваш код создает ForegroundService и запускает его, но для того чтобы сервис работал, даже когда приложение свернуто, необходимо внести следующие изменения:

В ForegroundService, в методе onStartCommand,
добавьте startForeground с уведомлением, чтобы убедиться, что сервис работает в фоновом режиме:

import android.app.Notification
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.os.IBinder
import androidx.core.app.NotificationCompat

class ForegroundService : Service() {

    // ...

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // ...

        // Создание уведомления для сервиса
        val notification = createNotification(input)

        // Запуск сервиса в режиме Foreground
        startForeground(1, notification)

        return START_NOT_STICKY
    }

    // ...

    // Метод для создания уведомления
    private fun createNotification(input: String?): Notification {
        val notificationIntent = Intent(this, FirstActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0,
            notificationIntent,
            PendingIntent.FLAG_IMMUTABLE
        )

        return NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service Kotlin Example")
            .setContentText(input)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentIntent(pendingIntent)
            .build()
    }
}

В вашем FirstActivity, убедитесь, что у вас нет логики, которая останавливает сервис при сворачивании приложения.
То есть, не вызывайте stopService в onPause или подобных методах активности.

С этими изменениями ваш фоновый сервис будет продолжать работать, даже если приложение свернуто. Убедитесь также, что у вас правильно настроена работа с уведомлениями и разрешениями на фоновую работу,, если это необходимо.

Предоставил возможные варианты, исключите в представленных вариантах излишние комментарии, код,
который возможно повторяется. Ваши знания Kotlin помогут Вам проверить значения переменных,
и скомпоновать несколько вариантов решения задачи облегчив решение сути вопроса.

Некоторый код также я опустил, просто закомментировав, проверьте, что ничего не упустили.
Также посмотрите Ваши разрешения Manifest (включая Gradle, Kotlin, Google) просмотрите все активности и разрешения, чтобы исключить серивисы влияющие на разрешения работы в фоне..

Если задача так и не решится, попробуйте предоставить не тестовый код, а боевой из проекта (именно тот кусок, который отвечает за логику фоновой обработки процесса), я попробую исправить код, предоставив вариант решения. Возможно, при энприментации кода из боевого в тестовый и обратно Вы допускаете ошибку логики или простановки знаков. Проверьте Ваш код через BagTracker в AndroidStudio, в Run & Bug

[kitcat2004]

uzolenta,

разобрал Ваш код в предоставленном Вами последнем ответе.

Вы столкнулись с проблемой, так как пытаетесь обновить gEditText из сервиса, который не имеет доступа к UI-компонентам напрямую..
Для обновления UI из сервиса, вам следует использовать механизм обратных вызовов, как было описано в предыдущих ответах. Однако, в вашем коде есть несколько проблем:

Метод setCallback в ForegroundService является закрытым и не может быть использован вне класса. Вы должны использовать публичный метод для установки myCallback.

В методе setCallback, обновление UI происходит сразу после установки myCallback, что не гарантирует корректной инициализации gEditText и может вызвать NullPointerException.

Вы не передаете myCallback из вашей активности FirstActivity в ForegroundService.

В ForegroundService, измените метод setCallback, сделайте его публичным и уберите обновление UI из него:

class ForegroundService : Service() {

    private var myCallback: MyCallback? = null

    // Метод для установки объекта MyCallback
    fun setCallback(callback: MyCallback) {
        myCallback = callback
    }
}

В FirstActivity, убедитесь, что gEditText инициализируется корректно в onCreate,
и установите MyCallback для ForegroundService:

class FirstActivity : AppCompatActivity(), MyCallback {
    private lateinit var gEditText: EditText

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

        // Инициализация gEditText
        gEditText = findViewById(R.id.your_edit_text_id)

        // Создайте запрос на выполнение MyWorker
        val workRequest = OneTimeWorkRequest.Builder(MyWorker::class.java).build()

        // Устанавливаем MyCallback для ForegroundService
        val serviceIntent = Intent(this, ForegroundService::class.java)
        bindService(serviceIntent, serviceConnection, Context.BIND_AUTO_CREATE)

        WorkManager.getInstance(this).enqueue(workRequest)
    }

    override fun updateUI(data: String) {
        runOnUiThread {
            gEditText.text = data
        }
    }

    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            val binder = service as ForegroundService.MyBinder
            val service = binder.getService()
            service.setCallback(this@FirstActivity)
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            // Handle disconnection, if needed
        }
    }
}

С этими изменениями, ваш фоновый сервис должен обновлять UI в gEditText без проблем.
И всё таки попробуйте все представленные мной ответы, попробуйте разобраться в них,
используйте разные реализации - не получится одна, исправит другая.

Пробуйте разные решения, спрашивайте, задайте дополнительно вопрос на StakOverFlow в русской и английской локализациях проекта, возможно, продвинутые кодеры знают готовый ответ.
Не бойтесь предоставить кодеру публично код из проекта, а не тестовые переменные для публичного пользования - это поможет в быстрой реализации решения.
Ваши собственные знания Kotlin и JS помогут в перекомпановке кода, проверке, правильной интерпретации и написании дополнительного кода. Пользуйтесь Debug в студио, чтобы проверить методы.

[kitcat2004]

ВЫ ИЗНАЧАЛЬНО ПРЕДОСТАВИЛИ КОД, который вполне рабочий,
однако в нем имеются незначительные ошибки логики, попробуйте их исправить!

Код представлен в Вашем вопросе.

Ниже, я опишу проблемы и пути решения, которые смогут помочь, возможно.

Разрешения:
Если ваше приложение выполняет сетевые запросы, вам необходимо запросить разрешение на доступ к интернету в файле манифеста (AndroidManifest.xml). Добавьте следующую строку:

<uses-permission android:name="android.permission.INTERNET" />

Поток интерфейса пользователя:
Ваш код выполняет запросы в цикле и обновляет интерфейс пользователя после каждого запроса.
Это может привести к блокировке пользовательского интерфейса.
Вместо этого, рекомендуется использовать библиотеки для выполнения асинхронных задач,
такие как Kotlin Coroutines или Android's AsyncTask,
чтобы выполнять сетевые запросы в фоновом потоке и обновлять интерфейс после получения ответа.

Управление памятью:
В вашем коде отсутствует управление памятью,
что может привести к утечкам памяти.
Вы должны закрывать тело ответа после использования с response.body?.close(),
чтобы освободить ресурсы.

Исключения:
Вам необходимо обрабатывать исключения при выполнении сетевых запросов,
чтобы избежать крашей приложения.
В вашем коде есть обработка ошибок onFailure,
но также стоит рассмотреть обработку других исключений, которые могут возникнуть.

Использование OkHttp:
В вашем коде вы используете OkHttp для выполнения запросов, что вполне правильно.
Однако, если у вас есть несколько запросов, которые могут выполняться параллельно,
рассмотрите возможность использования Kotlin Coroutines с OkHttp,
чтобы упростить асинхронное программирование.

Обработка ошибок:
Добавьте обработку ошибок в вашем коде для более информативных сообщений об ошибках и логгирования.

Это вроде бы все значительно влияющие факторы.
Представил ниже пример улучшения кода, предоставленного изначально.

Вот пример, как можно улучшить ваш код с учетом вышеперечисленных моментов:

import android.os.Bundle
import android.os.Handler
import android.os.Looper
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import okhttp3.*
import java.io.IOException

class FirstActivity : AppCompatActivity() {
    private val client = OkHttpClient()
    private val handler = Handler(Looper.getMainLooper())

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_first)
        HOPO()
    }

    fun HOPO() {
        runBlocking {
            val job = launch(Dispatchers.IO) {
                for (g in 0 until 10) {
                    val api = "https://test.ru/g=$g"
                    val request = Request.Builder()
                        .url(api)
                        .post(postBody.toRequestBody(MEDIA_TYPE_MARKDOWN))
                        .header("X-Get-Processing-Time", "1")
                        .removeHeader("User-Agent")
                        .addHeader("User-Agent", UserAgent)
                        .build()

                    try {
                        val response: Response = client.newCall(request).execute()
                        if (response.isSuccessful) {
                            val responseData = response.body?.string()
                            handler.post {
                                gEditText.text = "$g"
                            }
                        }
                        response.body?.close()
                    } catch (e: IOException) {
                        e.printStackTrace()
                    }
                }
            }
            job.join()
        }
    }
}

Пожалуйста, учтите, что это только пример,
и вы можете доработать его в соответствии с вашими требованиями и логикой приложения.

На данный номент это улучшение является лучшим решением задачи без дополнительных проверок и внедрений, на основе изначально предоставленного в вопросе кода.
Попробуйте для начала его, потом уже все остальные ответы, начиная с последнего Вашего ответа,
которые я предоставил. Там различные реализации и пути решения.

Описанное в этом ответе улучшение, гарантированно работает на Android 12, Android 13.
Смело можно проверить, и если не будет работать идти более сложными путями.

[uzolenta]

kitcat2004, val binder = service as ForegroundService.MyBinder

Ошибка в MyBinder - что это?)

[kitcat2004]

uzolenta, Ошибка "Unresolved reference: service" обычно возникает, когда вы пытаетесь использовать service в контексте, где он не определен.
В вашем коде, это может быть связано с тем, что вы пытаетесь привести service к типу ForegroundService.MyBinder, но переменная service не объявлена или не инициализирована.

Чтобы правильно использовать service, вам нужно убедиться, что она объявлена и инициализирована.
В контексте Android, это обычно используется в методе onServiceConnected()
при работе с ServiceConnection и связыванием с фоновым сервисом.

Вот пример использования:

private val serviceConnection = object : ServiceConnection {
    override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
        val service = (binder as ForegroundService.MyBinder).getService()
        // Теперь у вас есть доступ к сервису и можете выполнять методы, предоставленные сервисом.
    }

    override fun onServiceDisconnected(name: ComponentName?) {
        // Обработка отсоединения сервиса, если это необходимо.
    }
}

становится доступной после успешного связывания с фоновым сервисом через onServiceConnected().
Убедитесь, что вы используете правильное имя сервиса и тип биндера

[uzolenta]

kitcat2004, обновил вопрос, прошу посмотреть :)

Answer 1

[rPman]

тебе нужно создать фоновый сервис https://developer.android.com/training/run-backgro...
Мои скилы устарели, плюс гугл похоже сильно последние пару лет перелопачивает способ разработки приложений для android и что лучше использовать и будут ли какие либо ограничения судить сложно, информация из гугла очень противоричивая

Есть WorkManager, он более background, но его работа может быть остановлена по каким то причинам (работа выполнится но без гарантий оперативности, что бы это не значило) это больше планировщик задач а функция которая работает в фоне.

С точки зрения длительной загрузки файла мне кажется WorkManager подходит лучше чем Service

Comments

[uzolenta]

А для такой задачи не лучше WorkManager?
Мб где-нибудь встречали пример похожий на мой - отправка запроса в цикле в фоне?
А то я честно не могу раздуплиться, хотя фоновый сервис уже был написан до этого, я пытался разобраться.
Спасибо.

[rPman]

причем тут отправка запроса, с этим у тебя проблем нет

проблема в том что android замораживает все приложения в фоне, если они не служба

и правильно делает, батарейка не резиновая

[uzolenta]

rPman, я это понимаю. Я не понимаю как связать сервис и мой код.
Вот взял код с сайта, ошибок не выдаёт, но что с ним делать дальше? Реально как связать одно с другим не понимаю.

class ForegroundService2 : Service() {



    override fun onCreate() {
        super.onCreate()
    }

    @RequiresApi(Build.VERSION_CODES.O)
    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        val input = intent.getStringExtra("inputExtra")
        createNotificationChannel()
        val notificationIntent = Intent(this, MainActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
        )
        val notification: Notification = Notification.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service")
            .setContentText(input)
            .setSmallIcon(R.drawable.alert_light_frame)
            .setContentIntent(pendingIntent)
            .build()
        startForeground(1, notification)
        //do heavy work on a background thread
        //stopSelf();
        return START_NOT_STICKY
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    @Nullable
    override fun onBind(intent: Intent): IBinder? {
        return null
    }

    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val serviceChannel = NotificationChannel(
                Companion.CHANNEL_ID,
                "Foreground Service Channel",
                NotificationManager.IMPORTANCE_DEFAULT
            )
            val manager = getSystemService(
                NotificationManager::class.java
            )
            manager.createNotificationChannel(serviceChannel)
        }
    }

    companion object {
        const val CHANNEL_ID = "ForegroundServiceChannel"
    }
}

[uzolenta]

Либо такой ещё есть

class ForegroundService : Service() {
    private val CHANNEL_ID = "1"
    companion object {
        fun startService(context: Context, message: String) {
            val startIntent = Intent(context, ForegroundService::class.java)
            startIntent.putExtra("inputExtra", message)
            ContextCompat.startForegroundService(context, startIntent)
        }
        fun stopService(context: Context) {
            val stopIntent = Intent(context, ForegroundService::class.java)
            context.stopService(stopIntent)
        }
    }
    @RequiresApi(Build.VERSION_CODES.O)
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        //do heavy work on a background thread
        val input = intent?.getStringExtra("inputExtra")
        createNotificationChannel()
        val notificationIntent = Intent(this, PostingVKActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
        )
            /*
        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service Kotlin Example")
            .setContentText(input)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentIntent(pendingIntent)
            .build()


        startForeground(1, notification)
        */

        //stopSelf();
        return START_NOT_STICKY
    }
    override fun onBind(intent: Intent): IBinder? {
        return null
    }
    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
      //  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val serviceChannel = NotificationChannel(CHANNEL_ID, "1",
                NotificationManager.IMPORTANCE_DEFAULT)
            val manager = getSystemService(NotificationManager::class.java)
            manager!!.createNotificationChannel(serviceChannel)
       // }
    }
}

[rPman]

ну вот это стартанет твой сервис
https://developer.android.com/reference/android/co...

и вообще начни гуглить

[uzolenta]

rPman, а не похоже, что я не только гуглю? Варианты же кидаю, какие пробую.

В цикле вызываю из второго варианта сервис:
ForegroundService.startService(this, "СТАРТ ")
Но ничего не происходит, хотя там есть

val notification = NotificationCompat.Builder(this, CHANNEL_ID)

[rPman]

ты пытаешься запустить сервис из самого сервиса, а надо из своего приложения, ну грубо говоря по кнопке?

такое ощущение что ты пытаешься копировать случайный код из инетрнета и недоумеваешь, почему он не работает.

примерно то же самое пытается делать chatgpt ж)

[uzolenta]

Есть файл ForegroundService с кодом:

class ForegroundService : Service() {
    private val CHANNEL_ID = "1"
    companion object {
        fun startService(context: Context, message: String) {
            val startIntent = Intent(context, ForegroundService::class.java)
            startIntent.putExtra("inputExtra", message)
            ContextCompat.startForegroundService(context, startIntent)
        }
        fun stopService(context: Context) {
            val stopIntent = Intent(context, ForegroundService::class.java)
            context.stopService(stopIntent)
        }
    }
    @RequiresApi(Build.VERSION_CODES.O)
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        //do heavy work on a background thread
        val input = intent?.getStringExtra("inputExtra")
        createNotificationChannel()
        val notificationIntent = Intent(this, PostingVKActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
        )

        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service Kotlin Example")
            .setContentText(input)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentIntent(pendingIntent)
            .build()


        startForeground(1, notification)


        //stopSelf();
        return START_NOT_STICKY
    }
    override fun onBind(intent: Intent): IBinder? {
        return null
    }
    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
      //  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val serviceChannel = NotificationChannel(CHANNEL_ID, "1",
                NotificationManager.IMPORTANCE_DEFAULT)
            val manager = getSystemService(NotificationManager::class.java)
            manager!!.createNotificationChannel(serviceChannel)
       // }
    }
}

Есть функция, которой надо работать в фоновом режиме:

fun HOPO(){

g = 0

while(g < 10){
api = "https://test.ru/g=$g"
val request = Request.Builder()
            .url(api)
            .post(postBody.toRequestBody(MEDIA_TYPE_MARKDOWN))
            .header("X-Get-Processing-Time", "1")
            .removeHeader("User-Agent")
            .addHeader("User-Agent", UserAgent)
            .build()

        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                e.printStackTrace()
            }
       override fun onResponse(call: Call, response: Response) {
 runOnUiThread {
                            gEditText.text = "$g"
}
      }
})

g++
}//END WHILE
}//END FUN

в Активити через кнопку запускать?

val intentActivity = Intent(this, Activity::class.java)
            startService(intentActivity)

            HOPO()

[rPman]

ну да, ну елки палки первый же пример из гугла
https://www.concretepage.com/android/android-start...

Intent intent = new Intent(this, MyService.class);
    intent.putExtra("param", text);
    startService(intent);

[uzolenta]

rPman, гугл и примеры там - это хорошо. Я же сюда не просто так зашёл, а на конкретно моём примере разобраться. Если зашёл, значит, сам до конца не могу допереть, как правильно использовать. Что Вы всё в гугл отправляете.

[rPman]

uzolenta, я понимаю что документация написана не очень удобно, но реалии таковы что эту документацию нужно воспринимать исключительно в контексте примеров из интернета (очень маленький процент разработчиков разбирается в android так хорошо что ему не требуется ничего кроме документации и исходников android).

Но да был резок, извиняюсь, это клише - отправлять вопрошающих в гугл.

Кстати сейчас имеет смысл отправлять chatgpt со встроенным поисковиком или bing chat, в беседе с ним можно очень неплохо решать свои проблемы но постоянно помнить что если он чего то не находит или не до конца понимает он очень правдоподобно выдумывает, так что все нужно перепроверять

особенно полезно брать кусок кода, скармливать ему с вопросом, что делает тут 'эта' строчка

[uzolenta]

rPman, да я уже и лекции просмотрел и так далее, бывает такое, что просто не врубаешься, либо просто что-то не так где-то, а понять не могу.

Выше свой год запускаю, как написал, ошибок нету, но и уведомление сам сервис не присылает, хотя там в коде есть. Т.е никаких признаков жизни от него, приложение что без него работало, что с ним.

Сейчас ещё вопрос для понимания:

Intent intent = new Intent(this, MyService.class);

this - это, логично, активити откуда я запускаю. И какую я тут укажу, ту не даст закрыть Сервис Андроиду - это так работает?

[rPman]

uzolenta, я дико извиняюсь, так как мои скилы по android уже устарели, а гуглинг вносит путаницу

А для такой задачи не лучше WorkManager?

сейчас рекомендуют пользоваться именно этим, а как я понял сервисы себя дискредитировали и уже не надежны в плане фоновой работы

пусть профи отвечают https://habr.com/ru/companies/cleverpumpkin/articl...

[kitcat2004]

uzolenta, Передача контекста может быть сделана следующим образом:

fun HOPO(context: Context) {
    // Ваш код функции HOPO
    // ...
}

В вашей активити, когда пользователь нажимает на кнопку, запустите ForegroundService с помощью startService, а затем вызовите функцию HOPO:

val intentService = Intent(this, ForegroundService::class.java)
intentService.putExtra("inputExtra", "Your message")
ForegroundService.startService(this, "Your message")
HOPO(this)

Обратите внимание, что в вашем сервисе ForegroundService,
вы извлекаете значение "inputExtra" из Intent.
Убедиться, что ваша функция HOPO принимает контекст (Context) в качестве параметра,
чтобы можно было запустить сервис и извлечь параметры из Intent.

Это позволит вам запустить ваш сервис в фоновом режиме, а затем выполнить функцию HOPO.

[kitcat2004]

Пробуем сделать копию, удалить из проекта,
и вывести вот это всё в проект. Если есть что-то еще, добавьте в эту версию убедившись,
что не навредит сервису.

Возможно поможет. Если нет, либо экспериментируйте и гуглите, а лучше читайте документацию SDK,
или вернитесь к уже написанному Вами варианту.

Ваш ForegroundService:

import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.os.Build
import android.os.IBinder
import androidx.annotation.RequiresApi
import androidx.core.app.NotificationCompat
import android.app.Notification
import android.content.Context
import android.os.Handler
import android.os.Looper
import okhttp3.*
import java.io.IOException

class ForegroundService : Service() {
    private val CHANNEL_ID = "1"
    private val client = OkHttpClient()
    private val handler = Handler(Looper.getMainLooper())

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val input = intent?.getStringExtra("inputExtra")
        createNotificationChannel()
        val notificationIntent = Intent(this, PostingVKActivity::class.java)
        val pendingIntent = PendingIntent.getActivity(
            this,
            0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
        )

        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service Kotlin Example")
            .setContentText(input)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentIntent(pendingIntent)
            .build()

        startForeground(1, notification)

        // Вызываем функцию HOPO
        HOPO(this)

        return START_NOT_STICKY
    }

    override fun onBind(intent: Intent): IBinder? {
        return null
    }

    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
        val serviceChannel = NotificationChannel(CHANNEL_ID, "1", NotificationManager.IMPORTANCE_DEFAULT)
        val manager = getSystemService(NotificationManager::class.java)
        manager!!.createNotificationChannel(serviceChannel)
    }

    companion object {
        fun startService(context: Context, message: String) {
            val startIntent = Intent(context, ForegroundService::class.java)
            startIntent.putExtra("inputExtra", message)
            context.startService(startIntent)
        }
    }
}

Ваша функция HOPO:

fun HOPO(context: Context) {
    var g = 0

    while (g < 10) {
        val api = "https://test.ru/g=$g"
        val request = Request.Builder()
            .url(api)
            .post(postBody.toRequestBody(MEDIA_TYPE_MARKDOWN))
            .header("X-Get-Processing-Time", "1")
            .removeHeader("User-Agent")
            .addHeader("User-Agent", UserAgent)
            .build()

        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                e.printStackTrace()
            }

            override fun onResponse(call: Call, response: Response) {
                handler.post {
                    gEditText.text = "$g"
                }
            }
        })

        g++
    }
}

Код в вашей активности для запуска службы и функции HOPO:

val intentService = Intent(this, ForegroundService::class.java)
intentService.putExtra("inputExtra", "Your message")
ForegroundService.startService(this, "Your message")

ManifestActivity.XML

<service
    android:name=".ForegroundService"
    android:enabled="true"
    android:exported="false" />

Такой код должен запустить службу ForegroundService и выполнить функцию HOPO в фоновом режиме.

[kitcat2004]

Если ничего не помогло, или вы сочли,
что использование служб может быть несостоятельным в данной ситуации,
можете рассмотреть альтернативные способы выполнения задачи фоновой обработки,
например, с использованием фоновых потоков, WorkManager или Kotlin Coroutines.

Фоновые потоки (Background Threads):

создать отдельный фоновый поток, например, с использованием Thread или Executor,
и выполнять вашу функцию HOPO внутри этого потока.
Это позволит вам выполнить работу в фоновом режиме без использования служб.

Пример использования Thread:

Thread {
    HOPO(this)
}.start()

WorkManager - это библиотека Android Jetpack,
она позволяет выполнить задачи в фоновом режиме с учетом различных факторов,
таких как состояние батареи, сетевое подключение и даже уровень заряда устройства.
Она хорошо подходит, но ТОЛЬКО для периодических и отложенных задач.

Kotlin Coroutines:
Если вы предпочитаете асинхронное программирование, вы можете использовать Kotlin Coroutines
для выполнения функции HOPO в фоновом режиме.
Coroutines предоставляют простой способ работы с ассинхронкой.

Пример Kotlin Coroutines:

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

// Вызов функции HOPO в фоновом режиме
launch(Dispatchers.IO) {
    HOPO(this@YourActivity)
}

Помните также об ограничениях на выполнение фоновой работы в Android,
таких как ограничения батареи и сетевые ограничения.

[kitcat2004]

uzolenta,

Еще проверьте правильность своего кода:

MyCallback - Ваш код ссылается на MyCallback, но его определение отсутствует. Вы должны импортировать или определить этот интерфейс.

В методе setCallback вы используете myCallback!!, что означает, что вы уверены, что myCallback не равен null. Если это не всегда гарантировано, лучше использовать безопасный вызов ?..

input - Вы получаете input из intent?.getStringExtra("inputExtra"), но не проверяете, что input не равен null. Было бы хорошо добавить проверку на null и, возможно, установить значение по умолчанию, если input равен null.

PostingVKActivity и ForegroundService - В коде создается новый экземпляр PostingVKActivity и ForegroundService, что, возможно, не то, что вам требуется. Вы можете работать с уже существующими экземплярами классов, а не создавать новые.

NotificationCompat.Builder - Здесь используется метод setSmallIcon, который ожидает идентификатор ресурса. Убедитесь, что у вас есть соответствующий ресурс R.mipmap.ic_launcher.

В методе onStartCommand, когда устанавливается startForeground, вы указываете 2 в качестве первого аргумента. Это идентификатор уровня уведомлений, и вам может потребоваться уникальное значение, чтобы отличать разные службы.

В методе createNotificationChannel, вы устанавливаете имя канала "2", это, возможно, не самое информативное имя для канала уведомлений.

код требует проверки на наличие null и уточнения деталей о MyCallback.

Это всё о первом коде в вопросе.

По второй части:

Второй код правильный, однако есть значимая опечатка, которая мешает компиляции кода

button = binding.Button
константа button указана с большой буквы, а надо с маленькой ОБЯЗАТЕЛЬНО

Answer 2

[kitcat2004]

Проверьте следующее:

updateUI активируется после gEditText и что gEditText не переинициализируется позже в коде.
Это важно, потому что lateinit свойства должны быть инициализированы до их использования.

Проверьте по коду FirstActivity не должна повторяться, возможно gEditText обращается к ней в нескольких местах, вызывая переинициализацию, таким образом код ходит по циклу снова и снова, вызывая из другого экземпляра .

Проверьте, что FirstActivity не пересоздается в процессе работы. Если это именно так, то создаст проблемы с инициализацией gEditText.

Код вызова updateUI должен быть в том же потоке, в котором и был создан FirstActivity.
обновление UI из другого потока может вызвать подобную ошибку.

===========================================ПРОШЛЫЙ ОТВЕТ ===========================================

вы пытаетесь обратиться к переменной gEditText, которая не была инициализирована.

Сейчас она инициализируется так:

gEditText = binding.gEditText

Убедитесь, что binding.gEditText был успешно инициализирован в вашем Activity.
Это обычно происходит в методе onCreate.

(binding) и gEditText должны быть внутри представления

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ActivityFirstBinding.inflate(layoutInflater)
    setContentView(binding.root)

    gEditText = binding.gEditText

    // Остальной код вашей Activity
}

ПРОВЕРЬТЕ ЭТО!

Если binding.gEditText не был успешно инициализирован, проверяем,
что есть правильное представление и gEditText
имеет правильный идентификатор в макете (ActivityFirstBinding).

====================СТАРОЕ ================

Используйте основной поток, вместо фона.
Ошибка вызвана природой ассинхронки сервиса

Чтобы обновить пользовательский интерфейс из фонового потока, вы должны использовать методы, предоставленные Android для выполнения операций в основном потоке.

Используйте функцию runOnUiThread для обновления gEditText в основном потоке.
Вот как можно изменить вашу функцию updateUI:

override fun updateUI(data: String) {
    // Здесь вы обновляете ваш интерфейс, например, ваш TextView
    println("data updateUI: $data")

    runOnUiThread {
        // Обновление интерфейса в основном потоке
        gEditText.text = "8888"
    }
}

Это обернет обновление gEditText.text в блок, который будет выполнен в основном потоке,
и избежит ошибок, связанных с обновлением интерфейса из фонового потока.

Comments

[uzolenta]

Это я тоже пробовал :) Выдаёт:

kotlin.UninitializedPropertyAccessException: lateinit property gEditText has not been initialized

У меня так-то сложная активити с обновлениями интерфейса и так далее - всё работает. А вот описанное в новой версии вопроса - нет

[uzolenta]

так при нажатии на Button - всё работает (gEditText.text присваивается значение)и ошибок не выдаёт.

Сейчас она инициализируется так:

gEditText = binding.gEditText

Убедитесь, что binding.gEditText был успешно инициализирован в вашем Activity.
Это обычно происходит в методе onCreate.

(binding) и gEditText должны быть внутри представления

Я не покидаю активити, когда обращаюсь к Service.

Поэтому для меня и загадка, откуда такая ошибка.

[uzolenta]

Я скинул весь код, просто убрал лишние кнопки и функции.
Ничего лишнего не запускается и так далее.
Действие оставил только на нажатие Button

updateUI активируется после gEditText и что gEditText не переинициализируется позже в коде.
Это важно, потому что lateinit свойства должны быть инициализированы до их использования.

Проверьте по коду FirstActivity не должна повторяться, возможно gEditText обращается к ней в нескольких местах, вызывая переинициализацию, таким образом код ходит по циклу снова и снова, вызывая из другого экземпляра .

Проверьте, что FirstActivity не пересоздается в процессе работы. Если это именно так, то создаст проблемы с инициализацией gEditText.

Код вызова updateUI должен быть в том же потоке, в котором и был создан FirstActivity.
обновление UI из другого потока может вызвать подобную ошибку.

[uzolenta]

А не может ли проблема заключаться в этом? Из файла ForegroundService

val firstActivity = PostingVKActivity()
        val activity = ForegroundService()
        activity.setCallback(firstActivity, "9999")