Save FCM data in Room when app in background or kill

I am trying to save FCM data in Room Database but its works only app in forgroung. when app in background or killed, notification cames but not save in database.

I see many article on that but not works

My NotificationService class:

class NotificationService : FirebaseMessagingService() {

    override fun onNewToken(p0: String) {
        super.onNewToken(p0)
    }

    companion object {
        private const val NOTIFICATION_CHANNEL_ID = "Channel 1"
        private const val NOTIFICATION_ID = 100
    }

    override fun onMessageReceived(p0: RemoteMessage) {
        super.onMessageReceived(p0)

        if (p0.data.size > 0){
            val param: Map<String, String> = p0.data

            sendNotification(param)
            broadcastNotification()
        }
    }

    private fun sendNotification(param: Map<String, String>) {

        val db = AppDatabase.getInstance(applicationContext)

        val notificationEntity = NotificationEntity(null,param["title"], param["body"])
            db.notificationDao().addNotification(notificationEntity)
        
        val intent = Intent(this, MainActivity::class.java)
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)

        intent.putExtra("postId", param["postId"])

        val image = ImageRequest.Builder(applicationContext)
            .data(param["img-url"])
            .build()
        imageLoader.enqueue(image)
        val bitmap = param["img-url"]?.let { getBitmapFromUrl(it) }

        val pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_ONE_SHOT)


        val sound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM)
        val notificationManager: NotificationManager =
            getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        val notifiBuilder = NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
            .setSmallIcon(R.mipmap.ic_launcher_foreground)
            .setStyle(
                NotificationCompat.BigPictureStyle()
                    .bigPicture(bitmap)
                    .bigLargeIcon(null)
            ).setLargeIcon(bitmap)
            .setContentTitle(param["title"])
            .setContentText(param["body"])
            .setAutoCancel(true)
            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
            .setSound(sound)
            .setPriority(NotificationManagerCompat.IMPORTANCE_MAX)
            .setContentIntent(pendingIntent)

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                NOTIFICATION_CHANNEL_ID,
                "Channel human readable title",
                NotificationManager.IMPORTANCE_HIGH
            )
            notificationManager.createNotificationChannel(channel)
        }
        notificationManager.notify(NOTIFICATION_ID, notifiBuilder.build())
    }


    private fun getBitmapFromUrl(url: String): Bitmap? {
        try {
            val url: URL = URL(url)
            val connection: HttpURLConnection = url.openConnection() as HttpURLConnection
            connection.doInput = true
            connection.connect()
            val input: InputStream = connection.inputStream
            return BitmapFactory.decodeStream(input)
        } catch (e: Exception) {
            return null
        }

    }

    private fun broadcastNotification(){
        val intnet = Intent("new_notification")
        LocalBroadcastManager.getInstance(this).sendBroadcast(intnet)
    }
}

NotificationDao Class for inserting data in database

@Dao
interface NotificationDao {

    @Insert
    fun addNotification(notificationEntity: NotificationEntity)

    @Query("SELECT * FROM notification_data")
    fun getPostList(): List<NotificationEntity>

}

Database Class for creating instance of database

@Database(entities = [PostEntity::class, NotificationEntity::class], version = 1, exportSchema = false)
abstract class AppDatabase: RoomDatabase() {

    abstract fun postDao(): PostDao
    abstract fun notificationDao(): NotificationDao

    companion object {
        private var INSTANCE: AppDatabase?= null

        fun getInstance(context: Context): AppDatabase {
            if (INSTANCE == null){
                synchronized(AppDatabase::class.java){
                    INSTANCE = buildRoomDB(context)
                }

            }
            return INSTANCE!!
        }

        private fun buildRoomDB(context: Context) =
            Room.databaseBuilder(
                context,
                AppDatabase::class.java,
                NOTIFICATION_DATABASE
            ).build()


    }
}