Обработчик состояния диспетчера фрагментов

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()
}

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();
        }
    }
}