LazylifecycleCallbacks

Retornos de chamada de ciclo de Lazilifel

Os retornos de chamada do Lazilifecycle é uma estrutura simples para adiar suas tarefas não essenciais e as inicializações fora do caminho de lançamento da tela, mantendo as mesmas garantias de execução dos retornos de chamada do ciclo de vida do Android.

Fundamentos de retornos de chamada preguiçosos

• Primeiro empate: quando o aplicativo for lançado, a Play Store rastreia os números de lançamento frio, quente e quente. E o faz medindo a rapidez com que seu aplicativo é capaz de desenhar seu primeiro quadro. O aplicativo pode começar via lançador, notificações, deeplinks etc., e cada um pode pousar o usuário em telas diferentes. Considera -se que o aplicativo renderizou sua primeira tela quando o marcador "exibido" é mostrado no logcat. Sempre mostrado depois de todos os retornos de chamada para cima, como OnCreate, OnStart e OnResume, retornaram.

• Portanto, qualquer código que esteja executando o OnCreate, OnStart e OnResume e outros retornos de chamada ascendente (não mencionando coisas como OnPoStresume) tem potencial para tornar o tempo de lançamento da tela ruim. Portanto, é aconselhável remover o código diferida dos retornos de chamada do ciclo de vida do Android.

• Mas para onde devemos movê -lo? Podemos fazer as coisas sob demanda, mas nem tudo pode ser movido na OnDemand. Por exemplo, você deseja começar a fazer o N/W exige buscar as imagens o mais rápido possível. Aqui, não queremos que ele comece enquanto a renderização da tela está acontecendo, mas no momento em que a tela se renderiza com a visão de espaço reservado, precisamos iniciar as chamadas N/W-DB. Suponha que você queira carregar o rascunho de um email do banco de dados, primeiro gostaríamos de renderizar a tela Compose e depois começar a buscar o rascunho.

APIs

• Activate () - ativa os retornos de chamada preguiçosos em uma atividade, geralmente feita no OnResume ()
• DeActivate () - Desativar retornos de chamada preguiçosos em uma atividade, geralmente feita na pausa ()
• WatchedView - Cada tela possui uma visualização exclusiva que é crítica para essa tela e a renderização nessa tela pode ser considerada como lançamento. Se nenhuma exibição assistida for fornecida ou identificada, a vista da decoração pode ser usada.
• SupportsLazylifeCycleCallbacks - Isso nos ajuda a bordo da estrutura de forma incremental e nos permite realizar exeperamentos para medir a melhoria. Se isso retornar false para uma atividade, os retornos de chamada do ciclo de vida preguiçosos não serão ativados para essa tela. Cada tela pode substituir seu valor separadamente.
• LazylifeCycleCallbacks - Qualquer atividade/fragmento que queira a bordo desses retornos de chamada precisa implementar essa interface.

Os retornos de chamada preguiçosos fornecidos pela estrutura

• OnlazyCreate - Executa uma vez por atividade/fragmento como o OnCreate, mas após o primeiro sorteio acabamentos na tela ou no time limite.
• OnlazyStart - Excula se a atividade for retomada de um estado parado, mas após o primeiro empate na tela acabamentos ou no time limite.
• OnlazyResume - Excula se a atividade retomar de um estado pausado, mas após o primeiro sorteio na tela acaba ou no timeout.
• OnViewCreatedLazy (View) - isso é chamado apenas para fragmentos após o primeiro draw na tela acabamentos.

Ordenação relativa de retornos de chamada preguiçosos

A ordem desses retornos de chamada é mantida conforme o Android. Em uma atividade, o OnlazyCreate () será seguido por LazyStart (), seguido por onlazyResume (). Em fragmentos, o onLazyCreate () será seguido pelo OnViewCreatedLazy (View), seguido por OnlazyStart () seguido por onlazyresume (). Uma coisa à mente é que todos os retornos de chamada preguiçosos acontecem depois que os gatilhos do gerente de ciclo de vida preguiçosos estão satisfeitos. Eles não se entrelaçam com os retornos de chamada do ciclo de vida do Android.

Como configurar

Adicione o código abaixo às dependências do arquivo build.gradle dependencies { implementation 'com.github.microsoft:LazylifecycleCallbacks:v1.0' }

1. Implemente a interface LazyLifecycleCallbacks na atividade (preferivelmente, uma BaseActivity ) e forneça as implementações padrão do método.
2. Crie instância do LazylifeCycleManager em onCreate() .
3. Ligue para lifecycleManager.activate() em onResume ,
4. e ligue para lifecycleManager.deactivate() em onPause()
5. Substituir supportsLazyLifecycleCallbacks() para true .
6. Você terminou. Outras implementações da sua BaseActivity agora podem substituir os retornos de chamada do ciclo de vida preguiçosos e usá -lo.

Veja o código abaixo:

 abstract class BaseActivity : AppCompatActivity (), LazyLifecycleCallbacks {

    protected lateinit var lazyLifecycleManager : LazyLifecycleManager

    override fun onCreate ( savedInstanceState : Bundle ? ) {
        super .onCreate(savedInstanceState)
        lazyLifecycleManager = ViewBasedLazyLifecycleManager ( this )
    }

    override fun onResume () {
        super .onResume()
        lazyLifecycleManager.activate()
    }

    override fun onPause () {
        super .onPause()
        lazyLifecycleManager.deactivate()
    }

    override fun onLazyCreate () {}

    override fun onLazyStart () {}

    override fun onLazyResume () {}

    override fun supportsLazyLifecycleCallbacks (): Boolean = false
}