[refactor] #51 네컷지도 기능 및 UI 고도화

app/src/main/java/com/neki/android/app/ui/BottomNavigationBar.kt

@@ -86,9 +86,9 @@ fun BottomNavigationBarItem(
         color = NekiTheme.colorScheme.white,
     ) {
         Column(
-            modifier = Modifier.padding(vertical = 8.dp),
+            modifier = Modifier.padding(vertical = 4.dp),
             horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(1.dp),
+            verticalArrangement = Arrangement.spacedBy(4.dp),
         ) {
             Icon(
                 modifier = Modifier.size(24.dp),
@@ -99,7 +99,7 @@ fun BottomNavigationBarItem(
             Text(
                 text = stringResource(tab.iconStringRes),
                 color = textColor,
-                style = NekiTheme.typography.caption11SemiBold,
+                style = NekiTheme.typography.caption12SemiBold,
             )
         }
     }

core/common/build.gradle.kts

@@ -10,5 +10,6 @@ android {
 dependencies {
     api(libs.timber)
     implementation(libs.androidx.security.crypto)
+    implementation(libs.androidx.core.ktx)
 
-}
+}

core/common/src/main/java/com/neki/android/core/common/permission/LocationPermissionManager.kt

@@ -0,0 +1,29 @@
+package com.neki.android.core.common.permission
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import androidx.core.content.ContextCompat
+import androidx.core.content.PermissionChecker
+
+object LocationPermissionManager {
+    val LOCATION_PERMISSIONS = arrayOf(
+        Manifest.permission.ACCESS_FINE_LOCATION,
+        Manifest.permission.ACCESS_COARSE_LOCATION,
+    )
+
+    fun hasLocationPermission(context: Context): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_FINE_LOCATION,
+        ) == PermissionChecker.PERMISSION_GRANTED ||
+            ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+            ) == PermissionChecker.PERMISSION_GRANTED
+    }
+
+    fun shouldShowLocationRationale(activity: Activity): Boolean {
+        return activity.shouldShowRequestPermissionRationale(Manifest.permission.ACCESS_FINE_LOCATION)
+    }
+}

core/common/src/main/java/com/neki/android/core/common/permission/PermissionUtils.kt

@@ -0,0 +1,13 @@
+package com.neki.android.core.common.permission
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
+
+fun navigateToAppSettings(context: Context) {
+    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+        data = Uri.fromParts("package", context.packageName, null)
+    }
+    context.startActivity(intent)
+}

core/data-api/build.gradle.kts

@@ -5,5 +5,5 @@ plugins {
 dependencies {
     implementation(projects.core.model)
     implementation(libs.kotlinx.coroutines.core)
-
+    api(libs.androidx.datastore.preferences)
 }

core/data-api/src/main/java/com/neki/android/core/dataapi/datastore/DataStoreKey.kt

@@ -0,0 +1,11 @@
+package com.neki.android.core.dataapi.datastore
+
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+
+object DataStoreKey {
+    val ACCESS_TOKEN = stringPreferencesKey("access_token")
+    val REFRESH_TOKEN = stringPreferencesKey("refresh_token")
+
+    val IS_FIRST_LOCATION_PERMISSION = booleanPreferencesKey("is_first_location_permission")
+}

core/data-api/src/main/java/com/neki/android/core/dataapi/repository/DataStoreRepository.kt

@@ -1,15 +1,9 @@
 package com.neki.android.core.dataapi.repository
 
+import androidx.datastore.preferences.core.Preferences
 import kotlinx.coroutines.flow.Flow
 
 interface DataStoreRepository {
-    suspend fun saveJwtTokens(
-        accessToken: String,
-        refreshToken: String,
-    )
-
-    fun isSavedJwtTokens(): Flow<Boolean>
-    fun getAccessToken(): Flow<String?>
-    fun getRefreshToken(): Flow<String?>
-    suspend fun clearTokens()
+    suspend fun setBoolean(key: Preferences.Key<Boolean>, value: Boolean)
+    fun getBoolean(key: Preferences.Key<Boolean>): Flow<Boolean>
 }

core/data-api/src/main/java/com/neki/android/core/dataapi/repository/TokenRepository.kt

@@ -0,0 +1,14 @@
+package com.neki.android.core.dataapi.repository
+
+import kotlinx.coroutines.flow.Flow
+
+interface TokenRepository {
+    suspend fun saveTokens(
+        accessToken: String,
+        refreshToken: String,
+    )
+    fun isSavedTokens(): Flow<Boolean>
+    fun getAccessToken(): Flow<String>
+    fun getRefreshToken(): Flow<String>
+    suspend fun clearTokens()
+}

core/data/src/main/java/com/neki/android/core/data/local/di/DataStoreModule.kt

@@ -2,33 +2,32 @@ package com.neki.android.core.data.local.di
 
 import android.content.Context
 import androidx.datastore.core.DataStore
-import androidx.datastore.core.handlers.ReplaceFileCorruptionHandler
-import androidx.datastore.preferences.core.PreferenceDataStoreFactory
 import androidx.datastore.preferences.core.Preferences
-import androidx.datastore.preferences.core.emptyPreferences
-import androidx.datastore.preferences.preferencesDataStoreFile
+import androidx.datastore.preferences.preferencesDataStore
 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
 
+private const val AUTH_DATASTORE = "auth_datastore"
+private val Context.authDataStore: DataStore<Preferences> by preferencesDataStore(name = AUTH_DATASTORE)
+
+private const val TOKEN_DATASTORE = "token_datastore"
+private val Context.tokenDataStore: DataStore<Preferences> by preferencesDataStore(name = TOKEN_DATASTORE)
+
 @InstallIn(SingletonComponent::class)
 @Module
 internal object DataStoreModule {
-    private const val DATASTORE_NAME = "neki-datastore"
 
+    @AuthDataStore
+    @Singleton
+    @Provides
+    fun provideAuthDataStore(@ApplicationContext context: Context): DataStore<Preferences> = context.authDataStore
+
+    @TokenDataStore
     @Singleton
     @Provides
-    fun provideDataStore(
-        @ApplicationContext context: Context,
-    ): DataStore<Preferences> {
-        return PreferenceDataStoreFactory.create(
-            corruptionHandler = ReplaceFileCorruptionHandler(
-                produceNewData = { emptyPreferences() },
-            ),
-            produceFile = { context.preferencesDataStoreFile(DATASTORE_NAME) },
-        )
-    }
+    fun provideTokenDataStore(@ApplicationContext context: Context): DataStore<Preferences> = context.tokenDataStore
 }

core/data/src/main/java/com/neki/android/core/data/local/di/DataStoreQualifier.kt

@@ -0,0 +1,11 @@
+package com.neki.android.core.data.local.di
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class AuthDataStore
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class TokenDataStore

core/data/src/main/java/com/neki/android/core/data/remote/di/NetworkModule.kt

@@ -8,7 +8,7 @@ import com.neki.android.core.data.remote.model.response.AuthResponse
 import com.neki.android.core.data.remote.model.response.BasicResponse
 import com.neki.android.core.data.remote.qualifier.UploadHttpClient
 import com.neki.android.core.dataapi.auth.AuthEventManager
-import com.neki.android.core.dataapi.repository.DataStoreRepository
+import com.neki.android.core.dataapi.repository.TokenRepository
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -33,7 +33,6 @@ import io.ktor.http.HttpHeaders
 import io.ktor.http.encodedPath
 import io.ktor.serialization.kotlinx.json.json
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.serialization.json.Json
 import timber.log.Timber
 import javax.inject.Singleton
@@ -46,7 +45,7 @@ internal object NetworkModule {
     const val TIME_OUT = 5000L
     const val UPLOAD_TIME_OUT = 10_000L
 
-    val sendWithoutJwtUrls = listOf(
+    val sendWithoutAuthUrls = listOf(
         "/api/auth/kakao/login",
         "/api/auth/refresh",
     )
@@ -67,7 +66,7 @@ internal object NetworkModule {
     @Provides
     @Singleton
     fun provideHttpClient(
-        dataStoreRepository: DataStoreRepository,
+        tokenRepository: TokenRepository,
         authEventManager: AuthEventManager,
     ): HttpClient {
         return HttpClient(Android) {
@@ -80,10 +79,10 @@ internal object NetworkModule {
                 bearer {
                     loadTokens {
                         Timber.d("BearerAuth - loadTokens")
-                        if (dataStoreRepository.isSavedJwtTokens().first()) {
+                        if (tokenRepository.isSavedTokens().first()) {
                             BearerTokens(
-                                accessToken = dataStoreRepository.getAccessToken().firstOrNull() ?: "",
-                                refreshToken = dataStoreRepository.getRefreshToken().firstOrNull() ?: "",
+                                accessToken = tokenRepository.getAccessToken().first(),
+                                refreshToken = tokenRepository.getRefreshToken().first(),
                             )
                         } else null
                     }
@@ -95,12 +94,12 @@ internal object NetworkModule {
                                 val response = client.post("/api/auth/refresh") {
                                     setBody(
                                         RefreshTokenRequest(
-                                            refreshToken = dataStoreRepository.getRefreshToken().firstOrNull() ?: "",
+                                            refreshToken = tokenRepository.getRefreshToken().first(),
                                         ),
                                     )
                                 }.body<BasicResponse<AuthResponse>>()
 
-                                dataStoreRepository.saveJwtTokens(
+                                tokenRepository.saveTokens(
                                     accessToken = response.data.accessToken,
                                     refreshToken = response.data.refreshToken,
                                 )
@@ -111,20 +110,20 @@ internal object NetworkModule {
                                 )
                             } catch (e: Exception) {
                                 Timber.e(e)
-                                dataStoreRepository.clearTokens()
+                                tokenRepository.clearTokens()
                                 authEventManager.emitTokenExpired()
                                 null
                             }
                         } else null
                     }
 
                     sendWithoutRequest { request ->
-                        val shouldNotJwt = sendWithoutJwtUrls.any {
+                        val shouldNotAuth = sendWithoutAuthUrls.any {
                             request.url.encodedPath == it
                         }
 
-                        Timber.d("Bearer 인증 필요 API 여부 : $shouldNotJwt")
-                        !shouldNotJwt
+                        Timber.d("Bearer 인증 필요 API 여부 : $shouldNotAuth")
+                        !shouldNotAuth
                     }
                 }
             }

core/data/src/main/java/com/neki/android/core/data/repository/di/RepositoryModule.kt

@@ -5,11 +5,13 @@ import com.neki.android.core.data.repository.impl.AuthRepositoryImpl
 import com.neki.android.core.data.repository.impl.DataStoreRepositoryImpl
 import com.neki.android.core.data.repository.impl.MediaUploadRepositoryImpl
 import com.neki.android.core.data.repository.impl.PhotoRepositoryImpl
+import com.neki.android.core.data.repository.impl.TokenRepositoryImpl
 import com.neki.android.core.dataapi.auth.AuthEventManager
 import com.neki.android.core.dataapi.repository.AuthRepository
 import com.neki.android.core.dataapi.repository.DataStoreRepository
 import com.neki.android.core.dataapi.repository.MediaUploadRepository
 import com.neki.android.core.dataapi.repository.PhotoRepository
+import com.neki.android.core.dataapi.repository.TokenRepository
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@@ -32,6 +34,12 @@ internal interface RepositoryModule {
         authRepositoryImpl: AuthRepositoryImpl,
     ): AuthRepository
 
+    @Binds
+    @Singleton
+    fun bindTokenRepositoryImpl(
+        tokenRepositoryImpl: TokenRepositoryImpl,
+    ): TokenRepository
+
     @Binds
     @Singleton
     fun bindAuthEventManagerImpl(

core/data/src/main/java/com/neki/android/core/data/repository/impl/DataStoreRepositoryImpl.kt

@@ -3,53 +3,25 @@ package com.neki.android.core.data.repository.impl
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.stringPreferencesKey
-import com.neki.android.core.common.crypto.CryptoManager
 import com.neki.android.core.dataapi.repository.DataStoreRepository
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import com.neki.android.core.data.local.di.AuthDataStore
 import javax.inject.Inject
 
 class DataStoreRepositoryImpl @Inject constructor(
-    private val dataStore: DataStore<Preferences>,
+    @AuthDataStore private val dataStore: DataStore<Preferences>,
 ) : DataStoreRepository {
-    companion object {
-        private val ACCESS_TOKEN = stringPreferencesKey("access_token")
-        private val REFRESH_TOKEN = stringPreferencesKey("refresh_token")
-    }
 
-    override suspend fun saveJwtTokens(
-        accessToken: String,
-        refreshToken: String,
-    ) {
+    override suspend fun setBoolean(key: Preferences.Key<Boolean>, value: Boolean) {
         dataStore.edit { preferences ->
-            preferences[ACCESS_TOKEN] = CryptoManager.encrypt(accessToken)
-            preferences[REFRESH_TOKEN] = CryptoManager.encrypt(refreshToken)
-        }
-    }
-
-    override fun isSavedJwtTokens(): Flow<Boolean> {
-        return dataStore.data.map { preferences ->
-            val accessToken = preferences[ACCESS_TOKEN]?.let { CryptoManager.decrypt(it) }
-            val refreshToken = preferences[REFRESH_TOKEN]?.let { CryptoManager.decrypt(it) }
-
-            !accessToken.isNullOrBlank() && !refreshToken.isNullOrBlank()
+            preferences[key] = value
         }
     }
 
-    override fun getAccessToken(): Flow<String?> {
+    override fun getBoolean(key: Preferences.Key<Boolean>): Flow<Boolean> {
         return dataStore.data.map { preferences ->
-            preferences[ACCESS_TOKEN]?.let { CryptoManager.decrypt(it) }
+            preferences[key] ?: false
         }
     }
-
-    override fun getRefreshToken(): Flow<String?> {
-        return dataStore.data.map { preferences ->
-            preferences[REFRESH_TOKEN]?.let { CryptoManager.decrypt(it) }
-        }
-    }
-
-    override suspend fun clearTokens() {
-        dataStore.edit { it.clear() }
-    }
 }