Updated on 2026-08-14

app/src/main/java/com/tangem/tap/MainActivity.kt

@@ -46,6 +46,7 @@ import com.tangem.core.ui.message.EventMessageEffect
 import com.tangem.core.ui.message.SnackbarMessage
 import com.tangem.core.ui.res.TangemColorPalette
 import com.tangem.core.ui.res.TangemTheme
+import com.tangem.data.balancehiding.DefaultDeviceFlipDetector
 import com.tangem.data.card.sdk.CardSdkOwner
 import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.card.ScanCardUseCase
@@ -205,6 +206,9 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
     @Inject
     internal lateinit var uiDependencies: UiDependencies
 
+    @Inject
+    internal lateinit var defaultDeviceFlipDetector: DefaultDeviceFlipDetector
+
     internal val viewModel: MainViewModel by viewModels()
 
     private lateinit var appThemeModeFlow: SharedFlow<AppThemeMode>
@@ -271,6 +275,7 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         }
 
         lifecycle.addObserver(WindowObscurationObserver)
+        lifecycle.addObserver(defaultDeviceFlipDetector)
     }
 
     private fun installEventMessageEffect() {

data/balance-hiding/build.gradle.kts

@@ -12,6 +12,7 @@ android {
 
 dependencies {
     implementation(deps.androidx.datastore)
+    implementation(deps.androidx.appCompat)
 
     /** DI */
     implementation(deps.hilt.android)

data/balance-hiding/src/main/java/com/tangem/data/balancehiding/DefaultBalanceHidingRepository.kt

@@ -8,8 +8,11 @@ import com.tangem.datasource.local.preferences.utils.storeObject
 import com.tangem.domain.balancehiding.BalanceHidingSettings
 import com.tangem.domain.balancehiding.repositories.BalanceHidingRepository
 import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+import javax.inject.Singleton
 
-internal class DefaultBalanceHidingRepository(
+@Singleton
+internal class DefaultBalanceHidingRepository @Inject constructor(
     private val appPreferencesStore: AppPreferencesStore,
 ) : BalanceHidingRepository {
 

data/balance-hiding/src/main/java/com/tangem/data/balancehiding/DefaultDeviceFlipDetector.kt

@@ -3,18 +3,40 @@ package com.tangem.data.balancehiding
 import android.content.Context
 import android.hardware.Sensor
 import android.hardware.SensorManager
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
 import com.tangem.domain.balancehiding.DeviceFlipDetector
+import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
+import java.util.concurrent.atomic.AtomicBoolean
+import javax.inject.Inject
+import javax.inject.Singleton
 
-internal class DefaultDeviceFlipDetector(context: Context) : DeviceFlipDetector {
+@Singleton
+class DefaultDeviceFlipDetector @Inject constructor(
+    @ApplicationContext context: Context,
+) : DeviceFlipDetector, DefaultLifecycleObserver {
 
     private val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
     private var gravitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)
+    private var isResumedState = AtomicBoolean(false)
+
+    override fun onPause(owner: LifecycleOwner) {
+        isResumedState.set(false)
+    }
+
+    override fun onResume(owner: LifecycleOwner) {
+        isResumedState.set(true)
+    }
 
     override fun getDeviceFlipFlow(): Flow<Unit> = callbackFlow {
-        val listener = FlipListener { trySend(Unit) }
+        val listener = FlipListener {
+            if (isResumedState.get()) {
+                trySend(Unit)
+            }
+        }
 
         gravitySensor?.let {
             sensorManager.registerListener(listener, it, SensorManager.SENSOR_DELAY_NORMAL)

data/balance-hiding/src/main/java/com/tangem/data/balancehiding/di/BalanceHidingModule.kt

@@ -1,31 +1,24 @@
 package com.tangem.data.balancehiding.di
 
-import android.content.Context
 import com.tangem.data.balancehiding.DefaultBalanceHidingRepository
 import com.tangem.data.balancehiding.DefaultDeviceFlipDetector
-import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.domain.balancehiding.DeviceFlipDetector
 import com.tangem.domain.balancehiding.repositories.BalanceHidingRepository
+import dagger.Binds
 import dagger.Module
-import dagger.Provides
 import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
-internal object BalanceHidingModule {
+internal interface BalanceHidingModule {
 
-    @Provides
+    @Binds
     @Singleton
-    fun provideBalanceHidingRepository(appPreferencesStore: AppPreferencesStore): BalanceHidingRepository {
-        return DefaultBalanceHidingRepository(appPreferencesStore = appPreferencesStore)
-    }
+    fun provideBalanceHidingRepository(impl: DefaultBalanceHidingRepository): BalanceHidingRepository
 
-    @Provides
+    @Binds
     @Singleton
-    fun provideFlipDetector(@ApplicationContext context: Context): DeviceFlipDetector {
-        return DefaultDeviceFlipDetector(context = context)
-    }
+    fun provideFlipDetector(impl: DefaultDeviceFlipDetector): DeviceFlipDetector
 }