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

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.

1. Create a List of Transport Configurations: Define which transport protocols the SDK should support (e.g., Hydra, Wireguard).

List<TransportConfig> 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.

You can register both Hydra and Wireguard transports or just one of them.

1. 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().

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

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

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 AlarmManagerfor Java usage.

Request Permission

If permission is needed, launch the system settings activity to request the exact alarm permission:

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

// 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.