[GMSS-101] feat: 위험 표현 감지 및 상담 기관 안내

app/build.gradle.kts

@@ -72,6 +72,8 @@ dependencies {
     implementation(libs.orbit.viewmodel)
     implementation(libs.orbit.compose)
 
+    implementation(libs.kotlinx.coroutines.android)
+
     implementation(platform(libs.firebase.bom))
     implementation(libs.firebase.crashlytics)
     implementation(libs.firebase.analytics)

app/src/main/AndroidManifest.xml

@@ -3,6 +3,13 @@
 
     <uses-permission android:name="android.permission.INTERNET"/>
 
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.DIAL" />
+            <data android:scheme="tel" />
+        </intent>
+    </queries>
+
     <application
         android:name=".GamssApplication"
         android:allowBackup="true"

app/src/main/kotlin/com/gamss/android/app/GamssApplication.kt

@@ -1,7 +1,33 @@
 package com.gamss.android.app
 
 import android.app.Application
+import android.util.Log
+import com.gamss.android.domain.safety.RefreshRiskLexiconUseCase
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+private const val TAG = "GamssApplication"
 
 @HiltAndroidApp
-class GamssApplication : Application()
+class GamssApplication : Application() {
+
+    @Inject
+    lateinit var refreshRiskLexicon: RefreshRiskLexiconUseCase
+
+    private val applicationScope = CoroutineScope(
+        SupervisorJob() + Dispatchers.IO +
+            CoroutineExceptionHandler { _, throwable ->
+                Log.w(TAG, "application scope task failed", throwable)
+            },
+    )
+
+    override fun onCreate() {
+        super.onCreate()
+        applicationScope.launch { refreshRiskLexicon() }
+    }
+}

data/build.gradle.kts

@@ -61,6 +61,7 @@ dependencies {
 
     implementation(platform(libs.firebase.bom))
     implementation(libs.firebase.auth)
+    implementation(libs.firebase.firestore)
     implementation(libs.kotlinx.coroutines.play.services)
 
     testImplementation(libs.junit)

data/src/main/assets/risk_lexicon.json

@@ -0,0 +1,103 @@
+{
+  "version": 3,
+  "terms": [
+    { "term": "차라리죽", "level": "CRITICAL" },
+    { "term": "죽어야편", "level": "CRITICAL" },
+    { "term": "죽는게답", "level": "CRITICAL" },
+    { "term": "다끝내버리고싶", "level": "CRITICAL" },
+    { "term": "죽었으면좋겠", "level": "WARNING" },
+    { "term": "나만없으면", "level": "WARNING" },
+    { "term": "태어나지말았", "level": "WARNING" },
+    { "term": "살아있을이유", "level": "WARNING" },
+    { "term": "없어지는게낫", "level": "WARNING" },
+    { "term": "죽을거야", "level": "CRITICAL" },
+    { "term": "죽을게", "level": "CRITICAL" },
+    { "term": "죽을래", "level": "CRITICAL" },
+    { "term": "죽어버릴", "level": "CRITICAL" },
+    { "term": "죽어야지", "level": "CRITICAL" },
+    { "term": "죽고말", "level": "CRITICAL" },
+    { "term": "죽는게낫", "level": "CRITICAL" },
+    { "term": "죽으면좋겠", "level": "CRITICAL" },
+    { "term": "죽는수밖에", "level": "CRITICAL" },
+    { "term": "자살", "level": "CRITICAL" },
+    { "term": "자살방법", "level": "CRITICAL" },
+    { "term": "죽는방법", "level": "CRITICAL" },
+    { "term": "죽고싶", "level": "CRITICAL" },
+    { "term": "죽어버리", "level": "CRITICAL" },
+    { "term": "죽어야겠", "level": "CRITICAL" },
+    { "term": "자해", "level": "CRITICAL" },
+    { "term": "손목그", "level": "CRITICAL" },
+    { "term": "목매달", "level": "CRITICAL" },
+    { "term": "목을매", "level": "CRITICAL" },
+    { "term": "극단적선택", "level": "CRITICAL" },
+    { "term": "살고싶지않", "level": "CRITICAL" },
+    { "term": "유서를", "level": "CRITICAL" },
+    { "term": "유서써", "level": "CRITICAL" },
+    { "term": "유서남", "level": "CRITICAL" },
+    { "term": "번개탄", "level": "WARNING" },
+    { "term": "사라지고싶", "level": "WARNING" },
+    { "term": "없어지고싶", "level": "WARNING" },
+    { "term": "살기싫", "level": "WARNING" },
+    { "term": "살아갈이유", "level": "WARNING" },
+    { "term": "다포기하고싶", "level": "WARNING" },
+    { "term": "아무도날필요", "level": "WARNING" },
+    { "term": "혼자남겨진것같", "level": "WARNING" }
+  ],
+  "safePhrases": [
+    "죽을것같",
+    "죽을거같",
+    "죽을뻔",
+    "죽을각오",
+    "죽을힘",
+    "죽을죄",
+    "너죽을래",
+    "죽을때까지",
+    "죽을고생",
+    "죽고싶지않",
+    "자살예방",
+    "자살률",
+    "자살골",
+    "자살패스",
+    "유서깊",
+    "배고파죽",
+    "웃겨죽",
+    "좋아죽",
+    "귀여워죽",
+    "더워죽",
+    "추워죽",
+    "졸려죽",
+    "힘들어죽",
+    "심심해죽",
+    "죽을맛",
+    "죽을만큼",
+    "죽도록",
+    "죽여주는",
+    "자해공갈"
+  ],
+  "agencies": [
+    {
+      "id": "kr-109",
+      "name": "자살예방 상담전화",
+      "description": "24시간 무료 전문 상담",
+      "phoneNumber": "109",
+      "url": null,
+      "priority": 1
+    },
+    {
+      "id": "kr-mental-health",
+      "name": "정신건강 상담전화",
+      "description": "정신건강 위기 상담",
+      "phoneNumber": "1577-0199",
+      "url": null,
+      "priority": 2
+    },
+    {
+      "id": "kr-youth",
+      "name": "청소년 상담전화",
+      "description": "청소년 전문 상담",
+      "phoneNumber": "1388",
+      "url": null,
+      "priority": 3
+    }
+  ]
+}

data/src/main/java/com/gamss/android/data/di/FirebaseModule.kt

@@ -3,6 +3,8 @@ package com.gamss.android.data.di
 import com.google.firebase.Firebase
 import com.google.firebase.auth.FirebaseAuth
 import com.google.firebase.auth.auth
+import com.google.firebase.firestore.FirebaseFirestore
+import com.google.firebase.firestore.firestore
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -15,4 +17,8 @@ internal object FirebaseModule {
     @Provides
     @Singleton
     fun provideFirebaseAuth(): FirebaseAuth = Firebase.auth
+
+    @Provides
+    @Singleton
+    fun provideFirebaseFirestore(): FirebaseFirestore = Firebase.firestore
 }

data/src/main/java/com/gamss/android/data/di/SafetyModule.kt

@@ -0,0 +1,40 @@
+package com.gamss.android.data.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import com.gamss.android.data.safety.RiskLexiconDataStore
+import com.gamss.android.data.safety.RiskLexiconRepositoryImpl
+import com.gamss.android.domain.safety.RiskLexiconRepository
+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 abstract class SafetyModule {
+
+    @Binds
+    abstract fun bindRiskLexiconRepository(
+        riskLexiconRepositoryImpl: RiskLexiconRepositoryImpl,
+    ): RiskLexiconRepository
+
+    companion object {
+        @Provides
+        @Singleton
+        @RiskLexiconDataStore
+        fun provideRiskLexiconDataStore(
+            @ApplicationContext context: Context,
+        ): DataStore<Preferences> = PreferenceDataStoreFactory.create(
+            produceFile = { context.preferencesDataStoreFile(RISK_LEXICON_DATA_STORE_NAME) },
+        )
+
+        private const val RISK_LEXICON_DATA_STORE_NAME = "risk_lexicon"
+    }
+}

data/src/main/java/com/gamss/android/data/safety/BundledRiskLexiconDataSource.kt

@@ -0,0 +1,26 @@
+package com.gamss.android.data.safety
+
+import android.content.Context
+import com.gamss.android.data.safety.model.RiskLexiconDto
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class BundledRiskLexiconDataSource @Inject constructor(
+    @param:ApplicationContext private val context: Context,
+    private val json: Json,
+) {
+    suspend fun load(): RiskLexiconDto = withContext(Dispatchers.IO) {
+        context.assets.open(ASSET_NAME).bufferedReader().use { reader ->
+            json.decodeFromString<RiskLexiconDto>(reader.readText())
+        }
+    }
+
+    private companion object {
+        const val ASSET_NAME = "risk_lexicon.json"
+    }
+}

data/src/main/java/com/gamss/android/data/safety/FirestoreRiskLexiconDataSource.kt

@@ -0,0 +1,66 @@
+package com.gamss.android.data.safety
+
+import com.gamss.android.data.safety.model.RiskLexiconDto
+import com.gamss.android.data.safety.model.RiskTermDto
+import com.gamss.android.data.safety.model.SupportAgencyDto
+import com.google.firebase.firestore.DocumentSnapshot
+import com.google.firebase.firestore.FirebaseFirestore
+import kotlinx.coroutines.tasks.await
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+
+@Singleton
+internal class FirestoreRiskLexiconDataSource @Inject constructor(
+    private val firestoreProvider: Provider<FirebaseFirestore>,
+) {
+    suspend fun fetch(): RiskLexiconDto? =
+        firestoreProvider.get()
+            .collection(COLLECTION)
+            .document(DOCUMENT)
+            .get()
+            .await()
+            .takeIf { it.exists() }
+            ?.toDto()
+
+    private fun DocumentSnapshot.toDto(): RiskLexiconDto = RiskLexiconDto(
+        version = getLong(FIELD_VERSION)?.toInt() ?: 0,
+        terms = objectList(FIELD_TERMS).map {
+            RiskTermDto(term = it.string(FIELD_TERM), level = it.string(FIELD_LEVEL))
+        },
+        safePhrases = (get(FIELD_SAFE_PHRASES) as? List<*>).orEmpty().filterIsInstance<String>(),
+        agencies = objectList(FIELD_AGENCIES).map {
+            SupportAgencyDto(
+                id = it.string(FIELD_ID),
+                name = it.string(FIELD_NAME),
+                description = it.string(FIELD_DESCRIPTION),
+                phoneNumber = it[FIELD_PHONE_NUMBER] as? String,
+                url = it[FIELD_URL] as? String,
+                priority = (it[FIELD_PRIORITY] as? Number)?.toInt() ?: Int.MAX_VALUE,
+            )
+        },
+    )
+
+    private fun DocumentSnapshot.objectList(field: String): List<Map<*, *>> =
+        (get(field) as? List<*>).orEmpty().filterIsInstance<Map<*, *>>()
+
+    private fun Map<*, *>.string(key: String): String = (this[key] as? String).orEmpty()
+
+    private companion object {
+        const val COLLECTION = "app_config"
+        const val DOCUMENT = "risk_lexicon"
+
+        const val FIELD_VERSION = "version"
+        const val FIELD_TERMS = "terms"
+        const val FIELD_SAFE_PHRASES = "safePhrases"
+        const val FIELD_AGENCIES = "agencies"
+        const val FIELD_TERM = "term"
+        const val FIELD_LEVEL = "level"
+        const val FIELD_ID = "id"
+        const val FIELD_NAME = "name"
+        const val FIELD_DESCRIPTION = "description"
+        const val FIELD_PHONE_NUMBER = "phoneNumber"
+        const val FIELD_URL = "url"
+        const val FIELD_PRIORITY = "priority"
+    }
+}

data/src/main/java/com/gamss/android/data/safety/RiskLexiconDataStore.kt

@@ -0,0 +1,7 @@
+package com.gamss.android.data.safety
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+internal annotation class RiskLexiconDataStore

data/src/main/java/com/gamss/android/data/safety/RiskLexiconLocalDataSource.kt

@@ -0,0 +1,49 @@
+package com.gamss.android.data.safety
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.longPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+internal data class CachedRiskLexicon(
+    val json: String,
+    val fetchedAtMillis: Long,
+)
+
+@Singleton
+internal class RiskLexiconLocalDataSource @Inject constructor(
+    @param:RiskLexiconDataStore private val dataStore: DataStore<Preferences>,
+) {
+    suspend fun read(): CachedRiskLexicon? = withContext(Dispatchers.IO) {
+        val preferences = dataStore.data.first()
+        val json = preferences[LEXICON_JSON_KEY] ?: return@withContext null
+        CachedRiskLexicon(
+            json = json,
+            fetchedAtMillis = preferences[FETCHED_AT_KEY] ?: 0L,
+        )
+    }
+
+    suspend fun write(json: String, fetchedAtMillis: Long): Unit = withContext(Dispatchers.IO) {
+        dataStore.edit { preferences ->
+            preferences[LEXICON_JSON_KEY] = json
+            preferences[FETCHED_AT_KEY] = fetchedAtMillis
+        }
+    }
+
+    suspend fun markFetched(fetchedAtMillis: Long): Unit = withContext(Dispatchers.IO) {
+        dataStore.edit { preferences ->
+            preferences[FETCHED_AT_KEY] = fetchedAtMillis
+        }
+    }
+
+    private companion object {
+        val LEXICON_JSON_KEY = stringPreferencesKey("risk_lexicon_json")
+        val FETCHED_AT_KEY = longPreferencesKey("risk_lexicon_fetched_at")
+    }
+}