# Wireguard Transport ## Adding Wireguard transport support To enable Wireguard transport in your app, follow these steps: 1. Add the WireGuard Dependencies: 1. Open your app's build.gradle file. 2. Add the following dependencies to enable both the core SDK and Wireguard transport: Groovy ```groovy dependencies { implementation 'co.pango:sdk-core:{VERSION_NAME}' implementation 'co.pango:sdk-wireguard:{VERSION_NAME}' } ``` Kotlin ``` dependencies { implementation("co.pango:sdk-core:{VERSION_NAME}") implementation("co.pango:sdk-wireguard:{VERSION_NAME}") } ``` * `sdk-core`: This is the main SDK needed for core VPN functionality. * `sdk-wireguard`: This is the module that adds Wireguard transport support to your VPN setup. 2. Create a List of Transport Configurations: Define which transport protocols the SDK should support (e.g., Hydra, Wireguard). ```java List transports = new ArrayList<>(); transports.add(HydraTransportConfig.create()); transports.add(WireTransportConfig.create()); UnifiedSDK.update(transportConfigs, callback); ``` `UnifiedSDK.update(transports, callback);` : Passes the list of transports to the SDK to enable them. You can register both **Hydra** and **Wireguard** transports or just one, depending on your app's requirements. Once the dependencies are added, register the Wireguard transport in the SDK configuration. This allows the SDK to use Wireguard as a transport option. {% hint style="info" %} You can register both Hydra and Wireguard transports or just one of them. {% endhint %} 3. Start a VPN session using the Wireguard transport. 1. Initialize the SDK and Configure the VPN Session: Use UnifiedSdk.getInstance() to get the SDK instance and set up the VPN session configuration, including the server location and the Wireguard transport protocol. 2. Start the VPN: Start the VPN session using sdk.getVpn().start(). ```java UnifiedSdk sdk = UnifiedSdk.getInstance(clientInfo); SessionInfo session = new SessionConfig.Builder() .withLocation(UnifiedSDK.COUNTRY_OPTIMAL) .withReason(TrackingConstants.GprReasons.M_UI) .withTransport(WireguardTransport.TRANSPORT_ID) .build(); sdk.getVpn().start(session, new CompletableCallback() { @Override public void complete() { } @Override public void error(@NonNull VpnException e) { } }); ``` * `UnifiedSdk.getInstance()`: Initializes the SDK with your clientInfo. * `SessionConfig.Builder()`: Configures the session with the VPN server location, reason for starting the VPN, and the transport protocol (Wireguard). * `sdk.getVpn().start()`: Starts the VPN session using the specified configuration. * `CompletableCallback`: Handles the success or failure of starting the VPN session. ## Wireguard on Android 12+ (API 31+) On Android 12 (API 31) and higher, apps that use exact alarms need user permission to function correctly. Since Wireguard transport uses exact alarms internally, you must check for this permission and request it before starting a VPN session. 1. Check if the Permission Is Needed: Use the following code to determine if exact alarm permissions are required and whether they are already granted: Kotlin ```kotlin val shouldRequest = VERSION.SDK_INT >= VERSION_CODES.S && !getSystemService(AlarmManager::class.java).canScheduleExactAlarms() ``` * If `shouldRequest` is `true`, you need to ask the user for permission. Java ```java boolean shouldRequest = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && !((AlarmManager) getSystemService(Context.ALARM_SERVICE)).canScheduleExactAlarms(); ``` * `Build.VERSION.SDK_INT` and `Build.VERSION_CODES.S`: These Java constants are used to check the Android version (in this case, API level 31, Android 12). * `AlarmManager`: Cast the result of `getSystemService()` to `AlarmManager`for Java usage. ## Request Permission If permission is needed, launch the system settings activity to request the exact alarm permission: Kotlin ```kotlin if (VERSION.SDK_INT >= VERSION_CODES.S) { startActivity(Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM)) } ``` Make sure to handle the case where the user denies the permission request. You can check the permission status again before starting the VPN session and inform the user if the permission is required for Wireguard transport to work properly. Java ```java // Some code if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { startActivity(new Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM)); } ``` `startActivity()`: In Java/Groovy, we use `new Intent()` to create an intent and request permission to schedule exact alarms. ## Checking Permission Starting from Android 12+ (API 31+) (Android S+), apps that use exact alarms should request user permission. Wireguard transport internally uses exact alarms, so before using it on Android 12 or higher, you need to check if the permission was granted and request it if not before starting the VPN session. Here's how to check for the permission and request it if needed: Make sure to handle the case where the user denies the permission request. You can check the permission status again before starting the VPN session and inform the user if the permission is required for Wireguard transport to work properly. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://pango.gitbook.io/paas/sdk/vpn-sdk-for-android/features/wireguard-transport.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.