Code 33

@file:Suppress("MemberVisibilityCanBePrivate")
package com.ncapdevi.fragnav
import android.annotation.SuppressLint
import android.os.Bundle
import androidx.annotation.CheckResult
import androidx.annotation.IdRes
import androidx.annotation.IntDef
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentManager
import androidx.fragment.app.FragmentTransaction
import com.ncapdevi.fragnav.tabhistory.*
import org.json.JSONArray
import java.lang.ref.WeakReference
import java.util.*
@Suppress("unused")
/**
* The class is used to manage navigation through multiple stacks of fragments,
as well as coordinate
* fragments that may appear on screen
*
*
* https://github.com/ncapdevi/FragNav
* Nic Capdevila
* Nic.Capdevila@gmail.com
*
*
* Originally Created March 2016
*/
class FragNavController constructor(private val fragmentManger:
FragmentManager, @IdRes private val containerId: Int) {
//region Public properties

var rootFragments: List<Fragment>? = null
set(value) {
if (value != null) {
if (rootFragmentListener != null) {
throw IllegalStateException("Root fragments and root
fragment listener can not be set the same time")
}
if (value.size > FragNavController.MAX_NUM_TABS) {

throw IllegalArgumentException("Number of root fragments
cannot be greater than " + FragNavController.MAX_NUM_TABS)
}
}
field = value
}
var defaultTransactionOptions: FragNavTransactionOptions? = null
var fragNavLogger: FragNavLogger? = null
var rootFragmentListener: RootFragmentListener? = null
var transactionListener: TransactionListener? = null

var navigationStrategy: NavigationStrategy = CurrentTabStrategy()
set(value) {
field = value
fragNavTabHistoryController = when (value) {
is UniqueTabHistoryStrategy ->
UniqueTabHistoryController(DefaultFragNavPopController(),
value.fragNavSwitchController)
is UnlimitedTabHistoryStrategy ->
UnlimitedTabHistoryController(DefaultFragNavPopController(),
else ->
CurrentTabHistoryController(DefaultFragNavPopController())
}
var fragmentHideStrategy = FragNavController.DETACH

var createEager = false
@TabIndex
@get:CheckResult
@get:TabIndex
var currentStackIndex: Int = FragNavController.TAB1
private set
//endregion
//region Private properties

private val fragmentStacksTags: MutableList<Stack<String>> = ArrayList()
private var tagCount: Int = 0
private var mCurrentFrag: Fragment? = null
private var mCurrentDialogFrag: DialogFragment? = null
private var executingTransaction: Boolean = false

private var fragNavTabHistoryController: FragNavTabHistoryController =
private val fragmentCache = mutableMapOf<String, WeakReference<Fragment>>()
//endregion
//region Public helper functions
/**
* Helper function to attempt to get current fragment
*
* @return Fragment the current frag to be returned
*/
val currentFrag: Fragment?
get() {
//Attempt to used stored current fragment
if (mCurrentFrag?.isAdded == true &&
mCurrentFrag?.isDetached?.not() == true) {
return mCurrentFrag
} else if (currentStackIndex == NO_TAB) {
return null
} else if (fragmentStacksTags.isEmpty()) {
return null
}
//if not, try to pull it from the stack
val fragmentStack = fragmentStacksTags[currentStackIndex]
if (!fragmentStack.isEmpty()) {
val fragmentByTag = getFragment(fragmentStack.peek())
if (fragmentByTag != null) {
mCurrentFrag = fragmentByTag
}
}
return mCurrentFrag
}
/**
* @return Current DialogFragment being displayed. Null if none
*/
val currentDialogFrag: DialogFragment?
@CheckResult
get() {
if (mCurrentDialogFrag != null) {
return mCurrentDialogFrag
} else {
//Else try to find one in the FragmentManager
val fragmentManager: FragmentManager =
getFragmentManagerForDialog()
mCurrentDialogFrag = fragmentManager.fragments.firstOrNull { it
is DialogFragment } as DialogFragment?
}
}
/**
* Get the number of fragment stacks
*
* @return the number of fragment stacks
*/
val size: Int
@CheckResult
get() = fragmentStacksTags.size
/**
* Get a copy of the current stack that is being displayed
*
* @return Current stack
*/
val currentStack: Stack<Fragment>?
@CheckResult
get() = getStack(currentStackIndex)
/**
* @return If true, you are at the bottom of the stack
* (Consider using replaceFragment if you need to change the root fragment
for some reason)
* else you can popFragment as needed as your are not at the root
*/
val isRootFragment: Boolean
@CheckResult
get() = fragmentStacksTags.getOrNull(currentStackIndex)?.size == 1
/**
* Helper function to get whether the fragmentManger has gone through a
stateSave, if this is true, you probably want to commit allowing state loss
*
* @return if fragmentManger isStateSaved
*/
val isStateSaved: Boolean
get() = fragmentManger.isStateSaved
/**
* Helper function to make sure that we are starting with a clean slate and
to perform our first fragment interaction.
*
* @param index the tab index to initialize to
*/
fun initialize(@TabIndex index: Int = TAB1, savedInstanceState: Bundle? =

null) {
if (rootFragmentListener == null && rootFragments == null) {
throw IndexOutOfBoundsException("Either a root fragment(s) needs to
be set, or a fragment listener")
} else if (rootFragmentListener != null && rootFragments != null) {
throw java.lang.IllegalStateException("Shouldn't have both a
rootFragmentListener and rootFragments set, this is clearly a mistake")
}
val numberOfTabs: Int = rootFragmentListener?.numberOfRootFragments ?:

rootFragments?.size
?: 0
//Attempt to restore from bundle, if not, initialize

if (!restoreFromBundle(savedInstanceState)) {
fragmentStacksTags.clear()
for (i in 0 until numberOfTabs) {
fragmentStacksTags.add(Stack())
}
currentStackIndex = index
if (currentStackIndex > fragmentStacksTags.size) {
throw IndexOutOfBoundsException("Starting index cannot be
larger than the number of stacks")
}
fragNavTabHistoryController.switchTab(index)
clearFragmentManager()
clearDialogFragment()
if (index == NO_TAB) {
return
}
val ft = createTransactionWithOptions(defaultTransactionOptions,
false, false)
val lowerBound = if (createEager) 0 else index

val upperBound = if (createEager) fragmentStacksTags.size else
index + 1
for (i in lowerBound until upperBound) {
currentStackIndex = i
val fragment = getRootFragment(i)
val fragmentTag = generateTag(fragment)
fragmentStacksTags[currentStackIndex].push(fragmentTag)
ft.addSafe(containerId, fragment, fragmentTag)
if (i != index) {
when {
shouldDetachAttachOnSwitch() -> ft.detach(fragment)
shouldRemoveAttachOnSwitch() -> ft.remove(fragment)
else -> ft.hide(fragment)
}
} else {
mCurrentFrag = fragment
}
}
commitTransaction(ft, defaultTransactionOptions)
transactionListener?.onTabTransaction(currentFrag,
currentStackIndex)
} else {
fragNavTabHistoryController.restoreFromBundle(savedInstanceState)
}
}
//endregion
//region Transactions
/**
* Function used to switch to the specified fragment stack
*
* @param index The given index to switch to
* @param transactionOptions Transaction options to be displayed
* @throws IndexOutOfBoundsException Thrown if trying to switch to an index
outside given range
*/
@Throws(IndexOutOfBoundsException::class)
@JvmOverloads
fun switchTab(@TabIndex index: Int, transactionOptions:
FragNavTransactionOptions? = defaultTransactionOptions) {
switchTabInternal(index, transactionOptions)
}
private fun switchTabInternal(@TabIndex index: Int, transactionOptions:
FragNavTransactionOptions?) {
//Check to make sure the tab is within range
if (index >= fragmentStacksTags.size) {
throw IndexOutOfBoundsException("Can't switch to a tab that hasn't
been initialized, " +
"Index : " + index + ", current stack size : " +
fragmentStacksTags.size +
". Make sure to create all of the tabs you need in the
Constructor or provide a way for them to be created via RootFragmentListener.")
}
if (currentStackIndex != index) {
val ft = createTransactionWithOptions(transactionOptions, index <
currentStackIndex)
removeCurrentFragment(ft, shouldDetachAttachOnSwitch(),
shouldRemoveAttachOnSwitch())
var fragment: Fragment? = null

commitTransaction(ft, transactionOptions)
} else {
//Attempt to reattach previous fragment
fragment = addPreviousFragment(ft, shouldDetachAttachOnSwitch()
|| shouldRemoveAttachOnSwitch())
}
currentStackIndex)
}
}
/**
* Push a fragment onto the current stack
*
* @param fragment The fragment that is to be pushed
*/
@JvmOverloads
fun pushFragment(fragment: Fragment?, transactionOptions:
if (fragment != null && currentStackIndex != NO_TAB) {
val ft = createTransactionWithOptions(transactionOptions, false)
removeCurrentFragment(ft, shouldDetachAttachOnPushPop(),

transactionListener?.onFragmentTransaction(currentFrag,
TransactionType.PUSH)
}
}
/**
* Pop the current fragment from the current tab
*
*/
@Throws(UnsupportedOperationException::class)
@JvmOverloads
fun popFragment(transactionOptions: FragNavTransactionOptions? =
defaultTransactionOptions): Boolean {
return popFragments(1, transactionOptions)
}
/**
* Pop the current stack until a given tag is found. If the tag is not
found, the stack will popFragment until it is at
* the root fragment
*
* @return true if any any fragment has been popped
*/
fun popFragments(popDepth: Int, transactionOptions:
FragNavTransactionOptions?): Boolean {
return fragNavTabHistoryController.popFragments(popDepth,
transactionOptions)
}
private fun tryPopFragmentsFromCurrentStack(popDepth: Int,
transactionOptions: FragNavTransactionOptions?): Int {
if (navigationStrategy is CurrentTabStrategy && isRootFragment) {
throw UnsupportedOperationException(
"You can not popFragment the rootFragment. If you need to
change this fragment, use replaceFragment(fragment)")
} else if (popDepth < 1) {
throw UnsupportedOperationException("popFragments parameter needs
to be greater than 0")
throw UnsupportedOperationException("You can not pop fragments when
no tab is selected")
}
//If our popDepth is big enough that it would just clear the stack,
then call that.
val currentStack = fragmentStacksTags[currentStackIndex]
val poppableSize = currentStack.size - 1
if (popDepth >= poppableSize) {
clearStack(transactionOptions)
return poppableSize
}
val ft = createTransactionWithOptions(transactionOptions, true)
//Pop the number of the fragments on the stack and remove them from the
FragmentManager
for (i in 0 until popDepth) {
val fragment = getFragment(currentStack.pop())
if (fragment != null) {
ft.removeSafe(fragment)
}
}
// Attempt to reattach previous fragment

val fragment = addPreviousFragment(ft, shouldDetachAttachOnPushPop())
TransactionType.POP)
return popDepth
}
/**
*/
fun popFragments(popDepth: Int) {
popFragments(popDepth, defaultTransactionOptions)
}
/**
* Clears the current tab's stack to get to just the bottom Fragment. This
will reveal the root fragment
*
*/
@JvmOverloads
fun clearStack(transactionOptions: FragNavTransactionOptions? =
defaultTransactionOptions) {
clearStack(currentStackIndex,transactionOptions)
}
/**
* Clears the passed tab's stack to get to just the bottom Fragment. This
*
* @param tabIndex Index of tab that needs to be cleared
*/
@JvmOverloads
fun clearStack(tabIndex: Int, transactionOptions:
if (tabIndex == NO_TAB) {
return
}
//Grab Current stack

val fragmentStack = fragmentStacksTags[tabIndex]
// Only need to start popping and reattach if the stack is greater than
1
if (fragmentStack.size > 1) {
//Only animate if we're clearing the current stack
val shouldAnimate = tabIndex == currentStackIndex
val ft = createTransactionWithOptions(transactionOptions,true,
shouldAnimate)
//Pop all of the fragments on the stack and remove them from the
FragmentManager
while (fragmentStack.size > 1) {
val fragment = getFragment(fragmentStack.pop())
}
}

val fragment = addPreviousFragment(ft,
shouldDetachAttachOnPushPop())
}
}
/**
* Replace the current fragment
*
* @param fragment the fragment to be shown instead
*/
@JvmOverloads
fun replaceFragment(fragment: Fragment, transactionOptions:
val poppingFrag = currentFrag
if (poppingFrag != null) {
//overly cautious fragment popFragment

ft.replace(containerId, fragment, fragmentTag)
fragmentStacksTags[currentStackIndex].apply {
if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
TransactionType.REPLACE)
}
}
/**
* Clear any DialogFragments that may be shown
*/
@Suppress("MemberVisibilityCanBePrivate")
fun clearDialogFragment() {
val currentDialogFrag = mCurrentDialogFrag
if (currentDialogFrag != null) {
currentDialogFrag.dismiss()
mCurrentDialogFrag = null
} else {
fragmentManager.fragments.forEach {
if (it is DialogFragment) {
it.dismiss()
}
}
}
}
/**
* Display a DialogFragment on the screen
*
* @param dialogFragment The Fragment to be Displayed
*/
fun showDialogFragment(dialogFragment: DialogFragment?) {
//Clear any current dialog fragments
if (dialogFragment != null) {
mCurrentDialogFrag = dialogFragment
try {
dialogFragment.show(fragmentManager,
dialogFragment.javaClass.name)
} catch (e: IllegalStateException) {
logError("Could not show dialog", e)
// Activity was likely destroyed before we had a chance to
show, nothing can be done here.
}
}
}
//endregion
//region Private helper functions
/**
* Helper function to get the root fragment for a given index. This is done
by either passing them in the constructor, or dynamically via NavListener.
*
* @param index The tab index to get this fragment from
* @return The root fragment at this index
* @throws IllegalStateException This will be thrown if we can't find a
rootFragment for this index. Either because you didn't provide it in the
* constructor, or because your RootFragmentListener.getRootFragment(index)
isn't returning a fragment for this index.
*/
@CheckResult
@Throws(IllegalStateException::class)
private fun getRootFragment(index: Int): Fragment {
if (fragment == null) {
fragment = rootFragmentListener?.getRootFragment(index)
}
fragment = rootFragments?.getOrNull(index)
}
throw IllegalStateException("Either you haven't past in a fragment
at this index in your constructor, or you haven't " + "provided a way to create
it while via your RootFragmentListener.getRootFragment(index)")
}
return fragment
}
/**
* Adds fragment to the fragment transaction, also add it to local cache so
we can obtain it even before transaction has been committed.
*/
private fun FragmentTransaction.addSafe(containerViewId: Int, fragment:
Fragment, tag: String) {
fragmentCache[tag] = WeakReference(fragment)
add(containerViewId, fragment, tag)
}
/**
* Remove the fragment from transaction and also from cache if found.
*/
private fun FragmentTransaction.removeSafe(fragment: Fragment) {
val tag = fragment.tag
if (tag != null) {
fragmentCache.remove(tag)
}
remove(fragment)
}
/**
* Will attempt to reattach a previous fragment or fragments in fragment
stack until it succeeds or replace with root fragment.
*
* @param ft current fragment transaction
* @return Fragment if we were able to find and reattach it
*/
private fun addPreviousFragment(ft: FragmentTransaction, isAttach:
Boolean): Fragment {
var currentFragment: Fragment? = null
var currentTag: String? = null
var index = 0
val initialSize = fragmentStack.size
while (currentFragment == null && fragmentStack.isNotEmpty()) {
index++
currentTag = fragmentStack.pop()
currentFragment = getFragment(currentTag)
}
return if (currentFragment != null) {
if (index > 1) {
val message = "Could not restore top fragment on current stack"
logError(message, IllegalStateException(message))
}
fragmentStack.push(currentTag)
if (isAttach) {
ft.attach(currentFragment)
} else {
ft.show(currentFragment)
}
currentFragment
} else {
if (initialSize > 0) {
val message = "Could not restore any fragment on current stack,
adding new root fragment"
}
val rootFragment = getRootFragment(currentStackIndex)
val rootTag = generateTag(rootFragment)
fragmentStack.push(rootTag)
ft.addSafe(containerId, rootFragment, rootTag)
rootFragment
}
}
/**
* Attempts to detach any current fragment if it exists, and if none is
found, returns.
*
* @param ft the current transaction being performed
*/
private fun removeCurrentFragment(ft: FragmentTransaction, isDetach:
Boolean, isRemove: Boolean) {
currentFrag?.let {
when {
isDetach -> ft.detach(it)
isRemove -> ft.remove(it)
else -> ft.hide(it)
}
}
}
/**
* Create a unique fragment tag so that we can grab the fragment later from
the FragmentManger
*
* @param fragment The fragment that we're creating a unique tag for
* @return a unique tag using the fragment's class name
*/
@CheckResult
private fun generateTag(fragment: Fragment): String {
return fragment.javaClass.name + ++tagCount
}
private fun getFragment(tag: String): Fragment? {

val weakReference = fragmentCache[tag]
if (weakReference != null) {
val fragment = weakReference.get()
return fragment
}
}
return fragmentManger.findFragmentByTag(tag)
}
/**
* Private helper function to clear out the fragment manager on
initialization. All fragment management should be done via FragNav.
*/
private fun clearFragmentManager() {
val currentFragments = fragmentManger.fragments.filterNotNull()
if (currentFragments.isNotEmpty()) {
with(createTransactionWithOptions(defaultTransactionOptions,
false)) {
currentFragments.forEach { removeSafe(it) }
commitTransaction(this, defaultTransactionOptions)
}
}
}
/**
* Setup a fragment transaction with the given option
*
* @param transactionOptions The options that will be set for this
transaction
*/
@SuppressLint("CommitTransaction")
@CheckResult
private fun createTransactionWithOptions(transactionOptions:
FragNavTransactionOptions?, isPopping: Boolean, animated: Boolean = true):
FragmentTransaction {
return fragmentManger.beginTransaction().apply {
transactionOptions?.also { options ->
// Not using standard pop support since we handle backstack
manually
if (animated) {
if (isPopping) {
setCustomAnimations(
transactionOptions.popEnterAnimation,
transactionOptions.popExitAnimation
)
} else {
transactionOptions.enterAnimation,
transactionOptions.exitAnimation
)
}
}
setTransitionStyle(options.transitionStyle)
setTransition(options.transition)
options.sharedElements.forEach { sharedElement ->

sharedElement.first?.let {
sharedElement.second?.let { it1 ->
addSharedElement(
it,
it1
)
}
}
}
when {
options.breadCrumbTitle != null ->
setBreadCrumbTitle(options.breadCrumbTitle)
options.breadCrumbShortTitle != null ->
setBreadCrumbShortTitle(options.breadCrumbShortTitle)
}
setReorderingAllowed(options.reordering)
}
}
}
/**
* Helper function to commit fragment transaction with transaction option -
allowStateLoss
*
* @param fragmentTransaction
* @param transactionOptions
*/
private fun commitTransaction(fragmentTransaction: FragmentTransaction,
transactionOptions: FragNavTransactionOptions?) {
if (transactionOptions?.allowStateLoss == true) {
fragmentTransaction.commitAllowingStateLoss()
} else {
fragmentTransaction.commit()
}
}
private fun logError(message: String, throwable: Throwable) {

fragNavLogger?.error(message, throwable)
}
private fun shouldDetachAttachOnPushPop(): Boolean {

return fragmentHideStrategy != HIDE
}
private fun shouldDetachAttachOnSwitch(): Boolean {

return fragmentHideStrategy == DETACH
}
private fun shouldRemoveAttachOnSwitch(): Boolean {

return fragmentHideStrategy == REMOVE
}
/**
* Get a copy of the stack at a given index
*
* @return requested stack
*/
@CheckResult
fun getStack(@TabIndex index: Int): Stack<Fragment>? {
return null
}
return fragmentStacksTags[index].mapNotNullTo(Stack()) { s ->
getFragment(s) }
}
/**
* Use this if you need to make sure that pending transactions occur
immediately. This call is safe to
* call as often as you want as there's a check to prevent multiple
executePendingTransactions at once
*/
fun executePendingTransactions() {
if (!executingTransaction) {
executingTransaction = true
fragmentManger.executePendingTransactions()
executingTransaction = false
}
}
fun getFragmentManagerForDialog(): FragmentManager {

val currentFrag = this.currentFrag
return if (currentFrag?.isAdded == true) {
currentFrag.childFragmentManager
} else {
this.fragmentManger
}
}
//endregion
//region SavedInstanceState
/**
* Call this in your Activity's onSaveInstanceState(Bundle outState) method
to save the instance's state.
*
* @param outState The Bundle to save state information to
*/
fun onSaveInstanceState(outState: Bundle?) {
if (outState == null) {
return
}
// Write tag count
outState.putInt(EXTRA_TAG_COUNT, tagCount)
// Write select tab

outState.putInt(EXTRA_SELECTED_TAB_INDEX, currentStackIndex)
// Write current fragment

val currentFrag = currentFrag
if (currentFrag != null) {
outState.putString(EXTRA_CURRENT_FRAGMENT, currentFrag.tag)
}
// Write tag stacks
try {
val stackArrays = JSONArray()
fragmentStacksTags.forEach { stack ->
val stackArray = JSONArray()
stack.forEach { stackArray.put(it) }
stackArrays.put(stackArray)
}
outState.putString(EXTRA_FRAGMENT_STACK, stackArrays.toString())
} catch (t: Throwable) {

logError("Could not save fragment stack", t)
// Nothing we can do
}
fragNavTabHistoryController.onSaveInstanceState(outState)
}
/**
* Restores this instance to the state specified by the contents of
savedInstanceState
*
* @param savedInstanceState The bundle to restore from
* @return true if successful, false if not
*/
private fun restoreFromBundle(savedInstanceState: Bundle?): Boolean {
if (savedInstanceState == null) {
return false
}
// Restore tag count

tagCount = savedInstanceState.getInt(EXTRA_TAG_COUNT, 0)
// Restore current fragment

val tag = savedInstanceState.getString(EXTRA_CURRENT_FRAGMENT)
if (tag !=null) {
mCurrentFrag = getFragment(tag)
}
// Restore fragment stacks

try {
val stackArrays =
JSONArray(savedInstanceState.getString(EXTRA_FRAGMENT_STACK))
for (x in 0 until stackArrays.length()) {

val stackArray = stackArrays.getJSONArray(x)
val stack = Stack<String>()
(0 until stackArray.length())
.map { stackArray.getString(it) }
.filter { !it.isNullOrEmpty() && !"null".equals(it,
ignoreCase = true) }
.mapNotNullTo(stack) { it }
fragmentStacksTags.add(stack)
}
// Restore selected tab if we have one
val selectedTabIndex =
savedInstanceState.getInt(EXTRA_SELECTED_TAB_INDEX)
if (selectedTabIndex in 0..(MAX_NUM_TABS - 1)) {
// Shortcut for switchTab. We already restored fragment, so
just notify history controller
// We cannot use switchTab, because switchTab removes fragment,
but we don't want it
currentStackIndex = selectedTabIndex
fragNavTabHistoryController.switchTab(selectedTabIndex)
transactionListener?.onTabTransaction(mCurrentFrag,
selectedTabIndex)
}
//Successfully restored state

return true
} catch (ex: Throwable) {
tagCount = 0
mCurrentFrag = null
logError("Could not restore fragment state", ex)
return false
}
}
//endregion
enum class TransactionType {

PUSH,
POP,
REPLACE
}
//Declare the TabIndex annotation

@IntDef(NO_TAB, TAB1, TAB2, TAB3, TAB4, TAB5, TAB6, TAB7, TAB8, TAB9,
TAB10, TAB11, TAB12, TAB13, TAB14, TAB15, TAB16, TAB17, TAB18, TAB19, TAB20)
@kotlin.annotation.Retention(AnnotationRetention.SOURCE)
annotation class TabIndex
// Declare Transit Styles

@IntDef(FragmentTransaction.TRANSIT_NONE,
FragmentTransaction.TRANSIT_FRAGMENT_OPEN,
FragmentTransaction.TRANSIT_FRAGMENT_CLOSE,
FragmentTransaction.TRANSIT_FRAGMENT_FADE)
internal annotation class Transit
/**
* Define what happens when we try to pop on a tab where root fragment is
at the top
*/
@IntDef(DETACH, HIDE, REMOVE, DETACH_ON_NAVIGATE_HIDE_ON_SWITCH)
annotation class FragmentHideStrategy
interface RootFragmentListener {
val numberOfRootFragments: Int
/**
* Dynamically create the Fragment that will go on the bottom of the
stack
*
* @param index the index that the root of the stack Fragment needs to
go
* @return the new Fragment
*/
fun getRootFragment(index: Int): Fragment
}
interface TransactionListener {
fun onTabTransaction(fragment: Fragment?, index: Int)
fun onFragmentTransaction(fragment: Fragment?, transactionType:

TransactionType)
}
inner class DefaultFragNavPopController :

com.ncapdevi.fragnav.FragNavPopController {
override fun tryPopFragments(popDepth: Int, transactionOptions:
FragNavTransactionOptions?): Int {
return
this@FragNavController.tryPopFragmentsFromCurrentStack(popDepth,
transactionOptions)
}
}
companion object {
// Declare the constants. A maximum of 5 tabs is recommended for bottom
navigation, this is per Material Design's Bottom Navigation's design spec.
const val NO_TAB = -1
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9
const val TAB11 = 10
internal const val MAX_NUM_TABS = 20
// Extras used to store savedInstanceState

private val EXTRA_TAG_COUNT = FragNavController::class.java.name +
":EXTRA_TAG_COUNT"
private val EXTRA_SELECTED_TAB_INDEX =
FragNavController::class.java.name + ":EXTRA_SELECTED_TAB_INDEX"
private val EXTRA_CURRENT_FRAGMENT = FragNavController::class.java.name
+ ":EXTRA_CURRENT_FRAGMENT"
private val EXTRA_FRAGMENT_STACK = FragNavController::class.java.name +
":EXTRA_FRAGMENT_STACK"
/**
* Using attach and detach methods of Fragment transaction to switch
between fragments
*/
const val DETACH = 0
/**
* Using show and hide methods of Fragment transaction to switch
between fragments
*/
const val HIDE = 1
/**
* Using attach and detach methods of Fragment transaction to navigate
between fragments on the current tab but
* using show and hide methods to switch between tabs
*/
const val DETACH_ON_NAVIGATE_HIDE_ON_SWITCH = 2
/**
* Using create + attach and remove methods of Fragment transaction to
switch between fragments
*/
const val REMOVE = 3
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/
set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}
return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks

try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}

/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0
}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}
}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}
import java.util.*
@Suppress("unused")
/**
*
*
* Nic Capdevila
*
*
*/

set(value) {
}

}
}
field = value
}

set(value) {
field = value
else ->
}

@TabIndex
@get:CheckResult
@get:TabIndex
private set
//endregion


//endregion
/**
*
*/
get() {
return mCurrentFrag
return null
return null
}
}
}
return mCurrentFrag
}
/**
*/
@CheckResult
get() {
} else {
}
}
/**
*
*/
val size: Int
@CheckResult
/**
*
*/
@CheckResult
/**
for some reason)
*/
@CheckResult
/**
*
*/
/**
*
*/

null) {
}

rootFragments?.size
?: 0

}
}
return
}
false, false)

index + 1
if (i != index) {
when {
}
} else {
}
}
currentStackIndex)
} else {
}
}
//endregion
/**
*
outside given range
*/
@JvmOverloads
}
}
currentStackIndex)

} else {
}
currentStackIndex)
}
}
/**
*
*/
@JvmOverloads

}
}
/**
*
*/
@JvmOverloads
}
/**
* the root fragment
*
*/
transactionOptions)
}
}
then call that.
return poppableSize
}
FragmentManager
}
}

return popDepth
}
/**
*/
}
/**
*
*/
@JvmOverloads
}
/**
*
*/
@JvmOverloads
return
}

1
shouldAnimate)
FragmentManager
}
}

}
}
/**
*
*/
@JvmOverloads

if (isNotEmpty()) {
pop()
}
push(fragmentTag)
}
}
}
/**
*/
} else {
it.dismiss()
}
}
}
}
/**
*
*/
try {
}
}
}
//endregion
/**
*
*/
@CheckResult
}
}
}
return fragment
}
/**
*/
}
/**
*/
if (tag != null) {
}
remove(fragment)
}
/**
*
*/
var index = 0
index++
}
if (index > 1) {
}
if (isAttach) {
} else {
}
currentFragment
} else {
}
rootFragment
}
}
/**
found, returns.
*
*/
currentFrag?.let {
when {
else -> ft.hide(it)
}
}
}
/**
the FragmentManger
*
*/
@CheckResult
}

return fragment
}
}
}
/**
*/
false)) {
}
}
}
/**
*
transaction
*/
@CheckResult
manually
if (animated) {
if (isPopping) {
)
} else {
)
}
}

addSharedElement(
it,
it1
)
}
}
}
when {
}
}
}
}
/**
allowStateLoss
*
*/
} else {
}
}

}

}

}

}
/**
*
*/
@CheckResult
return null
}
getFragment(s) }
}
/**
*/
}
}

} else {
this.fragmentManger
}
}
//endregion
/**
*
*/
return
}
// Write tag count
// Write select tab


}
// Write tag stacks
try {
}

}
}
/**
savedInstanceState
*
*/
return false
}


if (tag !=null) {
}

try {
val stackArrays =

}
selectedTabIndex)
}

return true
tagCount = 0
mCurrentFrag = null
return false
}
}
//endregion

PUSH,
POP,
REPLACE
}


/**
at the top
*/
/**
stack
*
go
*/
}

TransactionType)
}

return
transactionOptions)
}
}
companion object {
const val TAB1 = 0
const val TAB2 = 1
const val TAB3 = 2
const val TAB4 = 3
const val TAB5 = 4
const val TAB6 = 5
const val TAB7 = 6
const val TAB8 = 7
const val TAB9 = 8
const val TAB10 = 9

":EXTRA_TAG_COUNT"
/**
between fragments
*/
/**
between fragments
*/
const val HIDE = 1
/**
*/
/**
*/
}
}

Code 33

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Code 33

Hochgeladen von

Copyright:

Verfügbare Formate

@file:Suppress("MemberVisibilityCanBePrivate")

//region Public properties

if (value.size > FragNavController.MAX_NUM_TABS) {

var transactionListener: TransactionListener? = null

var fragmentHideStrategy = FragNavController.DETACH

//region Private properties

private var executingTransaction: Boolean = false

//region Public helper functions

fun initialize(@TabIndex index: Int = TAB1, savedInstanceState: Bundle? =

val numberOfTabs: Int = rootFragmentListener?.numberOfRootFragments ?:

//Attempt to restore from bundle, if not, initialize

val lowerBound = if (createEager) 0 else index

var fragment: Fragment? = null

val fragmentTag = generateTag(fragment)

val ft = createTransactionWithOptions(transactionOptions, true)

// Attempt to reattach previous fragment

//Grab Current stack

// Attempt to reattach previous fragment

val fragmentTag = generateTag(fragment)

//region Private helper functions

private fun getFragment(tag: String): Fragment? {

options.sharedElements.forEach { sharedElement ->

private fun logError(message: String, throwable: Throwable) {

private fun shouldDetachAttachOnPushPop(): Boolean {

private fun shouldDetachAttachOnSwitch(): Boolean {

private fun shouldRemoveAttachOnSwitch(): Boolean {

fun getFragmentManagerForDialog(): FragmentManager {

// Write select tab

// Write current fragment

// Write tag stacks

} catch (t: Throwable) {

// Restore tag count

// Restore current fragment

// Restore fragment stacks

for (x in 0 until stackArrays.length()) {

//Successfully restored state

enum class TransactionType {

//Declare the TabIndex annotation

// Declare Transit Styles

fun onTabTransaction(fragment: Fragment?, index: Int)

fun onFragmentTransaction(fragment: Fragment?, transactionType:

inner class DefaultFragNavPopController :

internal const val MAX_NUM_TABS = 20

// Extras used to store savedInstanceState

if (value.size > FragNavController.MAX_NUM_TABS) {

var transactionListener: TransactionListener? = null

var fragmentHideStrategy = FragNavController.DETACH

//region Private properties

private var executingTransaction: Boolean = false

fun initialize(@TabIndex index: Int = TAB1, savedInstanceState: Bundle? =

val numberOfTabs: Int = rootFragmentListener?.numberOfRootFragments ?:

//Attempt to restore from bundle, if not, initialize

val lowerBound = if (createEager) 0 else index

var fragment: Fragment? = null

val fragmentTag = generateTag(fragment)

val ft = createTransactionWithOptions(transactionOptions, true)

//Grab Current stack

// Attempt to reattach previous fragment

//overly cautious fragment popFragment

val fragmentTag = generateTag(fragment)

//region Private helper functions

private fun getFragment(tag: String): Fragment? {

options.sharedElements.forEach { sharedElement ->