feature: 홈 채팅 구현

app/build.gradle.kts

@@ -3,6 +3,7 @@ import com.teamoffroad.app.setNamespace
 
 plugins {
     id("offroad.android.application")
+    alias(libs.plugins.google.services)
 }
 
 android {
@@ -55,4 +56,7 @@ dependencies {
     implementation(project(":feature:mypage"))
     implementation(project(":feature:characterchat"))
     implementation(libs.kakao.user)
+    implementation(libs.coil)
+    implementation(libs.bundles.firebase)
+    implementation(platform(libs.firebase.bom))
 }

app/src/main/AndroidManifest.xml

@@ -10,6 +10,7 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
 
     <application
         android:name=".OffroadApplication"
@@ -24,7 +25,13 @@
         android:theme="@style/Theme.Offroad"
         android:usesCleartextTraffic="true"
         tools:targetApi="31">
-
+        <service
+            android:name=".OffRoadMessagingService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
         <meta-data
             android:name="com.naver.maps.map.CLIENT_ID"
             android:value="${NAVER_CLIENT_ID}" />
@@ -55,5 +62,10 @@
             </intent-filter>
 
         </activity>
+        <receiver android:name="com.teamoffroad.feature.main.CharacterChatBroadcastReceiver">
+            <intent-filter>
+                <action android:name="com.teamoffroad.offroad.app.ACTION_RECEIVE_NOTIFICATION" />
+            </intent-filter>
+        </receiver>
     </application>
 </manifest>

app/src/main/java/com/teamoffroad/offroad.app/OffRoadMessagingService.kt

@@ -0,0 +1,199 @@
+package com.teamoffroad.offroad.app
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.BitmapDrawable
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import coil.Coil
+import coil.request.ImageRequest
+import com.google.firebase.messaging.Constants.MessageNotificationKeys
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.CHANNEL_ID
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.KEY_BODY
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.KEY_ID
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.KEY_IMAGE
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.KEY_TITLE
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.KEY_TYPE
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.NOTICE
+import com.teamoffroad.core.common.domain.model.FcmNotificationKey.TYPE_CHARACTER_CHAT
+import com.teamoffroad.core.common.domain.repository.DeviceTokenRepository
+import com.teamoffroad.core.common.util.ActivityLifecycleHandler
+import com.teamoffroad.feature.main.MainActivity
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class OffRoadMessagingService : FirebaseMessagingService() {
+    @Inject
+    lateinit var dataStore: DeviceTokenRepository
+
+    override fun onNewToken(token: String) {
+        super.onNewToken(token)
+
+        CoroutineScope(Dispatchers.IO).launch { dataStore.updateDeviceTokenEnabled(token) }
+    }
+
+    //FCM 메세지를 받을 때 호출됨
+    override fun onMessageReceived(remoteMessage: RemoteMessage) {
+        super.onMessageReceived(remoteMessage)
+        if (remoteMessage.data.isNotEmpty()) {
+            if (ActivityLifecycleHandler.isAppInForeground) {
+                if (remoteMessage.data[KEY_TYPE] != TYPE_CHARACTER_CHAT)
+                    sendNotification(remoteMessage, true)
+                else {
+                    // 앱이 포그라운드에 있고, 알림타임이 캐릭터채팅인 경우
+                    // 정현이 봐야할곳은 여기!! 요쪽 따라가십쇼
+                    sendCharacterChatNotificationInForeground(remoteMessage)
+                }
+            } else {
+                sendNotification(remoteMessage, false)
+            }
+        }
+    }
+
+    override fun handleIntent(intent: Intent?) {
+        val new = intent?.apply {
+            val temp = extras?.apply {
+                remove(MessageNotificationKeys.ENABLE_NOTIFICATION)
+                remove(keyWithOldPrefix())
+            }
+            replaceExtras(temp)
+        }
+        super.handleIntent(new)
+    }
+
+    private fun keyWithOldPrefix(): String {
+        if (!MessageNotificationKeys.ENABLE_NOTIFICATION.startsWith(MessageNotificationKeys.NOTIFICATION_PREFIX)) {
+            return MessageNotificationKeys.ENABLE_NOTIFICATION
+        }
+
+        return MessageNotificationKeys.ENABLE_NOTIFICATION.replace(
+            MessageNotificationKeys.NOTIFICATION_PREFIX,
+            MessageNotificationKeys.NOTIFICATION_PREFIX_OLD
+        )
+    }
+
+    private fun generateUniqueIdentifier(): Int {
+        return (System.currentTimeMillis() / 7).toInt()
+    }
+
+    private fun createPendingIntent(intent: Intent, uniqueIdentifier: Int): PendingIntent {
+        return PendingIntent.getActivity(
+            this,
+            uniqueIdentifier,
+            intent,
+            PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    private fun createNotificationIntent(
+        remoteMessage: RemoteMessage,
+        isForeGround: Boolean
+    ): Intent {
+        return Intent(this, MainActivity::class.java).apply {
+                flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK
+                putExtra(KEY_TYPE, remoteMessage.data[KEY_TYPE])
+                if (remoteMessage.data[KEY_TYPE] != TYPE_CHARACTER_CHAT) {
+                    putExtra(KEY_ID, remoteMessage.data[KEY_ID])
+
+            }
+        }
+    }
+
+    private fun createNotificationBuilder(
+        remoteMessage: RemoteMessage,
+        pendingIntent: PendingIntent,
+        onLargeIconReady: (NotificationCompat.Builder) -> Unit
+    ): NotificationCompat.Builder {
+
+        val notificationBuilder = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentTitle(remoteMessage.data[KEY_TITLE])
+            .setContentText(remoteMessage.data[KEY_BODY])
+            .setAutoCancel(true)
+            .setContentIntent(pendingIntent)
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+
+        val imageUrl = remoteMessage.data[KEY_IMAGE]
+        imageUrl?.let {
+            val request = ImageRequest.Builder(this)
+                .data(it)
+                .target { drawable ->
+                    val bitmap = (drawable as BitmapDrawable).bitmap
+                    notificationBuilder.setLargeIcon(bitmap)
+                    onLargeIconReady(notificationBuilder)
+                }
+                .build()
+
+            Coil.imageLoader(this).enqueue(request)
+        } ?: run {
+            onLargeIconReady(notificationBuilder)
+        }
+        return notificationBuilder
+    }
+
+    private fun sendNotification(remoteMessage: RemoteMessage, isForeGround: Boolean) {
+        if (!isForeGround) {
+            val uniqueIdentifier = generateUniqueIdentifier()
+            val intent = createNotificationIntent(remoteMessage, isForeGround)
+            val pendingIntent = createPendingIntent(intent, uniqueIdentifier)
+            createNotificationBuilder(remoteMessage, pendingIntent) { notificationBuilder ->
+                showNotification(notificationBuilder, uniqueIdentifier)
+            }
+        } else {
+            val uniqueIdentifier = generateUniqueIdentifier()
+            val broadCastIntent =
+                Intent("com.teamoffroad.offroad.app.ANNOUNCEMENT_FOREGROUND").apply {
+                    putExtra(KEY_TITLE, remoteMessage.data[KEY_TITLE])
+                    putExtra(KEY_ID, remoteMessage.data[KEY_ID])
+                }
+            val pendingIntent = PendingIntent.getBroadcast(
+                this,
+                0,
+                broadCastIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE // FLAG_IMMUTABLE 추가
+            )
+            createNotificationBuilder(remoteMessage, pendingIntent) { notificationBuilder ->
+                showNotification(notificationBuilder, uniqueIdentifier)
+            }
+        }
+    }
+
+    //브로드캐스트리시버에 필요한 데이터(캐릭터이름, 대화내용, 알림타입) 저장하고 브로드캐스트 발신
+    //feature main의 CharacterChatBroadcastReceiver로 가면 됩니다.
+    private fun sendCharacterChatNotificationInForeground(
+        remoteMessage: RemoteMessage,
+    ) {
+        val broadCastIntent =
+            Intent("com.teamoffroad.offroad.app.CHARACTER_CHAT_FOREGROUND").apply {
+                putExtra(KEY_TITLE, remoteMessage.data[KEY_TITLE])
+                putExtra(KEY_BODY, remoteMessage.data[KEY_BODY])
+                putExtra(KEY_TYPE, remoteMessage.data[KEY_TYPE])
+            }
+        sendBroadcast(broadCastIntent)
+    }
+
+    private fun showNotification(
+        notificationBuilder: NotificationCompat.Builder,
+        uniqueIdentifier: Int
+    ) {
+        val notificationManager =
+            getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel =
+                NotificationChannel(CHANNEL_ID, NOTICE, NotificationManager.IMPORTANCE_HIGH)
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        notificationManager.notify(uniqueIdentifier, notificationBuilder.build())
+    }
+}

app/src/main/java/com/teamoffroad/offroad.app/OffroadApplication.kt

@@ -2,13 +2,15 @@ package com.teamoffroad.offroad.app
 
 import android.app.Application
 import com.kakao.sdk.common.KakaoSdk
+import com.teamoffroad.core.common.util.ActivityLifecycleHandler
 import dagger.hilt.android.HiltAndroidApp
 
 @HiltAndroidApp
 class OffroadApplication : Application(){
     override fun onCreate() {
         super.onCreate()
         setKakaoSdk()
+        registerActivityLifecycleCallbacks(ActivityLifecycleHandler())
     }
 
     private fun setKakaoSdk() {

build.gradle.kts

@@ -6,4 +6,5 @@ plugins {
     alias(libs.plugins.android.library) apply false
     alias(libs.plugins.daggers.hilt) apply false
     alias(libs.plugins.ksp) apply false
+    alias(libs.plugins.google.services) apply false
 }

core/common/src/main/java/com/teamoffroad/core/common/data/datasource/AutoSignInPreferencesDataSource.kt

@@ -4,6 +4,5 @@ import kotlinx.coroutines.flow.Flow
 
 interface AutoSignInPreferencesDataSource {
     val autoLogin: Flow<Boolean>
-
     suspend fun setAutoLogin(autoLogin: Boolean)
 }

core/common/src/main/java/com/teamoffroad/core/common/data/datasource/DefaultDeviceTokenPreferencesDataSource.kt

@@ -0,0 +1,28 @@
+package com.teamoffroad.core.common.data.datasource
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+
+class DefaultDeviceTokenPreferencesDataSource @Inject constructor(
+    private val dataStore: DataStore<Preferences>,
+) : DeviceTokenPreferencesDataSource {
+
+    object PreferencesKey {
+        val DEVICE_TOKEN_KEY = stringPreferencesKey("DEVICE_TOKEN_KEY")
+    }
+
+    override val deviceToken: Flow<String> = dataStore.data.map { preferences ->
+        preferences[PreferencesKey.DEVICE_TOKEN_KEY].orEmpty()
+    }
+
+    override suspend fun setDeviceToken(deviceToken: String) {
+        dataStore.edit { preferences ->
+            preferences[PreferencesKey.DEVICE_TOKEN_KEY] = deviceToken
+        }
+    }
+}

core/common/src/main/java/com/teamoffroad/core/common/data/datasource/DeviceTokenPreferencesDataSource.kt

@@ -0,0 +1,8 @@
+package com.teamoffroad.core.common.data.datasource
+
+import kotlinx.coroutines.flow.Flow
+
+interface DeviceTokenPreferencesDataSource {
+    val deviceToken: Flow<String>
+    suspend fun setDeviceToken(deviceToken: String)
+}

core/common/src/main/java/com/teamoffroad/core/common/data/di/DataModule.kt

@@ -2,7 +2,9 @@ package com.teamoffroad.core.common.data.di
 
 import com.teamoffroad.core.common.data.datasource.AutoSignInPreferencesDataSource
 import com.teamoffroad.core.common.data.datasource.DefaultAutoSignInPreferencesDataSource
+import com.teamoffroad.core.common.data.datasource.DefaultDeviceTokenPreferencesDataSource
 import com.teamoffroad.core.common.data.datasource.DefaultTokenPreferencesDataSource
+import com.teamoffroad.core.common.data.datasource.DeviceTokenPreferencesDataSource
 import com.teamoffroad.core.common.data.datasource.TokenPreferencesDataSource
 import dagger.Binds
 import dagger.Module
@@ -22,4 +24,9 @@ internal abstract class DataModule {
     abstract fun bindsAutoSignInLocalDataSource(
         dataSource: DefaultAutoSignInPreferencesDataSource,
     ): AutoSignInPreferencesDataSource
+
+    @Binds
+    abstract fun bindsDeviceTokenLocalDataSource(
+        dataSource: DefaultDeviceTokenPreferencesDataSource,
+    ): DeviceTokenPreferencesDataSource
 }

core/common/src/main/java/com/teamoffroad/core/common/data/di/DataStoreModule.kt

@@ -44,6 +44,13 @@ object DataStoreModule {
         return context.createDataStore(AUTH_PREFERENCES)
     }
 
+    @Provides
+    @Singleton
+    fun provideDeviceTokenDataStore(@ApplicationContext context: Context): DataStore<Preferences> {
+        return context.createDataStore(DEVICE_TOKEN_PREFERENCES)
+    }
+
     private const val TOKEN_PREFERENCES = "com.teamoffroad.token_preferences"
     private const val AUTH_PREFERENCES = "com.teamoffroad.auth_preferences"
+    private const val DEVICE_TOKEN_PREFERENCES = "com.teamoffroad.device_token_preferences"
 }

core/common/src/main/java/com/teamoffroad/core/common/data/di/RepositoryModule.kt

@@ -1,8 +1,10 @@
 package com.teamoffroad.core.common.data.di
 
 import com.teamoffroad.core.common.data.repository.AutoSignInRepositoryImpl
+import com.teamoffroad.core.common.data.repository.DeviceTokenRepositoryImpl
 import com.teamoffroad.core.common.data.repository.TokenRepositoryImpl
 import com.teamoffroad.core.common.domain.repository.AutoSignInRepository
+import com.teamoffroad.core.common.domain.repository.DeviceTokenRepository
 import com.teamoffroad.core.common.domain.repository.TokenRepository
 import dagger.Binds
 import dagger.Module
@@ -24,4 +26,10 @@ abstract class RepositoryModule {
     abstract fun bindAutoSignInRepository(
         authRepositoryImpl: AutoSignInRepositoryImpl,
     ): AutoSignInRepository
+
+    @Binds
+    @Singleton
+    abstract fun bindDeviceTokenRepository(
+        deviceTokenRepositoryImpl: DeviceTokenRepositoryImpl
+    ): DeviceTokenRepository
 }