tencent cloud

import android.util.Log;
import com.tencent.qcloud.core.http.HttpLogger;
import com.tencent.qcloud.core.http.NetworkClient;
import com.tencent.qcloud.core.http.NetworkProxy;
import com.tencent.qcloud.core.http.QCloudHttpClient;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import javax.net.ssl.HostnameVerifier;
import okhttp3.Dns;
import okhttp3.Request;
import okio.BufferedSink;
import okio.Okio;

/**
 * Implement a custom network Client here.
 */
public class CustomizeNetworkClient extends NetworkClient {
    private static final String TAG = "CustomizeNetworkClient";

    private HttpURLConnectionManager httpURLConnectionManager;
    @Override
    public void init(QCloudHttpClient.Builder b, HostnameVerifier hostnameVerifier, Dns dns, HttpLogger httpLogger) {
        super.init(b, hostnameVerifier, dns, httpLogger);
        httpURLConnectionManager = new HttpURLConnectionManager();
    }

    @Override
    public NetworkProxy getNetworkProxy() {
        return new CustomizeNetworkProxy(httpURLConnectionManager);
    }

    public static class HttpURLConnectionManager {
        private static final int CONNECT_TIMEOUT = 5000;
        private static final int READ_TIMEOUT = 5000;

        public HttpURLConnection createConnection(Request request) throws IOException {
            Log.d("NetworkRequest", "Request URL: " + request.url());
            Log.d("NetworkRequest", "Request method: " + request.method());

            URL url = new URL(request.url().toString());
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            connection.setConnectTimeout(CONNECT_TIMEOUT);
            connection.setReadTimeout(READ_TIMEOUT);

            connection.setRequestMethod(request.method());

            // Set headers
            for (String name : request.headers().names()) {
                connection.setRequestProperty(name, request.header(name));
                Log.d("NetworkRequest", "Header: " + name + " = " + request.header(name));
            }

            // Set body
            if (request.body() != null) {
                connection.setDoOutput(true);
                try (OutputStream outputStream = connection.getOutputStream();
                     BufferedSink bufferedSink = Okio.buffer(Okio.sink(outputStream))) {
                    request.body().writeTo(bufferedSink);
                }
                Log.d("NetworkRequest", "Request body set");
            }

            return connection;
        }
    }
}

import android.text.TextUtils;
import android.util.Log;
import com.tencent.qcloud.core.http.NetworkProxy;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.util.List;
import java.util.Map;
import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.Protocol;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okio.BufferedSource;
import okio.Okio;

/**
 * Implement a network request here.
 */
public class CustomizeNetworkProxy<T> extends NetworkProxy<T> {
    private static final String TAG = "CustomizeNetworkProxy";
    private HttpURLConnection connection;
    private CustomizeNetworkClient.HttpURLConnectionManager httpURLConnectionManager;

    public CustomizeNetworkProxy(CustomizeNetworkClient.HttpURLConnectionManager httpURLConnectionManager) {
        this.httpURLConnectionManager = httpURLConnectionManager;
    }

    @Override
    protected void cancel() {
        if (connection != null) {
            connection.disconnect();
        }
    }

    @Override
    public Response callHttpRequest(Request okHttpRequest) throws IOException {
        try {
            connection = httpURLConnectionManager.createConnection(okHttpRequest);
            int responseCode = connection.getResponseCode();
            Log.d("NetworkRequest", "Response code: " + responseCode);
            Response response = convertToOkHttpResponse(connection);
            Log.d("NetworkRequest", "Response headers: " + response.headers());
            return response;
        } catch (IOException e) {
            Log.e("NetworkRequest", "Failed to execute HTTP request", e);
            throw e;
        }
    }

    @Override
    protected void disconnect(){
        if (connection != null) {
            connection.disconnect();
        }
    }

    private Response convertToOkHttpResponse(HttpURLConnection connection) throws IOException {
        int code = connection.getResponseCode();
        String message = connection.getResponseMessage();
        String contentType = connection.getContentType();
        int contentLength = connection.getContentLength();

        // Convert headers
        Headers.Builder headersBuilder = new Headers.Builder();
        Map<String, List<String>> headerFields = connection.getHeaderFields();
        for (Map.Entry<String, List<String>> entry : headerFields.entrySet()) {
            String name = entry.getKey();
            if (TextUtils.isEmpty(name)) continue;
            for (String value : entry.getValue()) {
                headersBuilder.add(name, value);
            }
        }
        Headers headers = headersBuilder.build();

        // Convert body
        BufferedSource source = Okio.buffer(Okio.source(connection.getInputStream()));
        ResponseBody body = new ResponseBody() {
            @Override
            public MediaType contentType() {
                if(TextUtils.isEmpty(contentType)){
                    return null;
                } else {
                    return MediaType.parse(contentType);
                }
            }

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

            @Override
            public BufferedSource source() {
                return source;
            }
        };

        // Build OkHttp Response
        Request request = new Request.Builder()
                .url(connection.getURL().toString())
                .build();

        return new Response.Builder()
                .request(request)
                .protocol(Protocol.HTTP_1_1)
                .code(code)
                .message(message)
                .headers(headers)
                .body(body)
                .build();
    }
}

CosXmlServiceConfig cosXmlServiceConfig = new CosXmlServiceConfig.Builder(
        .setRegion(region))
        // Other configurations remain unchanged.
        .setCustomizeNetworkClient(new CustomizeNetworkClient()) // Set the above-mentioned custom network client 
        .builder();