Controlador de estado del administrador de fragmentos

Importante

En este artículo se describen la funcionalidad y las instrucciones que se encuentran en versión preliminar pública, por lo que pueden modificarse de forma sustancial antes de que estén disponibles con carácter general. Microsoft no ofrece ninguna garantía, expresa o implícita, con respecto a la información que se ofrece aquí.

La clase FragmentManagerStateHandler ayuda a restaurar los fragmentos cuando se produce una transición en el modo de pantalla.

Al cambiar el modo de una aplicación del modo de doble pantalla al modo de pantalla única, todos los fragmentos se vuelven a crear incluso si no están visibles.

Con esta biblioteca, solo se volverán a crear los fragmentos necesarios.

Los fragmentos se restauran a partir del paquete de actividad. Este enfoque tiene dos paquetes que se intercambian en tiempo de ejecución en función del modo de expansión. Hay un paquete para la pantalla única y otro para el modo de expansión. Esto solo es posible si se agrega una devolución de llamada del ciclo de vida de la actividad y se intercambian estos dos paquetes dentro de la devolución de llamada onActivityPreCreated.

El componente detecta automáticamente el modo de pantalla. Restaura solo los fragmentos necesarios en función del modo de pantalla.

Importante

El componente solo funciona con las actividades de AndroidX.

Cómo se usa

Kotlin

class SampleApp : Application() {
    override fun onCreate() {
        super.onCreate()
        FragmentManagerStateHandler.init(this)
    }
}

class SampleActivity : AppCompatActivity() {
    companion object {
        private const val FRAGMENT_DUAL_START = "FragmentDualStart"
        private const val FRAGMENT_DUAL_END = "FragmentDualEnd"
        private const val FRAGMENT_SINGLE_SCREEN = "FragmentSingleScreen"
    }

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

    private fun registerWindowInfoFlow() {
        val windowInfoRepository = windowInfoRepository()
        lifecycleScope.launch(Dispatchers.Main) {
            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
                windowInfoRepository.windowLayoutInfo.collectIndexed { index, info ->
                    if (index == 0) {
                        onScreenInfoChanged(info)
                    }
                }
            }
        }
    }

    /**
     * Called whenever the screen info was changed.
     * @param windowLayoutInfo object used to retrieve screen information
     */
    private fun onScreenInfoChanged(windowLayoutInfo: WindowLayoutInfo) {
        when {
            windowLayoutInfo.isInDualMode() -> setupDualScreenFragments()
            else -> setupSingleScreenFragments()
        }
    }

    /**
     * Adds fragments for the single screen mode
     */
    private fun setupSingleScreenFragments() {
        if (supportFragmentManager.findFragmentByTag(FRAGMENT_SINGLE_SCREEN) == null) {
            supportFragmentManager.inTransaction {
                replace(R.id.first_container_id, SingleScreenFragment(), FRAGMENT_SINGLE_SCREEN)
            }
        }
    }

    /**
     * Adds fragments for the dual screen mode
     */
    private fun setupDualScreenFragments() {
        if (supportFragmentManager.findFragmentByTag(FRAGMENT_DUAL_START) == null &&
            supportFragmentManager.findFragmentByTag(FRAGMENT_DUAL_END) == null
        ) {
            supportFragmentManager.inTransaction {
                replace(R.id.first_container_id, DualStartFragment(), FRAGMENT_DUAL_START)
            }

            supportFragmentManager.inTransaction {
                replace(R.id.second_container_id, DualEndFragment(), FRAGMENT_DUAL_END)
            }
        }
    }
}

inline fun FragmentManager.inTransaction(func: FragmentTransaction.() -> Unit) {
    val fragmentTransaction = beginTransaction()
    fragmentTransaction.func()
    fragmentTransaction.commit()
}

Java

public class SampleApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        FragmentManagerStateHandler.init(this);
    }
}

public class SampleActivity2 extends AppCompatActivity {
    private static final String FRAGMENT_DUAL_START = "FragmentDualStart";
    private static final String FRAGMENT_DUAL_END = "FragmentDualEnd";
    private static final String FRAGMENT_SINGLE_SCREEN = "FragmentSingleScreen";

    private WindowInfoRepositoryCallbackAdapter adapter;
    private Consumer<WindowLayoutInfo> consumerWindowLayoutInfo;
    private Executor runOnUiThreadExecutor;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sample);
        initWindowLayoutInfo();
    }

    private void initWindowLayoutInfo() {
        WindowInfoRepository windowInfoRepository = WindowInfoRepository.Companion.getOrCreate(this);
        adapter = new WindowInfoRepositoryCallbackAdapter(windowInfoRepository);
        runOnUiThreadExecutor = command -> {
            if (command != null) {
                new Handler(Looper.getMainLooper()).post(command);
            }
        };
        consumerWindowLayoutInfo = this::onScreenInfoChanged;
    }

    @Override
    protected void onStart() {
        super.onStart();
        adapter.addWindowLayoutInfoListener(runOnUiThreadExecutor, consumerWindowLayoutInfo);
    }

    @Override
    protected void onStop() {
        super.onStop();
        adapter.removeWindowLayoutInfoListener(consumerWindowLayoutInfo);
    }

    /**
     * Called whenever the screen info was changed.
     *
     * @param windowLayoutInfo object used to retrieve screen information
     */
    private void onScreenInfoChanged(@NotNull WindowLayoutInfo windowLayoutInfo) {
        if (WindowLayoutInfoExtensionsKt.isInDualMode(windowLayoutInfo)) {
            setupDualScreenFragments();
        } else {
            setupSingleScreenFragments();
        }
    }

    /**
     * Adds fragments for the single screen mode
     */
    private void setupSingleScreenFragments() {
        FragmentManager fragmentManager = getSupportFragmentManager();
        if (fragmentManager.findFragmentByTag(FRAGMENT_SINGLE_SCREEN) == null) {
            fragmentManager
                    .beginTransaction()
                    .replace(R.id.first_container_id, new SingleScreenFragment(), FRAGMENT_SINGLE_SCREEN)
                    .commit();
        }
    }

    /**
     * Adds fragments for the dual screen mode
     */
    private void setupDualScreenFragments() {
        FragmentManager fragmentManager = getSupportFragmentManager();
        if (fragmentManager.findFragmentByTag(FRAGMENT_DUAL_START) == null &&
                fragmentManager.findFragmentByTag(FRAGMENT_DUAL_END) == null) {
            fragmentManager
                    .beginTransaction()
                    .replace(R.id.first_container_id, new DualStartFragment(), FRAGMENT_DUAL_START)
                    .commit();
            fragmentManager
                    .beginTransaction()
                    .replace(R.id.second_container_id, new DualEndFragment(), FRAGMENT_DUAL_END)
                    .commit();
        }
    }
}

Pasos siguientes

Obtenga información sobre otras bibliotecas de diseño de doble pantalla.