created split tunneling screen on TV, set apps list, set UI & focus on items,screen, set padding of bottomnav bar screens, etc..

.idea/deploymentTargetSelector.xml

@@ -4,10 +4,10 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2024-07-11T09:38:37.275793585Z">
+        <DropdownSelection timestamp="2024-07-12T15:02:21.310127177Z">
           <Target type="DEFAULT_BOOT">
             <handle>
-              <DeviceId pluginId="Default" identifier="serial=192.168.108.76:5555;connection=3676d456" />
+              <DeviceId pluginId="Default" identifier="serial=192.168.110.50:5555;connection=433c01d4" />
             </handle>
           </Target>
         </DropdownSelection>

app/src/main/java/com/vpn/fastestvpnservice/customItems/SplitTunnelingItem.kt

@@ -39,6 +39,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.ImageBitmap
 import androidx.compose.ui.graphics.asImageBitmap
@@ -67,16 +68,23 @@ fun SplitTunnelingItem(
     position: Int
 ) {
     var isSelected by rememberSaveable { mutableStateOf(app.isSelected().value) }
+    var isItemFocused by remember { mutableStateOf(false) }
+
+    val color = if (isSelected) colorResource(id = R.color.split_background)
+    else if (isItemFocused) colorResource(id = R.color.grayDark)
+    else colorResource(id = R.color.background_color_gray)
 
     Surface(
         modifier = Modifier
             .fillMaxWidth()
             .background(
-                color = MaterialTheme.colorScheme.background
+                color = colorResource(id = R.color.background_color_gray)
             )
-            .padding(bottom = 1.dp),
-        color = if (isSelected) MaterialTheme.colorScheme.surfaceContainer
-                else MaterialTheme.colorScheme.background
+            .padding(bottom = 1.dp)
+            .onFocusChanged {
+                isItemFocused = it.isFocused
+            },
+        color = color
 
     ) {
         val context = LocalContext.current
@@ -112,8 +120,7 @@ fun SplitTunnelingItem(
             )
             Text(text = "$app",
                 style = MaterialTheme.typography.bodySmall,
-                color = if (isSelected) MaterialTheme.colorScheme.primary
-                else MaterialTheme.colorScheme.primary,
+                color = colorResource(id = R.color.dark_blue_gray_text),
                 maxLines = 2,
                 overflow = TextOverflow.Ellipsis,
                 modifier = Modifier

app/src/main/java/com/vpn/fastestvpnservice/navigation/BottomBarNavGraphTV.kt

@@ -17,6 +17,7 @@ import com.vpn.fastestvpnservice.screensTV.HelpTV
 import com.vpn.fastestvpnservice.screensTV.HomeTV
 import com.vpn.fastestvpnservice.screensTV.ServerListTV
 import com.vpn.fastestvpnservice.screensTV.SettingsTV
+import com.vpn.fastestvpnservice.screensTV.SplitTunnelingTV
 import com.vpn.fastestvpnservice.sealedClass.BottomBarScreen
 import com.vpn.fastestvpnservice.sealedClass.ScreenTV
 
@@ -60,6 +61,9 @@ fun BottomBarNavGraphTV(navHostController: NavHostController,
         composable(route = ScreenTV.ServerListTV.route) {
             ServerListTV(navHostController = navHostController)
         }
+        composable(route = ScreenTV.SplitTunnelingTV.route) {
+            SplitTunnelingTV(navHostController = navHostController)
+        }
 
         /* Again declare for login because of different -> navHostController */
 //        composable(route = Screen.Login.route) {

app/src/main/java/com/vpn/fastestvpnservice/screensTV/AccountScreenTV.kt

@@ -123,8 +123,7 @@ fun AccountTV(navHostController: NavHostController,
         Box(modifier = Modifier
             .background(colorResource(id = R.color.background_color_gray))
             .fillMaxSize()
-            .padding(vertical = 10.dp)
-            .padding(bottom = 0.dp)
+            .padding(top = 0.dp)
             .verticalScroll(rememberScrollState())
 //        contentAlignment = Alignment.Center
 
@@ -145,10 +144,10 @@ fun AccountTV(navHostController: NavHostController,
                 verticalArrangement = Arrangement.Top,
                 horizontalAlignment = Alignment.Start,
                 modifier = Modifier
-                    .padding(start = 16.dp, end = 24.dp)
+                    .padding(start = 16.dp, end = 24.dp, top = 10.dp)
                     .fillMaxSize()
             ) {
-                Spacer(modifier = Modifier.height(50.dp))
+//                Spacer(modifier = Modifier.height(50.dp))
                 AddTextAccountTV(
                     text = "Account",
                     size = 28.sp,

app/src/main/java/com/vpn/fastestvpnservice/screensTV/HelpScreenTV.kt

@@ -94,7 +94,7 @@ fun HelpTV(navHostController: NavHostController) {
             modifier = Modifier
                 .background(colorResource(id = R.color.background_color_gray))
                 .fillMaxSize()
-                .padding(vertical = 10.dp)
+                .padding(vertical = 0.dp)
                 .verticalScroll(rememberScrollState()),
 //        contentAlignment = Alignment.Center
         ) {
@@ -115,10 +115,10 @@ fun HelpTV(navHostController: NavHostController) {
                 verticalArrangement = Arrangement.Top,
                 horizontalAlignment = Alignment.Start,
                 modifier = Modifier
-                    .padding(start = 16.dp, end = 24.dp)
+                    .padding(start = 16.dp, end = 24.dp, top = 10.dp)
                     .fillMaxSize()
             ) {
-                Spacer(modifier = Modifier.height(50.dp))
+//                Spacer(modifier = Modifier.height(50.dp))
                 AddTextHelpTV(
                     text = "Help",
                     size = 28.sp,

app/src/main/java/com/vpn/fastestvpnservice/screensTV/SettingsScreenTV.kt

@@ -110,6 +110,7 @@ import com.vpn.fastestvpnservice.screens.searchListViewModelSplash
 import com.vpn.fastestvpnservice.screens.serverListViewModelSplash
 import com.vpn.fastestvpnservice.sealedClass.BottomBarScreen
 import com.vpn.fastestvpnservice.sealedClass.Screen
+import com.vpn.fastestvpnservice.sealedClass.ScreenTV
 import com.vpn.fastestvpnservice.utils.isTablet
 import com.vpn.fastestvpnservice.viewmodels.HomeViewModel
 import com.vpn.fastestvpnservice.viewmodels.ServerListViewModel
@@ -158,20 +159,18 @@ fun SettingsTV(navHostController: NavHostController) {
 //            .background(MaterialTheme.colorScheme.background)
                 .background(colorResource(id = R.color.background_color_gray))
                 .fillMaxSize()
-                .padding(vertical = 10.dp),
+                .padding(vertical = 0.dp),
         ) {
             val view = LocalView.current
             val window = (view.context as Activity).window
             window.statusBarColor = Color.Transparent.toArgb()
             window.navigationBarColor = Color.Transparent.toArgb()
 
-
-
             Column(
                 verticalArrangement = Arrangement.Top,
                 horizontalAlignment = Alignment.Start,
                 modifier = Modifier
-                    .padding(start = 16.dp, end = 0.dp)
+                    .padding(start = 16.dp, top = 10.dp)
                     .fillMaxSize()
                     .verticalScroll(rememberScrollState())
                     .background(Color.Transparent)
@@ -186,7 +185,7 @@ fun SettingsTV(navHostController: NavHostController) {
 //                    )
 //                }
 
-                Spacer(modifier = Modifier.height(50.dp))
+//                Spacer(modifier = Modifier.height(16.dp))
                 AddTextSettingsTV(
                     text = "Settings",
                     size = 28.sp,
@@ -230,7 +229,7 @@ fun SettingsTV(navHostController: NavHostController) {
                 AddRowSettingsTV(
                     icon = R.drawable.split_tunneling3x,
                     text = "Split Tunneling",
-                    onClick = { navHostController.navigate(Screen.SplitTunneling.route) }
+                    onClick = { navHostController.navigate(ScreenTV.SplitTunnelingTV.route) }
                 )
                 AddRowSettingsTV(
                     icon = R.drawable.notification3x,

app/src/main/java/com/vpn/fastestvpnservice/screensTV/SplitTunnelingTV.kt

@@ -0,0 +1,402 @@
+package com.vpn.fastestvpnservice.screensTV
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.util.Log
+import android.widget.Toast
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.material.Icon
+import androidx.compose.material.IconButton
+import androidx.compose.material.Surface
+import androidx.compose.material.Text
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.RadioButtonDefaults
+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.draw.alpha
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.res.colorResource
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import androidx.navigation.NavHostController
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.vpn.fastestvpnservice.R
+import com.vpn.fastestvpnservice.beans.SelectApplicationEntry
+import com.vpn.fastestvpnservice.constants.splitList
+import com.vpn.fastestvpnservice.customItems.SplitTunnelingItem
+import com.vpn.fastestvpnservice.helpers.BasePreferenceHelper
+import com.vpn.fastestvpnservice.screens.settingsScreenAll.getInstalledApps
+import java.util.SortedSet
+import java.util.TreeSet
+
+@Composable
+fun SplitTunnelingTV(navHostController: NavHostController) {
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(colorResource(id = R.color.background_color_gray))
+    ) {
+        val view = LocalView.current
+        val window = (view.context as Activity).window
+        window.statusBarColor = Color.Transparent.toArgb()
+        window.navigationBarColor = Color.Transparent.toArgb()
+
+        HeaderRowSTTV(navHostController = navHostController)
+
+        Column(
+            verticalArrangement = Arrangement.Top,
+            horizontalAlignment = Alignment.Start,
+            modifier = Modifier
+                .padding(top = 60.dp, start = 0.dp, end = 0.dp)
+                .fillMaxSize()
+                .background(Color.Transparent)
+        ) {
+            var isExpanded by remember { mutableStateOf(true) }
+            val icon = if (isExpanded) R.drawable.dragarrow3x
+            else R.drawable.downarrow3x
+//            val rotationState by animateFloatAsState(
+//                targetValue = if (isExpanded) 180f else 0f,
+//                label = if (isExpanded) "Show Less" else "Show More")
+
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .padding(start = 16.dp, end = 28.dp)
+                    .fillMaxWidth()
+            ) {
+                Text(text = "While VPN is Connected",
+                    style = MaterialTheme.typography.titleSmall,
+                    color = colorResource(id = R.color.dark_blue_gray_text)
+                )
+//                IconButton(onClick = {
+//                    isExpanded = !isExpanded
+//                },
+//                    modifier = Modifier
+//                        .background(Color.Transparent)
+////                        .rotate(rotationState)
+//                        .size(12.dp, 7.dp)
+//                ) {
+//                    Icon(
+//                        painter = painterResource(
+//                            id = icon),
+//                        contentDescription = "Arrow-DropDown",
+//                        tint = MaterialTheme.colorScheme.primary
+//                    )
+//
+//                }
+            }
+
+//            if (isExpanded) { }
+            ShowRadioButtonsTV()
+
+        }
+    }
+}
+
+@Composable
+fun BoxScope.HeaderRowSTTV(navHostController: NavHostController) {
+    val focusRequester1 = remember { FocusRequester() }
+    var isButtonFocused by remember { mutableStateOf(false) }
+//    LaunchedEffect(key1 = Unit) {
+//        focusRequester1.requestFocus()
+//    }
+//    IconButton(
+//        onClick = {
+//            navHostController.popBackStack()
+////                    navHostController.navigate(BottomBarScreen.Help.route)
+//        },
+//        modifier = Modifier
+//            .align(Alignment.TopStart)
+//            .padding(top = 50.dp)
+//            .padding(start = 16.dp)
+//            .size(30.dp, 32.dp)
+//            .background(if (isButtonFocused) Color.LightGray else Color.Transparent)
+//            .focusRequester(focusRequester1)
+//            .onFocusChanged {
+//                isButtonFocused = it.isFocused
+//            }
+//            .focusable()
+//            .clickable {
+//                navHostController.popBackStack()
+//            }
+//    ) {
+//        Icon(
+//            painter = painterResource(id = R.drawable.backarrow3x),
+//            contentDescription = "Arrow-Back",
+//            tint = colorResource(id = R.color.dark_blue_gray_text),
+//            modifier = Modifier.size(18.dp, 12.dp)
+//        )
+//    }
+    Surface(
+        modifier = Modifier
+            .padding(start = 14.dp, top = 16.dp)
+            .height(32.dp)
+            .align(Alignment.TopStart)
+//            .padding(5.dp),
+                ,
+        color = colorResource(id = R.color.transparent)
+    ) {
+        Text(text = "Split Tunneling",
+            color = colorResource(id = R.color.dark_blue_gray_text),
+            style = MaterialTheme.typography.titleMedium,
+            modifier = Modifier.fillMaxHeight()
+
+        )
+    }
+}
+
+@Composable
+fun ColumnScope.ShowSplitTunnelListTV(list: List<SelectApplicationEntry>) {
+
+    Box(modifier = Modifier
+        .padding(top = 5.dp)
+        .fillMaxSize()
+        .background(Color.Transparent)
+    ) {
+        LazyColumn() {
+            itemsIndexed(items = list) {position, app ->
+                SplitTunnelingItem(app, list, position)
+            }
+        }
+    }
+}
+
+@Composable
+fun ColumnScope.ShowRadioButtonsTV() {
+    Log.d("test_split_compose", "ShowRadioButtons()")
+    val context = LocalContext.current
+    val prefHelper = BasePreferenceHelper(context = context)
+    var apps = ArrayList<SelectApplicationEntry>()
+
+    var selectedList by remember { mutableStateOf(prefHelper.getSplitPosition()) }
+    var focusedList by remember { mutableStateOf(splitList[0]) }
+    var isButtonFocused by remember { mutableStateOf(false) }
+    var isFocusedAnyItem by remember { mutableStateOf(false) }
+
+    Spacer(modifier = Modifier.height(10.dp))
+
+    splitList.forEachIndexed { index, list ->
+        isButtonFocused = focusedList == list
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(if (isButtonFocused && isFocusedAnyItem) Color.LightGray else Color.Transparent)
+                .padding(top = 0.dp)
+                .onFocusChanged {
+                    if (it.isFocused) {
+                        focusedList = list
+                    }
+                    isFocusedAnyItem = it.isFocused
+                }
+                .focusable()
+                .selectable(
+                    selected = selectedList == list,
+                    onClick = {
+                        selectedList = list
+                        prefHelper.saveSplitPosition(list)
+                        apps = getInstalledAppsTV(context)
+
+                    },
+                )
+//                                    .indication(
+//                                        indication = null,
+//                                        interactionSource = remember {
+//                                            MutableInteractionSource()
+//                                        }
+//                                    )
+                        ,
+                        verticalAlignment = Alignment.CenterVertically
+                        ) {
+                            RadioButton(
+                                modifier = Modifier,
+                                selected = list == selectedList,
+                                onClick = {
+                                    selectedList = list
+                                    prefHelper.saveSplitPosition(list)
+                                    apps = getInstalledAppsTV(context)
+                                },
+                                colors = RadioButtonDefaults.colors(
+                                    selectedColor = colorResource(id = R.color.radio_button_blue),
+                                    unselectedColor = colorResource(id = R.color.gray_icon)
+                                )
+                            )
+                            Text(
+                                text = list,
+                                modifier = Modifier.padding(start = 12.dp),
+                                style = MaterialTheme.typography.bodySmall,
+                                color = colorResource(id = R.color.dark_blue_gray_text)
+                            )
+                        }
+                    }
+
+    Surface(
+        modifier = Modifier
+            .padding(start = 16.dp, end = 16.dp, top = 15.dp)
+            .height(1.dp)
+            .fillMaxWidth()
+            .alpha(0.6F)
+        ,
+        color = colorResource(id = R.color.gray_icon)
+    ) {}
+
+    apps = getInstalledApps(context)
+    Log.d("test_split_compose", "apps called : ${apps.size}")
+
+    val type = object : TypeToken<SortedSet<String?>?>() {}.type
+    val appsAllow = Gson().fromJson<SortedSet<String>>(
+        prefHelper.getSplitTunneledApps(), type
+    )
+
+    appsAllow?.let {
+        for (app in appsAllow) {
+            Log.d("test_split_compose", "apps allow : $app")
+        }
+    }
+
+    if (selectedList == splitList[1]) {
+        ShowSplitTunnelListTV(apps)
+    }
+    else if (selectedList == splitList[2]) {
+        ShowSplitTunnelListTV(apps)
+    }
+}
+
+fun getInstalledAppsTV(context: Context): ArrayList<SelectApplicationEntry> {
+    val prefHelper = BasePreferenceHelper(context)
+    val apps: ArrayList<SelectApplicationEntry> = ArrayList()
+//    val apps2: ArrayList<SelectApplicationEntry> = ArrayList()
+    val seen: SortedSet<String> = TreeSet()
+    var selectedAppsList = ArrayList<String>()
+    var selectedAppsListNoVpn = ArrayList<String>()
+
+    if (!prefHelper.getSplitTunneledApps().equals("")) {
+        val type = object : TypeToken<ArrayList<String>>() {}.type
+        selectedAppsList = Gson().fromJson(prefHelper.getSplitTunneledApps(), type)
+    }
+
+    if (!prefHelper.getSplitTunneledAppsNoVpn().equals("")) {
+        val type = object : TypeToken<ArrayList<String>>() {}.type
+        selectedAppsListNoVpn = Gson().fromJson(prefHelper.getSplitTunneledAppsNoVpn(), type)
+    }
+
+    val mPackageManager: PackageManager = context.packageManager
+
+    for (info in mPackageManager.getInstalledApplications(PackageManager.GET_META_DATA)) { /* skip apps that can't access the network anyway */
+
+        if (info.flags and ApplicationInfo.FLAG_UPDATED_SYSTEM_APP != 0) {
+            Log.d("--package names !0", "" + info.packageName)
+            if (mPackageManager.checkPermission(
+                    Manifest.permission.INTERNET, info.packageName
+                ) == PackageManager.PERMISSION_GRANTED
+            ) {
+                if (info.packageName == context.packageName) continue
+                val entry = SelectApplicationEntry(mPackageManager, info, false)
+
+                prefHelper.getSplitPosition().let {
+                    when (it){
+                        splitList[1] -> {
+                            if (!prefHelper.getSplitTunneledApps().equals("")) {
+                                entry.setSelected(mutableStateOf(selectedAppsList.contains(info.packageName))) //= selectedAppsList!!.contains(info.packageName)
+                            }
+                        }
+                        splitList[2] -> {
+                            if (!prefHelper.getSplitTunneledAppsNoVpn().equals("")) {
+                                entry.setSelected(mutableStateOf(selectedAppsListNoVpn.contains(info.packageName))) //= selectedAppsList!!.contains(info.packageName)
+                            }
+                        }
+                    }
+                }
+
+                Log.d("test_splittunnel_data", "${entry.getInfo()?.name}")
+
+                Log.d("entry_split_FUSA","$entry")
+
+                apps.add(entry)
+//                apps2.add(entry)
+                seen.add(info.packageName)
+
+            }
+        }
+        if (info.flags and ApplicationInfo.FLAG_SYSTEM == 0) {
+            Log.d("--package names 0 ", "" + info.packageName)
+            if (mPackageManager.checkPermission(
+                    Manifest.permission.INTERNET, info.packageName
+                ) == PackageManager.PERMISSION_GRANTED
+            ) {
+                if (info.packageName == context.packageName) continue
+                val entry = SelectApplicationEntry(mPackageManager, info, false)
+
+                prefHelper.getSplitPosition().let {
+                    when (it){
+                        splitList[1] -> {
+                            if (!prefHelper.getSplitTunneledApps().equals("")) {
+                                entry.setSelected(mutableStateOf(selectedAppsList.contains(info.packageName))) //= selectedAppsList!!.contains(info.packageName)
+                            }
+                        }
+                        splitList[2] -> {
+                            if (!prefHelper.getSplitTunneledAppsNoVpn().equals("")) {
+                                entry.setSelected(mutableStateOf(selectedAppsListNoVpn.contains(info.packageName))) //= selectedAppsList!!.contains(info.packageName)
+                            }
+                        }
+                    }
+                }
+
+                apps.add(entry)
+//                apps2.add(entry)
+                seen.add(info.packageName)
+
+                Log.d("entry_split_FS","$entry")
+
+            }
+
+        }
+    }
+
+    apps.sort()
+//    apps2.sort()
+
+    apps.forEach {
+        Log.d("test_split_apps", "$it")
+    }
+//    apps2.forEach {
+//        Log.d("test_split_apps 2", "$$it ${it.getIcon()}")
+//    }
+
+    return apps
+}

app/src/main/java/com/vpn/fastestvpnservice/sealedClass/ScreenTV.kt

@@ -6,4 +6,5 @@ sealed class ScreenTV(val route: String) {
     data object HomeTV : ScreenTV("home_screen_tv")
     data object BottomBarTV : ScreenTV("bottom_bar_tv")
     data object ServerListTV : ScreenTV("server_list_route")
+    data object SplitTunnelingTV : ScreenTV("split_tunneling_tv")
 }

app/src/main/java/com/vpn/fastestvpnservice/ui/theme/Theme.kt

@@ -1,24 +1,16 @@
 package com.vpn.fastestvpnservice.ui.theme
 
 import android.app.Activity
-import android.os.Build
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.dynamicDarkColorScheme
-import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.material3.lightColorScheme
-import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.SideEffect
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalView
-import androidx.compose.ui.res.colorResource
-import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
-import com.vpn.fastestvpnservice.R
 
 /*
 primary = text,icon - white/darkBlueGrey
@@ -59,7 +51,7 @@ private val DarkColorScheme = darkColorScheme(
 
 private val LightColorScheme = lightColorScheme(
 //    primary = Purple40,
-    primary = Color(0xFF0d1a2a),    // darkBlueGrey
+    primary = Color(0xFF0d1a2a),    // darkBlueGrey || dark_blue_gray_text
     onPrimary = Color.White,
     onPrimaryContainer = Color(0xFFECF2FC),
     primaryContainer = Color(0xFF3B6AEE), // blue_text
@@ -77,7 +69,7 @@ private val LightColorScheme = lightColorScheme(
 
     surface = Color(0xFF4071fb), // light_blue_2
     surfaceBright = Color(0xFF36485e), // text_color_dark_gray
-    surfaceContainer = Color(0xFFE9EAEC),
+    surfaceContainer = Color(0xFFE9EAEC), // split_background
     surfaceDim = Color(0xFFE9EDF9),
     surfaceContainerLow = Color(0xFF3B6AEE), // blue_text
     surfaceContainerHigh = Color(0xFF4071fb), // light_blue_2