Евгений s's questions

Quero executar PeriodicWork com injeções de dependência Dagger Hilt. No entanto, isso não funciona periodicamente. Eu verifiquei meu código muitas vezes. Há no máximo apenas uma mensagem de conclusão bem-sucedida do trabalho, embora eu espere receber uma mensagem a cada segundo.

Aqui está o código para MainActivity:

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            RunARepeatableWorkUsingWorkManagerTheme {

            val lifecycleOwner = LocalLifecycleOwner.current

            LaunchedEffect(key1 = Unit ){

                val workRequest = PeriodicWorkRequestBuilder<CustomWorker>(
                    repeatInterval = 1,
                    repeatIntervalTimeUnit = TimeUnit.SECONDS,)
                    .setBackoffCriteria(
                        backoffPolicy = BackoffPolicy.LINEAR,
                        duration = Duration.ofSeconds(5))
                    .build()

                    val workManager = WorkManager.getInstance(applicationContext)
                    workManager.enqueueUniquePeriodicWork("myWork", ExistingPeriodicWorkPolicy.KEEP, workRequest)

                     workManager.getWorkInfosForUniqueWorkLiveData("myWork")
                    .observe(lifecycleOwner){ it ->
                        it.forEach {workInfo ->
                        Log.d("MyWorker: MainActivity", "${workInfo.state}")
                    }
                }
            }
            }
        }
    }
}   

Meu trabalhador fica assim:

@HiltWorker
class CustomWorker @AssistedInject constructor(
    @Assisted context: Context,
    @Assisted workerParameters: WorkerParameters
) : CoroutineWorker(context, workerParameters){
        override suspend fun doWork(): Result {
            try {
                println("MyWorker : The result or the worker is Success")
                return Result.success()
            } catch (e: Exception) {
                Log.e("MyWorker: CustomWorker", "Worker failed: ${e.message}", e)
                return Result.failure()
            }
        }
}

HiltAndroidAppIs:

@HiltAndroidApp
class AppInstance : Application(), Configuration.Provider{
    @Inject lateinit var workerFactory: HiltWorkerFactory

    override fun getWorkManagerConfiguration() =
        Configuration.Builder()
            .setWorkerFactory(workerFactory)
            .build()

}

Também no arquivo de manifesto adicionei:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge"
    >
    <meta-data
        android:name="androidx.work.impl.WorkManagerInitializer"
        android:value="androidx.startup"
        tools:node="remove" />
</provider>

O Logcat mostra apenas:

 2023-09-24 18:16:46.712  4819-4819  MyWorker: MainActivity  com...epeatableworkusingworkmanager  D  ENQUEUED
2023-09-24 18:17:47.375  4819-4854  System.out              com...epeatableworkusingworkmanager  I  MyWorker : The result or the worker is Success
2023-09-24 18:17:47.429  4819-4819  MyWorker: MainActivity  com...epeatableworkusingworkmanager  D  RUNNING
2023-09-24 18:17:47.437  4819-4819  MyWorker: MainActivity  com...epeatableworkusingworkmanager  D  ENQUEUED

E isso é tudo. A questão é: por que não vejo uma mensagem do trabalho sendo realizado a cada segundo? Eu apreciaria qualquer ajuda!

Quando faço download de informações de um banco de dados, a função de coleta não interrompe a emissão (a função de coleta do Kotlin não termina sozinha).

Eu tenho esta classe de entidade:

@Entity
data class ShareEntity(
    @PrimaryKey(autoGenerate = false)
    val secId: String,
    val shortName: String,
    val fullName: String = "",
    val isFavorite: Boolean
)

A função para obter todos os compartilhamentos específicos de “isFavorite” no Dao é assim:

@Dao
interface DataBaseDao {
………..
@Query("SELECT * FROM ShareEntity WHERE isFavorite =:isFavorite")
fun getAllSharesByIsFavorite(isFavorite: Boolean): Flow<List<ShareEntity>>
}

No DataBaseDao existem muitas outras funções que inserem alguns dados na entidade ShareEntity.

Para trabalhar com a interface Dao foi feito o DataBaseRepository e sua implementação DataBaseRepositoryIm:

interface DataBaseRepository {
………..
fun getAllSharesByIsFavorite(isFavorite: Boolean): Flow<List<ShareEntity>>
}

class DataBaseRepositoryIm(
private val dataBaseDao: DataBaseDao
) : DataBaseRepository{
………..
override fun getAllSharesByIsFavorite(isFavorite: Boolean): Flow<List<ShareEntity>> {
 return dataBaseDao.getAllSharesByIsFavorite(isFavorite)
}
}

No meu NewsScreenViewModel1 tenho uma função que carrega todos os compartilhamentos por “isFavorite”

@HiltViewModel
class NewsScreenViewModel1 @Inject constructor(
    private val dataBaseRepository: DataBaseRepository,
    private val repository: ApiRepository,
) : ViewModel(){

suspend fun downloadListOfSharesByIsFavorite(isFavorite: Boolean = true){
 val shares = dataBaseRepository.getAllSharesByIsFavorite(isFavorite).collect{ it:List<ShareEntity> ->
 println("NewsScreenVM1: allShares is with isFavorite = $isFavorite are $it")
 println("NewsScreenVM1: the size of shares is ${it.size}")
 }
 println("NewsScreenVM1: Now we are outside of the collect function")
}
}

No NewsScreen combinável eu inicio a função com LauncheEffect:

@Composable
fun NewsScreen(
    NewsScreenViewModel1: NewsScreenViewModel1 = hiltViewModel()
) {
    LaunchedEffect(key1 = Unit) {
        NewsScreenViewModel1.downloadListOfSharesByIsFavorite()
    }

}

O problema é que a função collect não termina sozinha ou, em outras palavras, não para. No LogCat vejo:

“NewsScreenVM1: allShares está com isFavorite = true são [ShareEntity(secId=ALRS, shortName=АЛРОСА ао, fullName=, isFavorite=true), ShareEntity(secId=AGRO, shortName=AGRO-гдр, fullName=, isFavorite=true), ShareEntity(secId=AFLT, shortName=Аэрофлот, fullName=, isFavorite=true), ShareEntity(secId=FEES, shortName=Россети, fullName=, isFavorite=true)]”

“NewsScreenVM1: o tamanho dos compartilhamentos é 4”

E não há: “NewsScreenVM1: Agora estamos fora da função de coleta”, o que significa que a função de coleta não interrompeu sua emissão e ainda está em execução.

O que eu fiz errado? Por que não consigo executar linhas do código depois de coletar alguns dados do banco de dados?

Tentei executar o fluxo em um escopo de corrotina diferente como este:

fun downloadListOfSharesByIsFavorite(isFavorite: Boolean = true){
 viewModelScope.launch { 
val shares = dataBaseRepository.getAllSharesByIsFavorite(isFavorite).collect{ it:List<ShareEntity> -> 
println("NewsScreenVM1: allShares is with isFavorite = $isFavorite are $it")
println("NewsScreenVM1: the size of shares is ${it.size}")
}
println("NewsScreenVM1: Now we are outside of the collect function")
}
}

Mas a mensagem 'NewsScreenVM1: Agora estamos fora da função de coleta' aparece logo antes de todos os cálculos, o que não é o que eu quero. Quero que seja a última massagem.

Quando uso a função assíncrona com .await() também não recebo a última mensagem, pois o fluxo nunca para. Aqui está o código:

suspend fun downloadListOfSharesByIsFavorite(isFavorite: Boolean = true) {
        val asyncValue = viewModelScope.async {
            var size = 0
            val shares = dataBaseRepository.getAllSharesByIsFavorite(isFavorite)
                .collect { it: List<ShareEntity> ->
                    println("NewsScreenVM1: allShares is with isFavorite = $isFavorite are $it")
                    println("NewsScreenVM1: the size of shares is ${it.size}")
                    size = it.size

                }
            size
        }
            println("NewsScreenVM1: Now we are outside of the collect function. The list size is ${asyncValue.await()}")
        }