How to throttle internet speed (upload and download) in Android programmatically

Question

How to Limit the Internet Speed of a VPN Connection on Android programmatically.

I have managed to control the upload speed using the OpenVPN "shaper" option, but I want to control both upload and download speeds.

Thank you.

Bob · Accepted Answer

Android does not provide direct APIs for throttling network speed. You may consider using ThrottlingInterceptor and use it like :

OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(new ThrottlingInterceptor(1024 * 100)) // Limit to 100 KBps         
  .build();

TLDR;

. .. ...

This is a basic approach for handling bandwidth throttling :

1. Create the VPN Service Class

import android.app.PendingIntent;
import android.content.Intent;
import android.net.VpnService;
import android.os.ParcelFileDescriptor;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.TimeUnit;

public class MyVpnService extends VpnService implements Runnable {
    private Thread mThread;
    private ParcelFileDescriptor mInterface;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (mThread != null) {
            mThread.interrupt();
        }
        mThread = new Thread(this, "MyVpnThread");
        mThread.start();
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        if (mThread != null) {
            mThread.interrupt();
        }
        try {
            if (mInterface != null) {
                mInterface.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            // Configure the TUN interface
            Builder builder = new Builder();
            builder.addAddress("10.0.0.2", 24);
            builder.addRoute("0.0.0.0", 0);
            mInterface = builder.setSession("MyVPNService")
                    .setConfigureIntent(PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0))
                    .establish();

            // Packets to be sent are queued in this input stream.
            FileInputStream in = new FileInputStream(mInterface.getFileDescriptor());
            // Packets received need to be written to this output stream.
            FileOutputStream out = new FileOutputStream(mInterface.getFileDescriptor());

            // Allocate the buffer for a single packet.
            ByteBuffer packet = ByteBuffer.allocate(32767);

            while (true) {
                // Read the outgoing packet from the input stream.
                int length = in.read(packet.array());
                if (length > 0) {
                    // Process the packet
                    packet.limit(length);
                    processPacket(packet);

                    // Send the packet to the output stream.
                    out.write(packet.array(), 0, length);
                    packet.clear();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void processPacket(ByteBuffer packet) {
        // Desired bandwidth limit in bytes per second (100 KB/s)
        long bytesPerSecond = 102400; // 100 KBps

        // Calculate the time in nanoseconds that should elapse per byte
        long nanosPerByte = TimeUnit.SECONDS.toNanos(1) / bytesPerSecond;

        // The number of bytes in the packet
        int packetSize = packet.limit();

        // The expected time to send this packet
        long expectedTime = packetSize * nanosPerByte;

        // Introduce delay based on the expected time to throttle the speed
        try {
            Thread.sleep(TimeUnit.NANOSECONDS.toMillis(expectedTime));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Throttling interrupted", e);
        }
    }
}

2. Declate it in AndroidManifest.xml:

3. Start and stop the VPN service from activity :

import android.content.Intent;
import android.net.VpnService;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    private static final int VPN_REQUEST_CODE = 0x0F;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Intent intent = VpnService.prepare(this);
        if (intent != null) {
            startActivityForResult(intent, VPN_REQUEST_CODE);
        } else {
            onActivityResult(VPN_REQUEST_CODE, RESULT_OK, null);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == VPN_REQUEST_CODE && resultCode == RESULT_OK) {
            Intent intent = new Intent(this, MyVpnService.class);
            startService(intent);
        }
    }
}

Another Approach

1. As VPN Service (for deivce level interception)

a). Using `ThrottlingInterceptor` as a Service

class ThrottlingInterceptor(private val maxBytesPerSecond: Long) {

    private var bytesTransferred: Long = 0
    private var lastTime: Long = System.currentTimeMillis()

    @Synchronized
    fun shouldThrottle(packetSize: Int): Boolean {
        val currentTime = System.currentTimeMillis()
        if (currentTime - lastTime > 1000) {
            lastTime = currentTime
            bytesTransferred = 0
        }

        if (bytesTransferred + packetSize > maxBytesPerSecond) {
            return true
        }

        bytesTransferred += packetSize
        return false
    }

    @Synchronized
    fun reset() {
        lastTime = System.currentTimeMillis()
        bytesTransferred = 0
    }
}

b). Your service class

class MyVpnService : VpnService() {
    
    private val interceptor = ThrottlingInterceptor(100 * 1024 / 8) // 100 kbps

    override fun onCreate() {
        super.onCreate()
        // Initialize the VPN service here
    }

    private fun processPacket(packet: ByteBuffer) {
        val packetSize = packet.remaining()

        if (interceptor.shouldThrottle(packetSize)) {
            try {
                Thread.sleep(1000) // Sleep for 1 second to reset the limit
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
            interceptor.reset()
        }

        // Forward the packet
        forwardPacket(packet)
    }

    private fun forwardPacket(packet: ByteBuffer) {
        // Logic to forward packet to destination
    }
}

2. If need to restrict speed limit within your app

a). Interceptor class

import java.io.IOException;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okio.Buffer;
import okio.ForwardingSource;
import okio.Okio;
import okio.Source;

public class ThrottlingInterceptor implements Interceptor {

    private final long bytesPerSecond;

    public ThrottlingInterceptor(long bytesPerSecond) {
        this.bytesPerSecond = bytesPerSecond;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response originalResponse = chain.proceed(request);
        return originalResponse.newBuilder()
                .body(new ThrottlingResponseBody(originalResponse.body(), bytesPerSecond))
                .build();
    }

    private static class ThrottlingResponseBody extends okhttp3.ResponseBody {
        private final okhttp3.ResponseBody responseBody;
        private final long bytesPerSecond;
        private BufferedSource bufferedSource;

        public ThrottlingResponseBody(okhttp3.ResponseBody responseBody, long bytesPerSecond) {
            this.responseBody = responseBody;
            this.bytesPerSecond = bytesPerSecond;
        }

        @Override
        public okhttp3.MediaType contentType() {
            return responseBody.contentType();
        }

        @Override
        public long contentLength() {
            return responseBody.contentLength();
        }

        @Override
        public BufferedSource source() {
            if (bufferedSource == null) {
                bufferedSource = Okio.buffer(new ThrottlingSource(responseBody.source(), bytesPerSecond));
            }
            return bufferedSource;
        }

        private static class ThrottlingSource extends ForwardingSource {
            private final long bytesPerSecond;
            private long totalBytesRead = 0L;
            private long startTime = System.currentTimeMillis();

            ThrottlingSource(Source source, long bytesPerSecond) {
                super(source);
                this.bytesPerSecond = bytesPerSecond;
            }

            @Override
            public long read(Buffer sink, long byteCount) throws IOException {
                long bytesRead = super.read(sink, byteCount);
                if (bytesRead == -1) return -1;

                totalBytesRead += bytesRead;
                long elapsedTime = System.currentTimeMillis() - startTime;

                long expectedTime = (totalBytesRead * 1000) / bytesPerSecond;
                if (expectedTime > elapsedTime) {
                    try {
                        Thread.sleep(expectedTime - elapsedTime);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new IOException("Throttling interrupted", e);
                    }
                }

                return bytesRead;
            }
        }
    }
}

b). Do this in Activity OkHttpClient fucntion

Use OkHttpClient with ThrottlingInterceptor while requesting network request

OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(new ThrottlingInterceptor(1024 * 100)) // Limit to 100 KBps
        .build();

Request request = new Request.Builder()
        .url("https://your.api.endpoint")
        .build();

try (Response response = client.newCall(request).execute()) {
    // Handle the response
} catch (IOException e) {
    e.printStackTrace();
}

References

How to throttle internet speed (upload and download) in Android programmatically

Answers (1)

This is a basic approach for handling bandwidth throttling :

1. Create the VPN Service Class

2. Declate it in AndroidManifest.xml:

3. Start and stop the VPN service from activity :

Another Approach

1. As VPN Service (for deivce level interception)

a). Using `ThrottlingInterceptor` as a Service

b). Your service class

2. If need to restrict speed limit within your app

a). Interceptor class

b). Do this in Activity OkHttpClient fucntion

Related Questions

How to throttle internet speed (upload and download) in Android programmatically

Answers (1)

This is a basic approach for handling bandwidth throttling :

1. Create the VPN Service Class

2. Declate it in AndroidManifest.xml:

3. Start and stop the VPN service from activity :

Another Approach

1. As VPN Service (for deivce level interception)

a). Using ThrottlingInterceptor as a Service

b). Your service class

2. If need to restrict speed limit within your app

a). Interceptor class

b). Do this in Activity OkHttpClient fucntion

Related Questions

a). Using `ThrottlingInterceptor` as a Service