diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index ed76bea..d7cb58b 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -5,6 +5,9 @@
       <option name="composableFile" value="true" />
       <option name="previewFile" value="true" />
     </inspection_tool>
+    <inspection_tool class="PreviewApiLevelMustBeValid" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
     <inspection_tool class="PreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="composableFile" value="true" />
       <option name="previewFile" value="true" />
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 8b74500..375b6fa 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -3,6 +3,13 @@
     xmlns:tools="http://schemas.android.com/tools">
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+        android:maxSdkVersion="28" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
+    <uses-permission android:name="android.permission.ACCESS_MEDIA_LOCATION" />
+
     <application
         android:name=".MasrofyApp"
         android:allowBackup="true"
diff --git a/app/src/main/java/com/masrofy/MainActivity.kt b/app/src/main/java/com/masrofy/MainActivity.kt
index f46046f..880d99b 100644
--- a/app/src/main/java/com/masrofy/MainActivity.kt
+++ b/app/src/main/java/com/masrofy/MainActivity.kt
@@ -38,6 +38,7 @@ import com.masrofy.screens.currency.currencyScreen
 import com.masrofy.screens.mainScreen.mainScreenNavigation
 import com.masrofy.screens.onboarding.onBoardingDest
 import com.masrofy.screens.settings.backups.backupScreens
+import com.masrofy.screens.settings.backups.device_backup.deviceBackupDest
 import com.masrofy.screens.settings.backups.drive_backup.driveBackupDest
 import com.masrofy.screens.settings.settingsDest
 import com.masrofy.screens.statisticsScreen.statisticsScreen
@@ -59,12 +60,16 @@ class MainActivity : ComponentActivity() {
         viewModel.checkCategories()
         viewModel.checkOnboarding()
         val permissionLauncher = registerForActivityResult(
-             ActivityResultContracts.RequestPermission(),
+             ActivityResultContracts.RequestMultiplePermissions(),
         ){
 
         }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            permissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+            permissionLauncher.launch(
+                arrayOf(Manifest.permission.POST_NOTIFICATIONS, Manifest.permission.READ_MEDIA_IMAGES,
+                Manifest.permission.READ_EXTERNAL_STORAGE,
+                Manifest.permission.ACCESS_MEDIA_LOCATION)
+            )
         }
 
         setContent {
@@ -215,6 +220,7 @@ fun SetNavigationScreen(mainViewModel: MainViewModel) {
             currencyScreen(navController)
             backupScreens(navController)
             driveBackupDest(navController)
+            deviceBackupDest(navController)
         }
     }
 }
diff --git a/app/src/main/java/com/masrofy/Screens.kt b/app/src/main/java/com/masrofy/Screens.kt
index 906037a..cafdd55 100644
--- a/app/src/main/java/com/masrofy/Screens.kt
+++ b/app/src/main/java/com/masrofy/Screens.kt
@@ -14,6 +14,10 @@ const val ONBOARDING_SCREENS_ARGS = "onboarding_screens"
 sealed class Screens(val route: String) {
     abstract val args: List<NamedNavArgument>
 
+    data object DeviceBackup :Screens("device-backup-screen"){
+        override val args: List<NamedNavArgument>
+            get() = emptyList()
+    }
     data object DriveBackupScreen:Screens("drive-backup-screen"){
         override val args: List<NamedNavArgument>
             get() = emptyList()
diff --git a/app/src/main/java/com/masrofy/component/ImportFilesDialog.kt b/app/src/main/java/com/masrofy/component/ImportFilesDialog.kt
index 8b58082..817ec50 100644
--- a/app/src/main/java/com/masrofy/component/ImportFilesDialog.kt
+++ b/app/src/main/java/com/masrofy/component/ImportFilesDialog.kt
@@ -38,7 +38,7 @@ import com.masrofy.ui.theme.MasrofyTheme
 @Composable
 fun ImportFilesDialog(
     files:List<BackUpDataFileInfo>,
-    progressDownloadState: ProgressDownloadState,
+    progressDownloadState: ProgressDownloadState?,
     onClickFile:(String)->Unit,
     onDismiss:()->Unit
 ) {
@@ -53,7 +53,7 @@ fun ImportFilesDialog(
                             .padding(8.dp), horizontalArrangement = Arrangement.SpaceBetween) {
                             Icon(painter = painterResource(id = R.drawable.backup_icon), contentDescription = "")
                             Text(text = "${it.fileName} ", fontSize = 17.sp, maxLines = 1)
-                            if (progressDownloadState.fileId == it.idFile){
+                            if (progressDownloadState?.fileId == it.idFile){
                                 if (progressDownloadState.state == ProgressState.INITIATION_STARTED){
                                     CircularProgressIndicator()
                                 }else if (progressDownloadState.state == ProgressState.STARTED){
diff --git a/app/src/main/java/com/masrofy/component/MScaffoldBar.kt b/app/src/main/java/com/masrofy/component/MScaffoldBar.kt
new file mode 100644
index 0000000..3f714f5
--- /dev/null
+++ b/app/src/main/java/com/masrofy/component/MScaffoldBar.kt
@@ -0,0 +1,29 @@
+package com.masrofy.component
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.runtime.Composable
+import com.masrofy.R
+import com.masrofy.screens.settings.backups.drive_backup.DriveBackupEvent
+
+@Composable
+fun MScaffoldBar(
+    title:TranslatableString,
+    onBack:() -> Unit,
+    menuItem: List<MenuItem> = listOf(),
+    content:@Composable (padding:PaddingValues)->Unit
+) {
+    Scaffold(topBar = {
+        AppBar(title, {
+            IconButton(onClick = onBack) {
+                Icon(imageVector = Icons.Default.ArrowBack, contentDescription = "")
+            }
+        },menuItem)
+    }) {
+        content(it)
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/masrofy/core/backup/AbstractBackupData.kt b/app/src/main/java/com/masrofy/core/backup/AbstractBackupData.kt
index 888e6e7..a1fbcae 100644
--- a/app/src/main/java/com/masrofy/core/backup/AbstractBackupData.kt
+++ b/app/src/main/java/com/masrofy/core/backup/AbstractBackupData.kt
@@ -4,8 +4,10 @@ import android.content.ContentResolver.MimeTypeInfo
 import android.webkit.MimeTypeMap
 import com.google.gson.Gson
 import com.masrofy.core.drive.DRIVE_BACKUP_FILENAME
+import com.masrofy.data.database.MasrofyDatabase
 import com.masrofy.screens.settings.backups.drive_backup.PeriodSchedule
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
 import kotlinx.coroutines.withContext
 import java.io.File
 import java.io.OutputStream
@@ -37,13 +39,26 @@ abstract class AbstractBackupData(backupEventListener: BackupEventListener) {
 
 
     fun getFileName():String = "$DRIVE_BACKUP_FILENAME ${System.currentTimeMillis()}.json"
-
+     suspend fun saveDataToDatabase(backupDataModel:BackupDataModel,database: MasrofyDatabase){
+        val getTransactionDao = database.transactionDao
+        getTransactionDao.upsertAccount(backupDataModel.account.toAccountEntity())
+        backupDataModel.transactions.forEach {
+            getTransactionDao.insertTransaction(it.toTransactionEntity())
+        }
+    }
+    suspend fun getBackupModel(database: MasrofyDatabase): BackupDataModel {
+        val getAccount = database.transactionDao.getAccounts().first()
+        val transactions =
+            database.transactionDao.getTransactions().map { it.toTransactionBackupData() }
+        return BackupDataModel(getAccount.toAccountBackupData(), transactions)
+    }
     /**
      * save data to json file
      */
     suspend fun writeDateToFile(backupDataModel: BackupDataModel):File{
         return withContext(Dispatchers.IO){
             val toGson = Gson().toJson(backupDataModel)
+            // TODO: improve it
             val tempFile = File.createTempFile(getFileName(),null,null).apply {
                 writeText(toGson.toString())
             }
diff --git a/app/src/main/java/com/masrofy/core/backup/BackupDataModel.kt b/app/src/main/java/com/masrofy/core/backup/BackupDataModel.kt
index 8f32b1f..38956bb 100644
--- a/app/src/main/java/com/masrofy/core/backup/BackupDataModel.kt
+++ b/app/src/main/java/com/masrofy/core/backup/BackupDataModel.kt
@@ -23,7 +23,6 @@ data class AccountBackupData(
     val type: CategoryAccount,
     val totalAmount: Long,
     val createdAt: Long,
-
     val currency: Currency
 )
 
diff --git a/app/src/main/java/com/masrofy/core/backup/BackupExternalStorage.kt b/app/src/main/java/com/masrofy/core/backup/BackupExternalStorage.kt
index 2e8fc6e..9bc8bf3 100644
--- a/app/src/main/java/com/masrofy/core/backup/BackupExternalStorage.kt
+++ b/app/src/main/java/com/masrofy/core/backup/BackupExternalStorage.kt
@@ -1,21 +1,88 @@
 package com.masrofy.core.backup
 
+import android.content.ContentResolver
+import android.content.ContentValues
 import android.content.Context
-import java.io.File
+import android.os.Build
+import android.os.Environment
+import android.provider.DocumentsProvider
+import android.provider.MediaStore
+import android.provider.OpenableColumns
+import android.util.Log
+import androidx.core.database.getStringOrNull
+import androidx.core.net.toUri
+import com.google.gson.Gson
+import com.masrofy.core.drive.DRIVE_BACKUP_FILENAME
+import com.masrofy.data.database.MasrofyDatabase
+import com.masrofy.utils.getFileSize
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.withContext
 
 class BackupExternalStorage(
     private val backupEventListener: BackupEventListener,
-    private val context: Context
-) :AbstractBackupData(backupEventListener){
+    private val context: Context,
+    private val database: MasrofyDatabase
+) : AbstractBackupData(backupEventListener) {
+
+    private val contentResolver = context.contentResolver
     override suspend fun backup() {
-        TODO("Not yet implemented")
+        withContext(Dispatchers.IO + CoroutineExceptionHandler { coroutineContext, throwable ->
+            Log.d("BackupExternalStorage", "backup: unknown error", throwable)
+        }) {
+            val backupModel = async { getBackupModel(database) }
+            val collection =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) MediaStore.Downloads.getContentUri(
+                    MediaStore.VOLUME_EXTERNAL
+                ) else return@withContext
+
+            val contentValues = ContentValues().apply {
+                put(MediaStore.Downloads.DISPLAY_NAME, getFileName())
+                put(MediaStore.Downloads.MIME_TYPE, "application/json")
+                put(MediaStore.Downloads.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
+            }
+            try {
+                val getFile = writeDateToFile(backupModel.await())
+                contentResolver.insert(collection, contentValues)?.also {
+                    contentResolver.openOutputStream(it).use { output ->
+                        output?.write(getFile.readBytes())
+                    }
+                }
+                backupEventListener.onFinish()
+            } catch (e: Exception) {
+                Log.d("BackupExternalStorage", "backup: unknown error", e)
+            }
+        }
     }
 
-    override suspend fun import(file: String) {
-        TODO("Not yet implemented")
+    override suspend fun import(fileId: String) {
+        val getUri = fileId.toUri()
+        try {
+            contentResolver.query(getUri,null,null,null,null).use{cor->
+                if (cor != null){
+                    if (cor.moveToNext()){
+                        val displayName = cor.getStringOrNull(cor.getColumnIndex(OpenableColumns.DISPLAY_NAME))?:return@use
+                        if (displayName.contains(DRIVE_BACKUP_FILENAME)){
+                            contentResolver.openInputStream(getUri).use{
+                                val parseByte = String(it?.readBytes()?:return@use)
+                                val gson = Gson().fromJson(parseByte,BackupDataModel::class.java)
+                                saveDataToDatabase(gson,database)
+                            }
+                        }else{
+                            Log.d(javaClass.simpleName, "import: it not this file")
+                        }
+                    }
+                }
+            }
+        }catch (e:Exception){
+            Log.e("BackupExternalStorage", "import: error",e )
+        }
     }
 
     override suspend fun getImportFiles(): List<BackUpDataFileInfo> {
-        TODO("Not yet implemented")
+        return emptyList()
     }
-}
\ No newline at end of file
+
+}
+
diff --git a/app/src/main/java/com/masrofy/core/backup/DriveBackupDataImpl.kt b/app/src/main/java/com/masrofy/core/backup/DriveBackupDataImpl.kt
index 6a2995a..2e08e7d 100644
--- a/app/src/main/java/com/masrofy/core/backup/DriveBackupDataImpl.kt
+++ b/app/src/main/java/com/masrofy/core/backup/DriveBackupDataImpl.kt
@@ -45,13 +45,9 @@ class DriveBackupDataImpl(
     override suspend fun backup() {
         withContext(Dispatchers.IO) {
             eventListener.onBackup()
-            val getAccount = async { database.transactionDao.getAccounts().first() }
-            val transactions = async {
-                database.transactionDao.getTransactions().map { it.toTransactionBackupData() }
-            }
+            val backupModel = async { getBackupModel(database) }
             eventListener.progressBackup(currentProgressState.copy(ProgressState.INITIATION_STARTED))
-            val backupModel = BackupDataModel(getAccount.await().toAccountBackupData(), transactions.await())
-            val file = async { writeDateToFile(backupModel) }
+            val file = async { writeDateToFile(backupModel.await()) }
             fileSize = file.await().length()
 
             backupDrive(drive!!, file.await(), getFileName()).apply {
@@ -70,6 +66,7 @@ class DriveBackupDataImpl(
 
     override suspend fun import(fileId: String) {
         withContext(Dispatchers.IO) {
+            // TODO: move to work manager it cancel when back screen
             eventListener.onImport()
             val getFromDrive = getFileById(drive!!, fileId)
             val downloader = getFromDrive.mediaHttpDownloader
@@ -79,9 +76,10 @@ class DriveBackupDataImpl(
             currentDownloadProgressState = currentDownloadProgressState.copy(fileId = fileId)
             eventListener.progressDownloadFile(currentDownloadProgressState.copy(progressState = ProgressState.INITIATION_STARTED, fileId = fileId))
             try {
+
                 getFromDrive.executeMediaAndDownloadTo(byteArrayOutputStream)
                 val parseToBackupModel = async { parseByteToJsonString(byteArrayOutputStream) }
-                saveDataToDatabase(parseToBackupModel.await())
+                saveDataToDatabase(parseToBackupModel.await(),database)
             }catch (e:Exception){
                 // improve later
                 Log.e(javaClass.simpleName, "import: called", e)
@@ -90,13 +88,7 @@ class DriveBackupDataImpl(
         }
     }
 
-    private suspend fun saveDataToDatabase(backupDataModel:BackupDataModel){
-        val getTransactionDao = database.transactionDao
-        getTransactionDao.upsertAccount(backupDataModel.account.toAccountEntity())
-        backupDataModel.transactions.forEach {
-            getTransactionDao.insertTransaction(it.toTransactionEntity())
-        }
-    }
+
     private fun parseByteToJsonString(byteArrayOutputStream: ByteArrayOutputStream): BackupDataModel {
         val string = String(byteArrayOutputStream.toByteArray())
         val toJson = Gson().fromJson(string, BackupDataModel::class.java)
@@ -114,7 +106,6 @@ class DriveBackupDataImpl(
             MediaHttpDownloader.DownloadState.MEDIA_COMPLETE -> {
                 eventListener.progressDownloadFile(currentDownloadProgressState.copy(ProgressState.COMPLETE, progress = downloader.progress ))
                 eventListener.onFinish()
-
             }
         }
     }
diff --git a/app/src/main/java/com/masrofy/screens/settings/backups/BackupScreens.kt b/app/src/main/java/com/masrofy/screens/settings/backups/BackupScreens.kt
index fa569cb..0bdccaf 100644
--- a/app/src/main/java/com/masrofy/screens/settings/backups/BackupScreens.kt
+++ b/app/src/main/java/com/masrofy/screens/settings/backups/BackupScreens.kt
@@ -11,6 +11,7 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.painterResource
@@ -32,9 +33,18 @@ fun NavGraphBuilder.backupScreens(navController: NavController) {
     composable(Screens.BackupScreens.route) {
         val backupViewModel = hiltViewModel<BackupViewModel>()
         val state by backupViewModel.state.collectAsStateWithLifecycle()
-        BackupScreens(backupStates = state){
-            navController.navigate(Screens.DriveBackupScreen.route)
+        val effect by backupViewModel.effect.collectAsStateWithLifecycle()
+
+        LaunchedEffect(key1 = effect){
+            when(effect){
+                is BackupSettingEffect.OnNavigate -> {
+                    navController.navigate((effect as BackupSettingEffect.OnNavigate).route)
+                    backupViewModel.resetEffect()
+                }
+                null -> Unit
+            }
         }
+        BackupScreens(backupStates = state,backupViewModel::onEvent)
     }
 }
 
@@ -42,8 +52,7 @@ fun NavGraphBuilder.backupScreens(navController: NavController) {
 @Composable
 fun BackupScreens(
     backupStates: BackupStates,
-    // for test now
-    onNavigate:() -> Unit
+    onEvent:(BackupSettingEvent)->Unit
 ) {
     Scaffold(topBar = {
         AppBar(
@@ -70,7 +79,8 @@ fun BackupScreens(
                     ),
                     endLabelColor = backupStates.getLabelColor()
                 ) {
-                    onNavigate()
+                    onEvent(BackupSettingEvent.Navigate(Screens.DriveBackupScreen.route))
+
                 }
                 Spacer(modifier = Modifier.height(6.dp))
                 SettingsComponent(
@@ -79,17 +89,17 @@ fun BackupScreens(
                         id = R.drawable.device_icon
                     ),
                 ) {
-
+                    onEvent(BackupSettingEvent.Navigate(Screens.DeviceBackup.route))
                 }
                 Spacer(modifier = Modifier.height(6.dp))
-                SettingsComponent(
-                    settingHeaderText = stringResource(id = R.string.export_email),
-                    painterResourceID = painterResource(
-                        id = R.drawable.email_icon
-                    ),
-                ) {
-
-                }
+//                SettingsComponent(
+//                    settingHeaderText = stringResource(id = R.string.export_email),
+//                    painterResourceID = painterResource(
+//                        id = R.drawable.email_icon
+//                    ),
+//                ) {
+//
+//                }
             }
         }
     }
diff --git a/app/src/main/java/com/masrofy/screens/settings/backups/BackupViewModel.kt b/app/src/main/java/com/masrofy/screens/settings/backups/BackupViewModel.kt
index ef3712c..cf90fd8 100644
--- a/app/src/main/java/com/masrofy/screens/settings/backups/BackupViewModel.kt
+++ b/app/src/main/java/com/masrofy/screens/settings/backups/BackupViewModel.kt
@@ -19,6 +19,22 @@ class BackupViewModel @Inject constructor(
 
     private val _state = MutableStateFlow(BackupStates())
     val state = _state.asStateFlow()
+    private val _effect = MutableStateFlow<BackupSettingEffect?>(null)
+    val effect = _effect.asStateFlow()
+    fun onEvent(backupSettingEvent: BackupSettingEvent){
+        when(backupSettingEvent){
+            is BackupSettingEvent.Navigate -> {
+                _effect.update {
+                    BackupSettingEffect.OnNavigate(backupSettingEvent.route)
+                }
+            }
+        }
+    }
+    fun resetEffect(){
+        _effect.update {
+            null
+        }
+    }
     init {
         viewModelScope.launch(dispatcherProvider.io) {
             googleSigningAuthManager.getSignInInfo()?.let{
@@ -28,4 +44,10 @@ class BackupViewModel @Inject constructor(
             }
         }
     }
+}
+sealed class BackupSettingEffect{
+    data class OnNavigate(val route:String):BackupSettingEffect()
+}
+sealed class BackupSettingEvent{
+    data class Navigate(val route:String):BackupSettingEvent()
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupScreen.kt b/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupScreen.kt
new file mode 100644
index 0000000..0fbb1bc
--- /dev/null
+++ b/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupScreen.kt
@@ -0,0 +1,104 @@
+package com.masrofy.screens.settings.backups.device_backup
+
+import android.content.Context
+import android.os.Environment
+import android.os.FileUtils
+import android.provider.DocumentsContract
+import android.util.Log
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.core.net.toFile
+import androidx.core.net.toUri
+import androidx.documentfile.provider.DocumentFile
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.compose.composable
+import com.masrofy.Screens
+import com.masrofy.component.ImportFilesDialog
+import com.masrofy.component.MScaffoldBar
+import com.masrofy.component.translatablePlain
+import com.masrofy.screens.settings.backups.drive_backup.DriveBackupEvent
+import com.masrofy.utils.getFileSize
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+
+fun NavGraphBuilder.deviceBackupDest(navController: NavController) {
+    composable(Screens.DeviceBackup.route) {
+        val deviceViewModel = hiltViewModel<DeviceBackupViewModel>()
+        val state by deviceViewModel.state.collectAsStateWithLifecycle()
+        DeviceBackupScreen(state, onEvent = deviceViewModel::onEvent)
+    }
+}
+
+@Composable
+fun DeviceBackupScreen(
+    state: DeviceBackupState,
+    onEvent: (DeviceBackupEvent) -> Unit
+) {
+    val context = LocalContext.current
+    val l = rememberLauncherForActivityResult(contract = ActivityResultContracts.OpenDocument()) {
+        onEvent(DeviceBackupEvent.Import(context, it ?: return@rememberLauncherForActivityResult))
+    }
+    MScaffoldBar(
+        title = translatablePlain("Device Back up"),
+        onBack = { onEvent(DeviceBackupEvent.Close) }) {
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(it)
+        ) {
+            Card(modifier = Modifier.fillMaxWidth()) {
+                Text(
+                    text = "Your backup data is kept in '/ Download' folder on your device only" +
+                            " In case of loss of your device like broken , stolen and so on" +
+                            " the data can not be recovered",
+                    modifier = Modifier.padding(16.dp),
+                    textAlign = TextAlign.Justify,
+
+                    )
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(6.dp),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    OutlinedButton(onClick = { l.launch(arrayOf("application/json")) }) {
+                        Text(text = "Import")
+                    }
+                    Button(onClick = { onEvent(DeviceBackupEvent.BackupNow(context)) }) {
+                        Text(text = "Back up now")
+                    }
+                }
+            }
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupState.kt b/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupState.kt
new file mode 100644
index 0000000..fc9aef7
--- /dev/null
+++ b/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupState.kt
@@ -0,0 +1,7 @@
+package com.masrofy.screens.settings.backups.device_backup
+
+import com.masrofy.core.backup.BackUpDataFileInfo
+
+data class DeviceBackupState(
+    val files : List<BackUpDataFileInfo> = emptyList()
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupViewModel.kt b/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupViewModel.kt
new file mode 100644
index 0000000..a2c09ca
--- /dev/null
+++ b/app/src/main/java/com/masrofy/screens/settings/backups/device_backup/DeviceBackupViewModel.kt
@@ -0,0 +1,89 @@
+package com.masrofy.screens.settings.backups.device_backup
+
+import android.content.Context
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.masrofy.core.backup.AbstractBackupData
+import com.masrofy.core.backup.BackupEventListener
+import com.masrofy.core.backup.BackupExternalStorage
+import com.masrofy.core.backup.BackupManager
+import com.masrofy.core.backup.ProgressBackupInfo
+import com.masrofy.coroutine.DispatcherProviderImpl
+import com.masrofy.data.database.MasrofyDatabase
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+class DeviceBackupViewModel @Inject constructor(
+    private val database: MasrofyDatabase,
+    private val dispatcherProviderImpl: DispatcherProviderImpl
+) : ViewModel(),BackupEventListener {
+
+    private val backupManager = BackupManager(viewModelScope, dispatcherProviderImpl)
+
+    private val _effect = MutableStateFlow<DeviceBackupEffect?>(null)
+    val effect = _effect.asStateFlow()
+
+    override fun onBackup() {
+    }
+
+    override fun onImport() {
+    }
+
+    override fun onFinish() {
+        // show toast
+    }
+
+    fun resetEffect(){
+        _effect.update {
+            null
+        }
+    }
+    override fun progressBackup(progressBackupInfo: ProgressBackupInfo) {
+
+    }
+
+    override fun progressDownloadFile(progressState: ProgressBackupInfo) {
+    }
+
+    private val _state = MutableStateFlow(DeviceBackupState())
+    val state  = _state.asStateFlow()
+    fun onEvent(deviceBackupEvent: DeviceBackupEvent) {
+        when (deviceBackupEvent) {
+            is DeviceBackupEvent.BackupNow -> {
+                backupManager.startBackup(
+                    BackupExternalStorage(
+                        AbstractBackupData.defaultEventListener,
+                        deviceBackupEvent.context,database
+                    )
+                )
+            }
+
+            is DeviceBackupEvent.Import -> {
+                backupManager.startImport(
+                    BackupExternalStorage(
+                        AbstractBackupData.defaultEventListener,
+                        deviceBackupEvent.context,database
+                    ),deviceBackupEvent.fileUri.toString()
+                )
+            }
+
+            DeviceBackupEvent.Close -> {
+
+            }
+        }
+    }
+}
+sealed class DeviceBackupEffect{
+    data object Close:DeviceBackupEffect()
+}
+sealed class DeviceBackupEvent {
+    data class BackupNow(val context: Context) : DeviceBackupEvent()
+    data class Import(val context: Context,val fileUri:Uri):DeviceBackupEvent()
+    data object Close : DeviceBackupEvent()
+}
\ No newline at end of file