setup IKEv2 connection, it is connecting fine, added broadcastlisteners & also OpenVPN connection is done but need to manage state, it is also connecting...

app/src/main/AndroidManifest.xml

@@ -36,6 +36,38 @@
             </intent-filter>
         </activity>
 
+        <activity
+            android:name="org.strongswan.android.ui.VpnProfileControlActivity"
+            android:excludeFromRecents="true"
+            android:exported="true"
+            android:launchMode="singleTask"
+            android:taskAffinity=""
+            android:theme="@style/TransparentActivity">
+            <intent-filter>
+                <action android:name="org.strongswan.android.action.START_PROFILE" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="org.strongswan.android.action.DISCONNECT" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name="de.blinkt.openvpn.LaunchVPN"
+            android:excludeFromRecents="true"
+            android:exported="true"
+            android:label="@string/vpn_launch_title"
+            tools:ignore="ExportedActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
         <service
             android:name="com.wireguard.android.backend.GoBackend$VpnService"
             android:exported="true"

app/src/main/java/com/vpn/fastestvpnservice/MainActivity.kt

@@ -42,6 +42,7 @@ import com.vpn.fastestvpnservice.viewmodels.SubscriptionViewModel
 class MainActivity : ComponentActivity() {
     val loginViewModel: LoginViewModel by viewModels()
 
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -69,5 +70,9 @@ class MainActivity : ComponentActivity() {
 
         }
     }
+
+    companion object {
+        var isWGDown: Boolean = true
+    }
 }
 

app/src/main/java/com/vpn/fastestvpnservice/screens/bottomNavBarScreens/HomeScreen.kt

@@ -238,6 +238,7 @@ fun Home(navHostController: NavHostController, activity: ComponentActivity) {
                     App.setBackend(back)
                     App.backend = App.getBackend()
                 }
+                vpnConnectionsUtil.onResumeCallBack()
 
                 homeViewModel.getIp()
 
@@ -280,6 +281,19 @@ fun Home(navHostController: NavHostController, activity: ComponentActivity) {
                     android.os.Build.VERSION.RELEASE
                 )
             }
+            Lifecycle.Event.ON_PAUSE -> {
+                Log.d("test_home_resume", "ON_PAUSE: Home Screen!")
+                vpnConnectionsUtil.onPauseCallBack()
+
+            }
+            Lifecycle.Event.ON_STOP -> {
+                Log.d("test_home_resume", "ON_STOP: Home Screen!")
+                vpnConnectionsUtil.onStopCallBack()
+            }
+            Lifecycle.Event.ON_DESTROY -> {
+                Log.d("test_home_resume", "ON_DESTROY: Home Screen!")
+                vpnConnectionsUtil.onPauseCallBack()
+            }
             else -> {
                 Log.d("test_home_resume", "else: Home Screen!")
             }
@@ -352,10 +366,14 @@ fun Home(navHostController: NavHostController, activity: ComponentActivity) {
         IconButton(
             onClick = {
                 Log.d("isConnect_State", "onClick{} -> $isConnect")
+                Log.d("isConnect_State_vpn", "onClick{} -> $isConnect")
+
                 if (isConnect == App.CONNECTED || isConnect == App.CONNECTING) {
+                    Log.d("isConnect_State_vpn", "stopVPN")
                     vpnConnectionsUtil.stopVpn()
                     homeViewModel.getIp()
                 } else {
+                    Log.d("isConnect_State_vpn", "startVPN")
                     vpnConnectionsUtil.startVpn()
                 }
 

app/src/main/java/com/vpn/fastestvpnservice/screens/bottomNavBarScreens/SettingsScreen.kt

@@ -199,6 +199,8 @@ private fun gotoVPNSettings(context: Context) {
 
 @Composable
 fun ColumnScope.AddRowSwitch(icon: Int, text: String) {
+    val context = LocalContext.current
+    val basePreferenceHelper = BasePreferenceHelper(context)
     Row(
         modifier = Modifier
             .fillMaxWidth()
@@ -245,11 +247,12 @@ fun ColumnScope.AddRowSwitch(icon: Int, text: String) {
                 .align(Alignment.CenterVertically),
             color = Color.Transparent
         ) {
-            var isSwitch by remember { mutableStateOf(false) }
+            var isSwitch by remember { mutableStateOf(basePreferenceHelper.getAdBlockState()) }
             Switch(
                 checked = isSwitch,
                 onCheckedChange = {
                     isSwitch = it
+                    basePreferenceHelper.saveAdBlockState(it)
                 },
                 modifier = Modifier.scale(0.8F),
                 colors = SwitchDefaults.colors(

app/src/main/java/com/vpn/fastestvpnservice/utils/StaticMethods.java

@@ -0,0 +1,31 @@
+package com.vpn.fastestvpnservice.utils;
+
+import static android.content.Context.UI_MODE_SERVICE;
+import static android.content.res.Configuration.UI_MODE_TYPE_TELEVISION;
+
+import android.app.Activity;
+import android.app.UiModeManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.widget.Toast;
+
+public class StaticMethods {
+
+    public static int pixToDp(int dp) {
+        return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
+    }
+
+    public static boolean isTV(Activity activity) {
+        UiModeManager uiModeManager = (UiModeManager) activity.getSystemService(UI_MODE_SERVICE);
+        return uiModeManager != null && uiModeManager.getCurrentModeType() == UI_MODE_TYPE_TELEVISION;
+    }
+
+    public static boolean isPhone(Activity activity) {
+        return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY);
+    }
+
+    public static void showToast(Context context, String message) {
+        Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
+    }
+}

app/src/main/java/com/vpn/fastestvpnservice/utils/VPNConnectionsUtil.kt

@@ -1,18 +1,35 @@
 package com.vpn.fastestvpnservice.utils
 
+import android.app.Activity
+import android.content.BroadcastReceiver
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
 import android.content.ServiceConnection
+import android.content.pm.PackageManager
 import android.net.ConnectivityManager
 import android.net.NetworkCapabilities
 import android.os.AsyncTask
+import android.os.Build
+import android.os.CountDownTimer
 import android.os.IBinder
+import android.os.RemoteException
 import android.util.Log
 import androidx.activity.ComponentActivity
+import androidx.compose.runtime.livedata.observeAsState
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.vpn.fastestvpnservice.MainActivity
+import com.vpn.fastestvpnservice.R
+import com.vpn.fastestvpnservice.constants.AppConstant
 import de.blinkt.openvpn.core.App
 import com.vpn.fastestvpnservice.constants.AppEnum
+import com.vpn.fastestvpnservice.constants.splitList
 import com.vpn.fastestvpnservice.helpers.BasePreferenceHelper
+import com.vpn.fastestvpnservice.helpers.UIHelper
+import com.vpn.fastestvpnservice.openVpnUtils.EncryptData
 import com.vpn.fastestvpnservice.viewmodels.HomeViewModel
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.GoBackend
@@ -22,20 +39,33 @@ import com.wireguard.config.InetEndpoint
 import com.wireguard.config.InetNetwork
 import com.wireguard.config.Interface
 import com.wireguard.config.Peer
+import de.blinkt.openvpn.LaunchVPN
 import de.blinkt.openvpn.VpnProfile
 import de.blinkt.openvpn.core.ConfigParser
+import de.blinkt.openvpn.core.ConnectionStatus
 import de.blinkt.openvpn.core.IOpenVPNServiceInternal
+import de.blinkt.openvpn.core.OpenVPNService
 import de.blinkt.openvpn.core.ProfileManager
+import de.blinkt.openvpn.core.VpnStatus
+import org.json.JSONObject
+import org.strongswan.android.logic.CharonVpnService
+import org.strongswan.android.ui.VpnProfileControlActivity
 import wireguard.WgTunnel
 import java.io.BufferedReader
 import java.io.InputStream
+import java.io.InputStreamReader
+import java.util.SortedSet
+import java.util.TreeSet
 
-class VPNConnectionsUtil {
+class VPNConnectionsUtil: VpnStatus.StateListener {
 
     var context: Context
     var activity: ComponentActivity
     var basePreferenceHelper: BasePreferenceHelper
     var homeViewModel: HomeViewModel
+    var countDownTimer: CountDownTimer? = null
+
+    var isBound: Boolean = false
 
     /* WireGuard */
     var backend: Backend? = null
@@ -54,16 +84,21 @@ class VPNConnectionsUtil {
 
     private val mConnection: ServiceConnection = object : ServiceConnection {
         override fun onServiceConnected(className: ComponentName, service: IBinder) {
-            de.blinkt.openvpn.core.App.mService = IOpenVPNServiceInternal.Stub.asInterface(service)
-            Log.d("test_openvpn", "onServiceConnected: ${de.blinkt.openvpn.core.App.mService}")
+            App.mService = IOpenVPNServiceInternal.Stub.asInterface(service)
+            Log.d("test_openvpn", "onServiceConnected: ${App.mService} $isBound")
         }
 
         override fun onServiceDisconnected(arg0: ComponentName) {
-            de.blinkt.openvpn.core.App.mService = null
-            Log.d("test_openvpn", "onServiceDisconnected: ${de.blinkt.openvpn.core.App.mService}")
+            App.mService = null
+            Log.d("test_openvpn", "onServiceDisconnected: ${App.mService} $isBound")
         }
     }
 
+    /*IKEV2*/
+    private lateinit var ikevConnectionStatesReceiver: IkevConnectionStatesReceiver
+
+    var dnswg: String = ""
+
     constructor(context: Context, activity: ComponentActivity, homeViewModel: HomeViewModel) {
         this.context = context
         this.activity = activity
@@ -74,12 +109,185 @@ class VPNConnectionsUtil {
 
     fun startVpn() {
         Log.d("test_wg", "start vpn")
+        Log.d("isConnect_State_vpn", "startVPN util")
+
+        countDownTimer()
+        try {
+            if (CheckInternetConnection.getInternetConnection(context).isConnectedToInternet) {
+
+                if (basePreferenceHelper.getProtocol().title.contentEquals(AppEnum.IKEV2_PROTOCOL.key))
+                {
+
+                    basePreferenceHelper.getServerObject().let { server ->
+
+                        /*Connect IKEV2*/
+
+                        val intent = Intent(context, VpnProfileControlActivity::class.java)
+                        App.connection_status = App.CONNECTION_STATE_CONNECTING
+                        homeViewModel.setConnectState(App.CONNECTING)
+
+//                        val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
+//                        widgetIntent1.action = SimpleAppWidget.ACTION_CONNECTING_VPN
+//                        context.sendBroadcast(widgetIntent1)
+                        intent.action = VpnProfileControlActivity.START_PROFILE
+                        intent.putExtra(VpnProfileControlActivity.EXTRA_VPN_PROFILE_ID, server?.id)
+                        intent.putExtra(AppConstant.SERVER, Gson().toJson(server))
+                        intent.putExtra("username", basePreferenceHelper.getUser()?.userinfo?.email)
+                        intent.putExtra(
+                            "password", basePreferenceHelper.getPassword()
+                        )
+                        context.startActivity(intent)
+
+                    }
+                }
+                else if (basePreferenceHelper.getProtocol().title.toLowerCase()
+                        .contentEquals(AppEnum.WG_PROTOCOL.key.toLowerCase())
+                ) {
+
+                    /*Connect Wire-Guard*/
+                    MainActivity.isWGDown = true
+                    vpnWireGuardPermission(true)
+
+
+                } else {
+
+                    /*Connect UDP / TCP*/
+                    startTcpUDP()
 
-        if (basePreferenceHelper.getProtocol().title.toLowerCase()
-                .contentEquals(AppEnum.WG_PROTOCOL.key.toLowerCase())
-        ) {
-            Log.d("test_wg", "WG protocol")
-            vpnWireGuardPermission(true)
+                }
+            }
+
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    fun startTcpUDP() {
+        Log.d("Auto test connect", "ACTION_VPN_SERVER_NOT_RESPONDING startTcpUDP")
+
+
+        /*Connect UDP,TCP*/
+        App.connection_status = App.CONNECTION_STATE_CONNECTING
+        homeViewModel.setConnectState(App.CONNECTING)
+
+//        val widgetIntent = Intent(context, SimpleAppWidget::class.java)
+//        widgetIntent.action = SimpleAppWidget.ACTION_CONNECTING_VPN
+//        context.sendBroadcast(widgetIntent)
+        App.isShowNotify = true
+        countDownTimer?.start()
+
+        try {
+            inputStream = null
+            bufferedReader = null
+            inputStream = getJsonFileDetails()
+            assert(inputStream != null)
+            bufferedReader =
+                BufferedReader(InputStreamReader(inputStream /*, Charset.forName("UTF-8")*/))
+            cp = ConfigParser(context)
+            cp!!.parseConfig(bufferedReader)
+            vp = cp!!.convertProfile()
+
+            ///////////////// openvpn split tunneling start /////////////////
+            val type = object : TypeToken<SortedSet<String?>?>() {}.type
+
+            val selectedApps = Gson().fromJson<SortedSet<String>>(
+                basePreferenceHelper.getSplitTunneledApps(), type
+            )
+            val selectedAppsNoVpn = Gson().fromJson<SortedSet<String>>(
+                basePreferenceHelper.getSplitTunneledAppsNotAllow(), type
+            )
+
+            if (StaticMethods.isTV(activity))                              // TV
+            {
+                val listEnable = basePreferenceHelper.getEnableTvAppsSplit()
+
+                if (listEnable?.size == 0) {
+                    Log.d("TCP/UDP Split Tunneling", "All apps")
+                }
+                else
+                {
+                    val appPackageName: SortedSet<String> = TreeSet()
+                    if (listEnable != null){
+                        for (i in listEnable.indices) {
+                            appPackageName.add(listEnable[i].appPackageName)
+                        }
+                    }
+
+                    if (appPackageName.size > 0)
+                    {
+                        for (app in appPackageName)
+                        {
+                            try {
+                                vp?.mAllowedAppsVpn?.add(app)
+                                Log.d("packages Vpn", app)
+                            } catch (e: PackageManager.NameNotFoundException) {
+                                e.printStackTrace()
+                            }
+                        }
+                    }
+                }
+            }
+            else{                                                           // Android
+                basePreferenceHelper.getSplitPosition().let {
+                    when (it) {
+                        splitList[0] -> {}
+                        splitList[1] -> {
+                            if (selectedApps != null && selectedApps.size > 0) {
+                                for (app in selectedApps) {
+                                    try {
+                                        vp?.mAllowedAppsVpn?.add(app)
+                                        Log.d("packages Vpn", app)
+                                    } catch (e: PackageManager.NameNotFoundException) {
+                                        e.printStackTrace()
+                                    }
+                                }
+                            }
+                        }
+                        splitList[2] -> {
+                            if (selectedAppsNoVpn != null && selectedAppsNoVpn.size > 0) {
+                                for (app in selectedAppsNoVpn) {
+                                    try {
+                                        vp?.mAllowedAppsVpn?.add(app)
+                                        Log.d("packages NoVpn", app)
+                                    } catch (e: PackageManager.NameNotFoundException) {
+                                        e.printStackTrace()
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            ///////////////// openvpn split tunneling end /////////////////
+            vp?.mAllowedAppsVpnAreDisallowed = false
+            val En = EncryptData()
+            val AppDetailsValues = En.decrypt(basePreferenceHelper.getAppDetails())
+
+            val json_response = JSONObject(AppDetailsValues)
+            val jsonArray = json_response.getJSONArray("blocked")
+            for (i in 0 until jsonArray.length()) {
+                val json_object = jsonArray.getJSONObject(i)
+                vp?.mAllowedAppsVpn?.add(json_object.getString("app"))
+                Log.e("packages end", json_object.getString("app"))
+            }
+
+            vp?.mName = Build.MODEL
+            vp?.mUsername = basePreferenceHelper.getUser()?.userinfo?.email
+            vp?.mPassword = basePreferenceHelper.getPassword()
+            pm = ProfileManager.getInstance(context)
+            pm?.addProfile(vp)
+            pm?.saveProfileList(context)
+            pm?.saveProfile(context, vp)
+            vp = pm?.getProfileByName(Build.MODEL)
+            val intent = Intent(context, LaunchVPN::class.java)
+            intent.putExtra(LaunchVPN.EXTRA_KEY, vp?.uuid.toString())
+            intent.action = Intent.ACTION_MAIN
+            context.startActivity(intent)
+        }
+        catch (e: Exception) {
+            e.printStackTrace()
+            Log.d("test_openvpn", "catch = ${e.printStackTrace()}")
         }
     }
 
@@ -163,14 +371,270 @@ class VPNConnectionsUtil {
 
     fun stopVpn() {
         Log.d("test_wg", "stop vpn")
-        if (basePreferenceHelper.getProtocol().title.toLowerCase()
-                .contentEquals(AppEnum.WG_PROTOCOL.key.toLowerCase())
-        )
-        {
-            vpnWireGuardPermission(false)
+        Log.d("isConnect_State_vpn", "stopVpn Util")
+
+
+        try {
+//            Log.d("App.connection stop", App.connection_status.toString())
+
+            /*Disconnect IKEV2*/
+            if (basePreferenceHelper.getProtocol().title.contentEquals(AppEnum.IKEV2_PROTOCOL.key)) {
+                Log.d("App stop ikev2", "1")
+                val intent = Intent(context, VpnProfileControlActivity::class.java)
+                Log.d("App stop ikev2", "2")
+                intent.action = VpnProfileControlActivity.DISCONNECT
+                Log.d("App stop ikev2", "3")
+                context.startActivity(intent)
+                Log.d("App stop ikev2", "4")
+            }
+            /*Disconnect Wireguard*/
+            else if (basePreferenceHelper.getProtocol().title.toLowerCase()
+                    .contentEquals(AppEnum.WG_PROTOCOL.key.toLowerCase())
+            )
+            {
+                vpnWireGuardPermission(false)
+
+            } else {
+                /*Disconnect TCP,UDP*/
+                App.connection_status = App.CONNECTION_STATE_DISCONNECTED
+                homeViewModel.setConnectState(App.DISCONNECTED)
+
+//            val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
+//            widgetIntent1.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
+//            context.sendBroadcast(widgetIntent1)
+
+                App.isShowNotify = false
+                OpenVPNService.abortConnectionVPN = true
+                ProfileManager.setConntectedVpnProfileDisconnected(context)
+                if (App.mService != null) {
+                    Log.d("test_openvpn", "if => ${App.mService}")
+                    try {
+                        Log.d("test_openvpn", "try => ${App.mService}")
+                        App.mService!!.stopVPN(false)
+                    } catch (e: RemoteException) {
+                        e.printStackTrace()
+                    }
+                    try {
+                        pm = ProfileManager.getInstance(context)
+                        vp = pm?.getProfileByName(Build.MODEL)
+                        pm?.removeProfile(context, vp)
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                    }
+                }
+            }
+
+
+
+
+
+
+
+//            val widgetIntent = Intent(context, SimpleAppWidget::class.java)
+//            widgetIntent.action = SimpleAppWidget.ACTION_STOP_SERVICE
+//            context.sendBroadcast(widgetIntent)
+
+        } catch (e: Exception) {
+            e.printStackTrace()
         }
     }
 
+    fun countDownTimer() {
+        countDownTimer = object : CountDownTimer(32000, 1000) {
+            override fun onTick(millisUntilFinished: Long) {
+                if (App.connection_status == App.CONNECTION_STATE_CONNECTED
+                    || App.connection_status == App.CONNECTION_STATE_CONNECTED_2) {
+                    countDownTimer!!.cancel()
+
+//                    val widgetIntent = Intent(context, SimpleAppWidget::class.java)
+//                    widgetIntent.action = SimpleAppWidget.ACTION_CONNECT_VPN
+//                    context.sendBroadcast(widgetIntent)
+                }
+                else if (App.connection_status == App.CONNECTION_STATE_DISCONNECTED) {
+                    countDownTimer!!.cancel()
+
+//                    val widgetIntent = Intent(context, SimpleAppWidget::class.java)
+//                    widgetIntent.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
+//                    context.sendBroadcast(widgetIntent)
+                }
+            }
+
+            override fun onFinish() {
+                if (App.connection_status == App.CONNECTION_STATE_CONNECTING) {
+                    UIHelper.showToast(R.string.server_not_responding)
+                    stopVpn()
+                }
+            }
+        }
+    }
+
+    inner class IkevConnectionStatesReceiver : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent != null && intent.action != null) {
+                val action = intent.action
+                when (action) {
+                    CharonVpnService.ACTION_VPN_CONNECTED -> {
+                        val connectState = homeViewModel.isConnect.value
+
+                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_CONNECTED $connectState")
+                        App.connection_status = App.CONNECTION_STATE_CONNECTED
+                        homeViewModel.setConnectState(App.CONNECTED)
+
+//                        vpnConnectionCallBacks.onVpnConnected()
+//                        MainActivity.vpnConnectionCallBacks?.onVpnConnected()
+//
+//                        val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
+//                        widgetIntent1.action = SimpleAppWidget.ACTION_CONNECT_VPN
+//                        context?.sendBroadcast(widgetIntent1)
+                    }
+                    CharonVpnService.ACTION_VPN_DISCONNECTED -> {
+                        val connectState = homeViewModel.isConnect.value
+                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_DISCONNECTED $connectState")
+
+                        if (connectState == App.CONNECTING) {
+                            App.connection_status = App.CONNECTION_STATE_CONNECTING
+                            homeViewModel.setConnectState(App.CONNECTING)
+                        }
+//                        else if (connectState == App.DISCONNECTED) {
+//                            App.connection_status = App.CONNECTION_STATE_DISCONNECTED
+//                            homeViewModel.setConnectState(App.DISCONNECTED)
+//                        }
+                        else if (connectState == App.CONNECTED) {
+                            Log.d("vpnConnectionCall_ip", "connectState == App.CONNECTED $connectState")
+                            App.connection_status = App.CONNECTION_STATE_DISCONNECTED
+                            homeViewModel.setConnectState(App.DISCONNECTED)
+                        }
+
+//                        vpnConnectionCallBacks.onVpnDisconnected()
+//                        MainActivity.vpnConnectionCallBacks?.onVpnDisconnected()
+//
+//                        val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
+//                        widgetIntent1.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
+//                        context?.sendBroadcast(widgetIntent1)
+
+                        homeViewModel.getIp()
+                    }
+                    CharonVpnService.ACTION_VPN_CONNECTING -> {
+                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_CONNECTING")
+                        App.connection_status = App.CONNECTION_STATE_CONNECTING
+                        homeViewModel.setConnectState(App.CONNECTING)
+
+//                        vpnConnectionCallBacks.onVpnConnecting()
+//                        MainActivity.vpnConnectionCallBacks?.onVpnConnecting()
+//
+//                        val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
+//                        widgetIntent1.action = SimpleAppWidget.ACTION_CONNECTING_VPN
+//                        context?.sendBroadcast(widgetIntent1)
+                    }
+                    CharonVpnService.ACTION_VPN_SERVER_NOT_RESPONDING -> {
+                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_SERVER_NOT_RESPONDING")
+                        App.connection_status = App.CONNECTION_STATE_SERVER_NOT_RESPONDING
+
+//                        vpnConnectionCallBacks.onServerNotResponding()
+//                        MainActivity.vpnConnectionCallBacks?.onServerNotResponding()
+                    }
+                }
+            }
+        }
+    }
+
+    fun onStopCallBack() {
+        Log.d("test_home_resume", "onStopCallBack!")
+        VpnStatus.removeStateListener(this)
+    }
+
+    fun onResumeCallBack() {
+        Log.d("test_home_resume", "onResumeCallBack!")
+
+        try {
+            Log.d("test_openvpn", "mConnection = $mConnection")
+            VpnStatus.addStateListener(this)
+            val intent = Intent(context, OpenVPNService::class.java)
+            intent.action = OpenVPNService.START_SERVICE
+            if (!isBound) {
+                Log.d("test_openvpn", "mConnection = $mConnection")
+                Log.d("test_openvpn", "bindServ:: isBound = $isBound")
+                context.bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
+                isBound = true
+                Log.d("test_openvpn", "bindServ2:: isBound = $isBound")
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+//        //setting receiver to listen ikev2 protocol connection states
+
+//        App.createIKEV2Listener()
+
+        /* Currently Commenting ... */
+//        try {
+//            LocalBroadcastManager.getInstance(context)
+//                .unregisterReceiver(WireGuardService.ikevConnectionStatesReceiver)
+//
+//        } catch (e: Exception) {
+//            e.printStackTrace()
+//        }
+
+        try {
+            ikevConnectionStatesReceiver = IkevConnectionStatesReceiver()
+            Log.d("test_home_resume", "ikevConnectionStatesReceiver: $ikevConnectionStatesReceiver")
+            val filter = IntentFilter()
+            filter.addAction(CharonVpnService.ACTION_VPN_CONNECTED)
+            filter.addAction(CharonVpnService.ACTION_VPN_DISCONNECTED)
+            filter.addAction(CharonVpnService.ACTION_VPN_CONNECTING)
+            filter.addAction(CharonVpnService.ACTION_VPN_SERVER_NOT_RESPONDING)
+            LocalBroadcastManager.getInstance(context)
+                .registerReceiver(ikevConnectionStatesReceiver, filter)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    fun onPauseCallBack() {
+        Log.d("test_home_resume", "onPauseCallBack!")
+        Log.d("test_openvpn", "pause:: mConnection = $mConnection")
+        Log.d("test_openvpn", "pause:: context = $context")
+
+        // TODO uncomment_this_JC
+        if (isBound) {
+            Log.d("test_openvpn", "pause1:: isBound = $isBound")
+            context.unbindService(mConnection)
+        } else {
+            Log.d("test_openvpn", "pause2:: isBound = $isBound")
+
+        }
+
+//        removing receiver to listen ikev2 protocol connection states
+
+        // Commenting Below Just Now ... !!!
+
+        try {
+            Log.d("test_home_resume", "onPause = ikevConnectionStatesReceiver: $ikevConnectionStatesReceiver")
+            LocalBroadcastManager.getInstance(context)
+                .unregisterReceiver(ikevConnectionStatesReceiver)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun getJsonFileDetails(): InputStream? {
+        var conf: InputStream? = null
+        try {
+            conf = if (basePreferenceHelper.getProtocol().title.equals(AppEnum.TCP_PROTOCOL.key)) {
+                context.assets.open("fileDetails/tcp.ovpn")
+            } else {
+                context.assets.open("fileDetails/udp.ovpn")
+            }
+
+            Log.d("test_openvpn", "conf = $conf")
+
+            return conf
+        } catch (e: java.lang.Exception) {
+            e.printStackTrace()
+        }
+        return null
+    }
+
     fun isVPNConnected(): Boolean {
         try {
             val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
@@ -187,4 +651,19 @@ class VPNConnectionsUtil {
         return false
     }
 
+    override fun updateState(
+        state: String?,
+        logmessage: String?,
+        localizedResId: Int,
+        level: ConnectionStatus?
+    ) {
+        if (level == ConnectionStatus.LEVEL_NOTCONNECTED) {
+            Log.d("vpnConnectionCall ip", "LEVEL_NOTCONNECTED")
+
+            homeViewModel.getIp()
+        }
+    }
+
+    override fun setConnectedVPN(uuid: String?) {}
+
 }

app/src/main/java/de/blinkt/openvpn/core/App.java

@@ -8,6 +8,7 @@ import android.app.Application;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.content.Context;
+import android.content.ServiceConnection;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.os.Build;
@@ -64,6 +65,7 @@ public class App extends /*com.orm.SugarApp*/ Application {
     public static Config.Builder config;
     public static App mInstance = null;
     public static IOpenVPNServiceInternal mService = null;
+    public static ServiceConnection mConnection = null;
 
     public static final int DISCONNECTED = 0;
     public static final int CONNECTING = 1;

app/src/main/res/values/themes.xml

@@ -4,4 +4,16 @@
         <item name="android:windowDisablePreview">true</item>
         <item name="android:windowBackground">@color/light_blue</item>
     </style>
+
+    <!-- strongswan -->
+    <style name="TransparentActivity" parent="Theme.AppCompat.Light.NoActionBar">
+        <item name="android:backgroundDimEnabled">false</item>
+        <item name="android:colorBackgroundCacheHint">@null</item>
+        <!--        <item name="android:windowAnimationStyle">@android:style/Animation</item>-->
+        <item name="android:windowAnimationStyle">@null</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowIsFloating">true</item>
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowNoTitle">true</item>
+    </style>
 </resources>