Android中同步等待OkHttpClient网络请求的有效策略

import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class SecondaryActivity extends AppCompatActivity {

    private String apiResponseData = null; // 用于存储网络请求结果

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_secondary); // 假设有一个布局

        // 在后台线程中执行网络请求和等待逻辑
        new Thread(new Runnable() {
            @Override
            public void run() {
                performNetworkRequestAndWait();
                // 网络请求完成后，可以在这里处理数据并关闭Activity
                // 注意：UI操作仍需回到主线程
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        if (apiResponseData != null) {
                            // 处理获取到的数据，例如更新UI或设置结果
                            System.out.println("Received data: " + apiResponseData);
                            // 示例：设置结果并关闭Activity
                            // Intent resultIntent = new Intent();
                            // resultIntent.putExtra("data", apiResponseData);
                            // setResult(RESULT_OK, resultIntent);
                            // finish();
                        } else {
                            System.out.println("Failed to retrieve data.");
                            // setResult(RESULT_CANCELED);
                            // finish();
                        }
                    }
                });
            }
        }).start();
    }

    private void performNetworkRequestAndWait() {
        // 创建一个CountDownLatch，计数器为1
        CountDownLatch latch = new CountDownLatch(1);

        OkHttpClient client = new OkHttpClient();
        // 假设someRequest是一个JSON字符串
        String someRequest = "{ \"key\": \"value\" }";
        RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), someRequest);
        String myURL = "https://api.example.com/data"; // 替换为你的API地址
        Request request = new Request.Builder().url(myURL).post(body).build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {
                System.err.println("Network request failed: " + e.getMessage());
                apiResponseData = null; // 请求失败，数据为空
                latch.countDown(); // 无论成功失败，都要释放latch
            }

            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                if (response.isSuccessful() && response.body() != null) {
                    apiResponseData = response.body().string();
                    System.out.println("Network response: " + apiResponseData);
                } else {
                    System.err.println("Network request unsuccessful: " + response.code());
                    apiResponseData = null;
                }
                latch.countDown(); // 无论成功失败，都要释放latch
            }
        });

        try {
            // 等待网络请求完成，最多等待10秒
            // await()方法会阻塞当前线程，直到latch.countDown()被调用或超时
            boolean completed = latch.await(10, TimeUnit.SECONDS);
            if (!completed) {
                System.err.println("Network request timed out.");
                apiResponseData = null; // 超时，数据为空
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断状态
            System.err.println("Waiting for network request was interrupted: " + e.getMessage());
            apiResponseData = null; // 中断，数据为空
        }
        // 在此处，apiResponseData变量将包含网络请求的结果（如果成功且未超时）
        // 或者为null（如果失败、超时或中断）
    }
}