ОШибка при добавлении строки     private val inMemoryCardRepository: InMemoryCardRepository, в чём проблема? package ru.maxi.mobile.feature.newCardTab.ui.content

import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.axmor.maxi.view.main.TabType
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import ru.maxi.mobile.business.auth.AuthInteractor
import ru.maxi.mobile.business.bottomnavigation.BottomNavigationInteractor
import ru.maxi.mobile.common.card.repository.inmemory.InMemoryCardRepository
import ru.maxi.mobile.common.card.repository.local.LocalCardRepository
import ru.maxi.mobile.common.utils.android.barcode.Barcode
import ru.maxi.mobile.core.data.ReloadableData
import ru.maxi.mobile.core.data.emitLoading
import ru.maxi.mobile.core.data.emitRefreshing
import ru.maxi.mobile.core.data.emitSuccess
import ru.maxi.mobile.core.data.exception.BusinessLogicException
import ru.maxi.mobile.core.data.isLoading
import ru.maxi.mobile.core.data.isRefreshing
import ru.maxi.mobile.core.data.isSuccess
import ru.maxi.mobile.core.data.mapped
import ru.maxi.mobile.core.network.utils.REQUEST_ERROR_MESSAGE
import ru.maxi.mobile.entity.featurepromo.FeaturePromoType
import ru.maxi.mobile.feature.analytics.model.AnalyticType
import ru.maxi.mobile.feature.analytics.model.actions.AnalyticNewCardActions
import ru.maxi.mobile.feature.analytics.model.events.AnalyticsGeneralEvent
import ru.maxi.mobile.feature.analytics.usecase.AnalyticsUseCase
import ru.maxi.mobile.feature.birthdaygifts.usecase.ClientBirthdayInteractor
import ru.maxi.mobile.feature.bonusPoints.BonusPointsScreens
import ru.maxi.mobile.feature.cardtab.viewmodel.GetClientCardBarcodeUseCase
import ru.maxi.mobile.feature.chips.ChipsScreens
import ru.maxi.mobile.feature.clubs.model.Club
import ru.maxi.mobile.feature.newCardTab.domain.GetCardContentUseCase
import ru.maxi.mobile.feature.newCardTab.domain.GetCardDataUseCase
import ru.maxi.mobile.feature.newCardTab.domain.LoadCardContentUseCase
import ru.maxi.mobile.feature.newCardTab.domain.MarkCardContentItemViewedUseCase
import ru.maxi.mobile.feature.newCardTab.model.CardContentBanner
import ru.maxi.mobile.feature.newCardTab.model.CardContentDiscountPackage
import ru.maxi.mobile.feature.newCardTab.model.CardContentItemIndication
import ru.maxi.mobile.feature.newCardTab.model.CardContentPrivilege
import ru.maxi.mobile.feature.newCardTab.model.NewCardContent
import ru.maxi.mobile.feature.newCardTab.model.NewCardContentBannerTransitionType
import ru.maxi.mobile.feature.newCardTab.model.NewCardContentBannerType
import ru.maxi.mobile.feature.newCardTab.model.NewCardContentDiscountPackageType
import ru.maxi.mobile.feature.newCardTab.model.NewCardContentPrivilegeType
import ru.maxi.mobile.feature.newCardTab.ui.content.model.NewCardContentNavigationEvent
import ru.maxi.mobile.feature.newCardTab.ui.content.model.NewCardViewData
import javax.inject.Inject

/**
 * [ViewModel] для экрана контента КПП V3
 */
@HiltViewModel
class NewCardContentViewModel @Inject constructor(
    cardDataUseCase: GetCardDataUseCase,
    getCardBarcodeFlow: GetClientCardBarcodeUseCase,
    getCardContent: GetCardContentUseCase,
    private val markCardContentItemViewedUseCase: MarkCardContentItemViewedUseCase,
    private val loadCardContent: LoadCardContentUseCase,
    private val authInteractor: AuthInteractor,
    private val bottomNavigationInteractor: BottomNavigationInteractor,
    private val clientBirthdayInteractor: ClientBirthdayInteractor,
    private val localCardRepository: LocalCardRepository,
    private val analyticsUseCase: AnalyticsUseCase,
    private val inMemoryCardRepository: InMemoryCardRepository,
) : ViewModel() {

    private val cardContentState: StateFlow<NewCardContent?> = getCardContent.cardContent
        .stateIn(viewModelScope, SharingStarted.Lazily, null)

    private val loadingState = MutableStateFlow<ReloadableData<Nothing?>>(ReloadableData.Loading())
    private val _navigationEvent = Channel<NewCardContentNavigationEvent>(Channel.BUFFERED)
    private val _messageEvent = Channel<String>(Channel.BUFFERED)

    /** Подписка на [Barcode] QR-кода КПП */
    val cardBarcode: Flow<Barcode> = getCardBarcodeFlow()
        .stateIn(viewModelScope, SharingStarted.Lazily, null)
        .filterNotNull()

    /** Подписка на данные КПП */
    val cardData: Flow<NewCardViewData> = cardDataUseCase.card
        .map { NewCardViewData(it.number, it.isGold(), it.changeCardStatus) }
        .stateIn(viewModelScope, SharingStarted.Lazily, null)
        .filterNotNull()

    /** События навигации экрана */
    val navigationEvent = _navigationEvent.receiveAsFlow()

    /** События сообщений **/
    val messageEvent = _messageEvent.receiveAsFlow()

    /** Состояние позиции страницы привилегий */
    val privilegePagePositionState = MutableStateFlow(0)

    /** Значение флага автояркости */
    val isAutoBrightnessEnabled: Boolean
        get() = localCardRepository.isAutoBrightnessEnabled()

    /** Состояние экрана*/
    val viewState: Flow<ReloadableData<NewCardContent>> = combine(
        loadingState.asStateFlow(),
        cardContentState.filterNotNull(),
    ) { loadingState, content ->
        loadingState.mapped { content }
    }
        .onStart { loadData() }
        .stateIn(viewModelScope, SharingStarted.Lazily, ReloadableData.Loading())

    private fun loadData() {
        viewModelScope.launch {
            try {
                Log.d("TESTING", "NEW CARD LOAD DATA")
                authInteractor.updateClientData()
                loadCardContent()
                // checkWelcomePackage()
            } catch (exception: Exception) {
                val errorMessage = (exception as? BusinessLogicException)?.message
                    ?: exception.localizedMessage
                    ?: REQUEST_ERROR_MESSAGE
                _messageEvent.send(errorMessage)
            } finally {
                loadingState.emitSuccess(null)
            }
        }
    }

    /**
     * Обновить данные экрана
     */
    fun refreshData() {
        when {
            loadingState.isLoading || loadingState.isRefreshing -> return
            loadingState.isSuccess -> loadingState.emitRefreshing()
            else -> loadingState.emitLoading()
        }

        viewModelScope.launch {
            loadData()
        }
    }

    /**
     * Обработать клик по карте
     */
    fun onCardClick() {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_OPEN_QR,
        )

        viewModelScope.launch {
            _navigationEvent.send(NewCardContentNavigationEvent.OpenQrCode)
        }
    }

    /**
     * Обработать клик по информации о карте
     */
    fun onCardInfoClick() {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_OPEN_INFO,
        )

        viewModelScope.launch {
            _navigationEvent.send(NewCardContentNavigationEvent.OpenCardInfo)
        }
    }

    /**
     * Обработать клик по истории покупок
     */
    fun onSellHistoryCardClick() {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_OPEN_SELL_HISTORY,
        )

        viewModelScope.launch {
            _navigationEvent.send(NewCardContentNavigationEvent.OpenSellHistory)
        }
    }

    /**
     * Обработать клик по баллам
     */
    fun onBonusPointsCardClick() {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_OPEN_BONUS_POINTS_BUTTON,
        )

        val bonusPointsCount = cardContentState.value?.bonusPointsCount ?: return
        viewModelScope.launch {
            val initialTab = if (bonusPointsCount > 0) {
                BonusPointsScreens.ContainerTab.BALANCE_TAB
            } else {
                BonusPointsScreens.ContainerTab.INFO_TAB
            }
            _navigationEvent.send(NewCardContentNavigationEvent.OpenBonusPoints(initialTab))
        }
    }

    /**
     * Обработать клик по фишкам
     */
    fun onChipsCardClick() {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_CHIPS_BUTTON,
        )

        val chipsCount = cardContentState.value?.chipsCount ?: return
        viewModelScope.launch {
            val initialTab = if (chipsCount > 0) {
                ChipsScreens.ContainerTab.BALANCE_TAB
            } else {
                ChipsScreens.ContainerTab.INFO_TAB
            }
            _navigationEvent.send(NewCardContentNavigationEvent.OpenChips(initialTab))
        }
    }

    /**
     * Обработать клик по привилегии с типом [type]
     */
    fun onPrivilegeClick(privilege: CardContentPrivilege) {
        viewModelScope.launch {
            try {
                markCardContentItemViewedUseCase.markPrivilege(privilege.id)
            } catch (exception: CancellationException) {
                throw exception
            } catch (ignored: Exception) {
            }

            when (privilege.type) {
                NewCardContentPrivilegeType.LOTTERY -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_LOTTERY_BUTTON,
                        itemId = privilege.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenLottery,
                    )
                }

                NewCardContentPrivilegeType.PROMO_CODE -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_PROMO_BUTTON,
                        itemId = privilege.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenOfflinePromoCodeList,
                    )
                }

                NewCardContentPrivilegeType.COUPONS -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_COUPONS_BUTTON,
                        itemId = privilege.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenCoupons,
                    )
                }

                NewCardContentPrivilegeType.MOMENT_DISCOUNT -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_MOMENT_DISCOUNT_BUTTON,
                        itemId = privilege.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenMomentDiscount,
                    )
                }

                NewCardContentPrivilegeType.CASHBACK -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_CASHBACK_BUTTON,
                        itemId = privilege.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenCashback,
                    )
                }

                NewCardContentPrivilegeType.SOON -> {
                    return@launch
                }
            }
        }
    }

    /**
     * Обновить позицию [position] страницы привилегий
     */
    fun updatePrivilegePagePosition(position: Int) {
        privilegePagePositionState.update { position }
    }

    /**
     * Обработать клик по баннеру [banner]
     */
    fun onBannerClick(banner: CardContentBanner) {
        when (banner.type) {
            is NewCardContentBannerType.Info -> {
                processBannerTransitionType(banner.type.transitionType)
            }

            is NewCardContentBannerType.AdventCalendar -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_ADVENT_CALENDAR_BANNER,
                )

                _navigationEvent.trySend(NewCardContentNavigationEvent.OpenAdventCalendar)
            }

            is NewCardContentBannerType.ScratchCards -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_SCRATCH_CARDS_BANNER,
                )

                _navigationEvent.trySend(NewCardContentNavigationEvent.OpenScratchCards)
            }

            is NewCardContentBannerType.ChipsPromo -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_CHIPS_BANNER,
                )

                val initialTab = if (cardContentState.value?.chipsCount == 0) {
                    ChipsScreens.ContainerTab.INFO_TAB
                } else {
                    ChipsScreens.ContainerTab.BALANCE_TAB
                }
                _navigationEvent.trySend(NewCardContentNavigationEvent.OpenChips(initialTab))
            }

            is NewCardContentBannerType.CouponForChips -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_COUPON_FOR_CHIPS_BANNER,
                )

                _navigationEvent.trySend(
                    NewCardContentNavigationEvent.OpenFeaturePromo(FeaturePromoType.COUPON_FOR_CHIPS),
                )
            }

            is NewCardContentBannerType.MaxiPay -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_MAXI_PAY_BANNER,
                )

                _navigationEvent.trySend(NewCardContentNavigationEvent.OpenMaxiPay)
            }

            is NewCardContentBannerType.AppUpdate -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_UPDATE_BANNER,
                )

                _navigationEvent.trySend(NewCardContentNavigationEvent.OpenMarketScreen)
            }

            is NewCardContentBannerType.DigitalReceipts -> {
                analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                    analyticType = AnalyticType.CARD_PAGE,
                    analyticAction = AnalyticNewCardActions.TAB_CARD_DIGITAL_RECEIPTS_BANNER,
                )

                _navigationEvent.trySend(NewCardContentNavigationEvent.OpenClientProfile)
            }

            is NewCardContentBannerType.GoldStatus -> return
        }
    }

    /**
     * Обработать клик по пакету скидок [discountPackage]
     */
    fun onDiscountPackageClick(discountPackage: CardContentDiscountPackage) {
        viewModelScope.launch {
            try {
                markCardContentItemViewedUseCase.markDiscountPackage(discountPackage.id)
            } catch (exception: CancellationException) {
                throw exception
            } catch (ignored: Exception) {
            }

            when (discountPackage.type) {
                NewCardContentDiscountPackageType.PARTNERS_DISCOUNTS -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_PARTNERS_DISCOUNTS,
                        itemId = discountPackage.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenPartnersDiscounts(discountPackage.id),
                    )
                }

                NewCardContentDiscountPackageType.BIRTHDAY -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_BIRTHDAY,
                        itemId = discountPackage.indication.analyticsValue,
                    )

                    val featurePromoType = if (clientBirthdayInteractor.haveBirthdayGifts()) {
                        FeaturePromoType.BIRTHDAY_GIFTS
                    } else {
                        FeaturePromoType.BIRTHDAY
                    }
                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenFeaturePromo(featurePromoType),
                    )
                }

                NewCardContentDiscountPackageType.WELCOME_PACKAGE -> {
                    analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
                        analyticType = AnalyticType.CARD_PAGE,
                        analyticAction = AnalyticNewCardActions.TAB_CARD_WELCOME_PACKAGE,
                        itemId = discountPackage.indication.analyticsValue,
                    )

                    _navigationEvent.send(
                        NewCardContentNavigationEvent.OpenFeaturePromo(
                            FeaturePromoType.WELCOME_PACKAGE,
                        ),
                    )
                }
            }
        }
    }

    /**
     * Обработать клик по кнопке получения золотой карты
     */
    fun onGetGoldCardButtonClick() {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_OPEN_CHANGE_STATUS,
        )

        viewModelScope.launch {
            _navigationEvent.send(NewCardContentNavigationEvent.OpenChangeCardStatusInfo)
        }
    }

    // private fun checkWelcomePackage() {
    //     Log.d("TESTING", "NEW CARD checkWelcomePackage")
    //     if(inMemoryCardRepository.isNeedShowWelcomePackage()) {
    //         inMemoryCardRepository.setNeedShowWelcomePackage(false)
    //         viewModelScope.launch {
    //             _navigationEvent.send(NewCardContentNavigationEvent.OpenWelcomePackagePromoDialog)
    //         }
    //     }
    // }

    private fun processBannerTransitionType(transitionType: NewCardContentBannerTransitionType?) {
        when (transitionType) {
            NewCardContentBannerTransitionType.CASHBACK -> _navigationEvent.trySend(
                NewCardContentNavigationEvent.OpenCashback,
            )

            NewCardContentBannerTransitionType.COUPONS -> _navigationEvent.trySend(
                NewCardContentNavigationEvent.OpenCoupons,
            )

            NewCardContentBannerTransitionType.PROMO_CODE -> _navigationEvent.trySend(
                NewCardContentNavigationEvent.OpenOfflinePromoCodeList,
            )

            NewCardContentBannerTransitionType.MESSAGES ->
                bottomNavigationInteractor.switchTabToRootPage(TabType.MESSAGES_TAB)

            NewCardContentBannerTransitionType.LOTTERY -> _navigationEvent.trySend(
                NewCardContentNavigationEvent.OpenLottery,
            )

            NewCardContentBannerTransitionType.MOMENT_DISCOUNT -> _navigationEvent.trySend(
                NewCardContentNavigationEvent.OpenMomentDiscount,
            )

            else -> {}
        }
    }

    /**
     * Обработать клик по клубу [club]
     */
    fun onClubClick(club: Club) {
        analyticsUseCase log AnalyticsGeneralEvent.SelectContent(
            analyticType = AnalyticType.CARD_PAGE,
            analyticAction = AnalyticNewCardActions.TAB_CARD_CLUB_LIST,
            itemId = club.id.id.toString(),
        )

        _navigationEvent.trySend(NewCardContentNavigationEvent.OpenClub(club.id))
    }

    private val CardContentItemIndication?.analyticsValue: String?
        get() = when (this) {
            null -> "no"
            is CardContentItemIndication.New -> null
            is CardContentItemIndication.Counter -> if (isViewed) "no" else "yes"
        }
}
2024-10-18 10:32:35.662 18975-18975 AndroidRuntime          today.maxi.mobile.dev                E  FATAL EXCEPTION: main
                                                                                                    Process: today.maxi.mobile.dev, PID: 18975
                                                                                                    java.lang.NoSuchMethodError: No static method -$$Nest$fgetinMemoryCardRepositoryProvider(Lru/maxi/mobile/DaggerApp_HiltComponents_SingletonC$SingletonCImpl;)Ldagger/internal/Provider; in class Lru/maxi/mobile/DaggerApp_HiltComponents_SingletonC$SingletonCImpl; or its super classes (declaration of 'ru.maxi.mobile.DaggerApp_HiltComponents_SingletonC$SingletonCImpl' appears in /data/app/today.maxi.mobile.dev-8D0i-YKgqI64kWSHj9v-cA==/base.apk!classes24.dex)
                                                                                                    	at ru.maxi.mobile.DaggerApp_HiltComponents_SingletonC$ViewModelCImpl$SwitchingProvider.get0(DaggerApp_HiltComponents_SingletonC.java:4380)
                                                                                                    	at ru.maxi.mobile.DaggerApp_HiltComponents_SingletonC$ViewModelCImpl$SwitchingProvider.get(DaggerApp_HiltComponents_SingletonC.java:4522)
                                                                                                    	at dagger.hilt.android.internal.lifecycle.HiltViewModelFactory$2.createViewModel(HiltViewModelFactory.java:132)
                                                                                                    	at dagger.hilt.android.internal.lifecycle.HiltViewModelFactory$2.create(HiltViewModelFactory.java:103)
                                                                                                    	at dagger.hilt.android.internal.lifecycle.HiltViewModelFactory.create(HiltViewModelFactory.java:170)
                                                                                                    	at androidx.lifecycle.ViewModelProvider$Factory.create(ViewModelProvider.android.kt:158)
                                                                                                    	at androidx.lifecycle.viewmodel.ViewModelProviderImpl_androidKt.createViewModel(ViewModelProviderImpl.android.kt:34)
                                                                                                    	at androidx.lifecycle.viewmodel.ViewModelProviderImpl.getViewModel$lifecycle_viewmodel_release(ViewModelProviderImpl.kt:65)
                                                                                                    	at androidx.lifecycle.viewmodel.ViewModelProviderImpl.getViewModel$lifecycle_viewmodel_release$default(ViewModelProviderImpl.kt:47)
                                                                                                    	at androidx.lifecycle.ViewModelProvider.get(ViewModelProvider.android.kt:91)
                                                                                                    	at androidx.lifecycle.ViewModelLazy.getValue(ViewModelLazy.kt:51)
                                                                                                    	at androidx.lifecycle.ViewModelLazy.getValue(ViewModelLazy.kt:35)
                                                                                                    	at ru.maxi.mobile.feature.newCardTab.ui.content.NewCardContentFragment.getViewModel(NewCardContentFragment.kt:87)
                                                                                                    	at ru.maxi.mobile.feature.newCardTab.ui.content.NewCardContentFragment.bannerSliderAdapter_delegate$lambda$0(NewCardContentFragment.kt:93)
                                                                                                    	at ru.maxi.mobile.feature.newCardTab.ui.content.NewCardContentFragment.$r8$lambda$WjIDaP2XJ9DVVY1V38AHNQeI1B0(Unknown Source:0)
                                                                                                    	at ru.maxi.mobile.feature.newCardTab.ui.content.NewCardContentFragment$$ExternalSyntheticLambda3.invoke(D8$$SyntheticClass:0)
                                                                                                    	at ru.maxi.mobile.uikit.utils.LifecycleAwareLazy.getValue(SourceFile:1)
                                                                                                    	at ru.maxi.mobile.feature.newCardTab.ui.content.NewCardContentFragment.getBannerSliderAdapter(NewCardContentFragment.kt:91)
                                                                                                    	at ru.maxi.mobile.feature.newCardTab.ui.content.NewCardContentFragment.onViewCreated(NewCardContentFragment.kt:122)
                                                                                                    	at androidx.fragment.app.Fragment.performViewCreated(Fragment.java:3152)
                                                                                                    	at androidx.fragment.app.FragmentStateManager.createView(FragmentStateManager.java:608)
                                                                                                    	at androidx.fragment.app.FragmentStateManager.moveToExpectedState(FragmentStateManager.java:286)
                                                                                                    	at androidx.fragment.app.FragmentManager.executeOpsTogether(FragmentManager.java:2164)
                                                                                                    	at androidx.fragment.app.FragmentManager.removeRedundantOperationsAndExecute(FragmentManager.java:2065)
                                                                                                    	at androidx.fragment.app.FragmentManager.execPendingActions(FragmentManager.java:2002)
                                                                                                    	at androidx.fragment.app.FragmentManager$5.run(FragmentManager.java:702)
                                                                                                    	at android.os.Handler.handleCallback(Handler.java:900)
                                                                                                    	at android.os.Handler.dispatchMessage(Handler.java:103)
                                                                                                    	at android.os.Looper.loop(Looper.java:219)
                                                                                                    	at android.app.ActivityThread.main(ActivityThread.java:8349)
                                                                                                    	at java.lang.reflect.Method.invoke(Native Method)
                                                                                                    	at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:513)
                                                                                                    	at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:1055)