Gmail API Android快速入门示例扩展遇阻，寻求重构方案

我完全懂你的困扰！谷歌官方的这个示例为了演示完整流程把所有逻辑揉在了一起，确实在实际项目里没法直接复用，尤其是要加多个API请求的时候，代码会变得一团糟。下面给你一套可行的重构方案，把认证逻辑和API请求彻底解耦，让扩展新API变得轻松很多：

第一步：把认证逻辑抽成独立的管理类 #

首先，把getResultsFromApi()里的所有认证相关操作（检查Play服务、账号选择、网络检查）封装成一个GoogleAuthManager，这样所有需要谷歌API的地方都能复用这套逻辑，不用重复写。这个类负责处理认证流程的所有细节，包括Activity跳转后的回调，然后通过回调通知调用方认证是否完成。

示例代码大概是这样：

public class GoogleAuthManager {
    private Context mContext;
    private GoogleAccountCredential mCredential;
    private AuthCallback mCallback;
    private static final int REQUEST_ACCOUNT_PICKER = 1000;

    public interface AuthCallback {
        void onAuthSuccess();
        void onAuthFailure(String errorMsg);
    }

    public GoogleAuthManager(Context context, GoogleAccountCredential credential) {
        mContext = context;
        mCredential = credential;
    }

    // 启动认证流程
    public void startAuth(AuthCallback callback) {
        mCallback = callback;
        if (!isGooglePlayServicesAvailable()) {
            acquireGooglePlayServices();
        } else if (mCredential.getSelectedAccountName() == null) {
            // 启动账号选择页面
            ((Activity)mContext).startActivityForResult(
                    mCredential.newChooseAccountIntent(),
                    REQUEST_ACCOUNT_PICKER);
        } else if (!isDeviceOnline()) {
            mCallback.onAuthFailure("No network connection available.");
        } else {
            // 认证条件都满足，回调成功
            mCallback.onAuthSuccess();
        }
    }

    // 处理Activity跳转后的结果，在Activity的onActivityResult里调用这个方法
    public void handleActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQUEST_ACCOUNT_PICKER && resultCode == Activity.RESULT_OK && data != null) {
            String accountName = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
            if (accountName != null) {
                mCredential.setSelectedAccountName(accountName);
                // 账号选择完成，重新触发认证检查
                startAuth(mCallback);
            }
        }
    }

    // 下面是原来的辅助方法，直接移过来就行
    private boolean isGooglePlayServicesAvailable() {
        // 原逻辑不变
    }

    private void acquireGooglePlayServices() {
        // 原逻辑不变
    }

    private boolean isDeviceOnline() {
        // 原逻辑不变
    }
}

第二步：把API请求抽象成独立任务 #

接下来，把每个API请求做成独立的任务类（这里沿用示例的AsyncTask风格，也可以替换成Coroutines/Retrofit等现代异步方案），让它们只负责具体的API调用逻辑，不用管认证。先写一个基类封装通用逻辑，再为每个API写子类：

// 基类，封装通用的请求逻辑
public abstract class GoogleApiTask<T> extends AsyncTask<Void, Void, T> {
    protected GoogleAccountCredential mCredential;
    protected ApiCallback<T> mCallback;

    public interface ApiCallback<T> {
        void onSuccess(T result);
        void onFailure(Exception e);
    }

    public GoogleApiTask(GoogleAccountCredential credential, ApiCallback<T> callback) {
        mCredential = credential;
        mCallback = callback;
    }

    @Override
    protected abstract T doInBackground(Void... voids);

    @Override
    protected void onPostExecute(T result) {
        if (result != null) {
            mCallback.onSuccess(result);
        } else {
            mCallback.onFailure(new Exception("Request failed"));
        }
    }
}

// 第一个API请求示例：获取用户信息
public class UserInfoTask extends GoogleApiTask<String> {
    public UserInfoTask(GoogleAccountCredential credential, ApiCallback<String> callback) {
        super(credential, callback);
    }

    @Override
    protected String doInBackground(Void... voids) {
        try {
            // 这里写具体的API调用逻辑，比如调用People API
            HttpTransport transport = AndroidHttp.newCompatibleTransport();
            JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
            People service = new People.Builder(transport, jsonFactory, mCredential)
                    .setApplicationName("Your App Name")
                    .build();
            Person profile = service.people().get("people/me").execute();
            return profile.getDisplayName();
        } catch (IOException e) {
            mCallback.onFailure(e);
            return null;
        }
    }
}

// 第二个API请求示例：获取日历事件
public class CalendarEventsTask extends GoogleApiTask<List<String>> {
    public CalendarEventsTask(GoogleAccountCredential credential, ApiCallback<List<String>> callback) {
        super(credential, callback);
    }

    @Override
    protected List<String> doInBackground(Void... voids) {
        try {
            // 调用Calendar API的逻辑
            HttpTransport transport = AndroidHttp.newCompatibleTransport();
            JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
            Calendar service = new Calendar.Builder(transport, jsonFactory, mCredential)
                    .setApplicationName("Your App Name")
                    .build();
            Events events = service.events().list("primary").execute();
            List<String> eventTitles = new ArrayList<>();
            for (Event event : events.getItems()) {
                eventTitles.add(event.getSummary());
            }
            return eventTitles;
        } catch (IOException e) {
            mCallback.onFailure(e);
            return null;
        }
    }
}

第三步：在Activity里整合逻辑 #

现在你的Activity就变得非常简洁了，只需要初始化AuthManager，然后在按钮点击时触发认证，认证成功后执行对应的API请求：

public class MainActivity extends AppCompatActivity {
    private GoogleAccountCredential mCredential;
    private GoogleAuthManager mAuthManager;
    private TextView mOutputText;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mOutputText = findViewById(R.id.output_text);

        // 初始化Credential，和原来一样
        mCredential = GoogleAccountCredential.usingOAuth2(
                this, Arrays.asList(SCOPES))
                .setBackOff(new ExponentialBackOff());

        // 初始化AuthManager
        mAuthManager = new GoogleAuthManager(this, mCredential);
    }

    // 第一个按钮的点击事件：获取用户信息
    public void onGetUserInfoClick(View view) {
        mAuthManager.startAuth(new GoogleAuthManager.AuthCallback() {
            @Override
            public void onAuthSuccess() {
                // 认证成功，执行用户信息请求
                new UserInfoTask(mCredential, new GoogleApiTask.ApiCallback<String>() {
                    @Override
                    public void onSuccess(String result) {
                        mOutputText.setText("User Name: " + result);
                    }

                    @Override
                    public void onFailure(Exception e) {
                        mOutputText.setText("Error: " + e.getMessage());
                    }
                }).execute();
            }

            @Override
            public void onAuthFailure(String errorMsg) {
                mOutputText.setText(errorMsg);
            }
        });
    }

    // 第二个按钮的点击事件：获取日历事件
    public void onGetCalendarEventsClick(View view) {
        mAuthManager.startAuth(new GoogleAuthManager.AuthCallback() {
            @Override
            public void onAuthSuccess() {
                // 认证成功，执行日历请求
                new CalendarEventsTask(mCredential, new GoogleApiTask.ApiCallback<List<String>>() {
                    @Override
                    public void onSuccess(List<String> result) {
                        mOutputText.setText("Calendar Events: " + TextUtils.join("\n", result));
                    }

                    @Override
                    public void onFailure(Exception e) {
                        mOutputText.setText("Error: " + e.getMessage());
                    }
                }).execute();
            }

            @Override
            public void onAuthFailure(String errorMsg) {
                mOutputText.setText(errorMsg);
            }
        });
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        // 把结果交给AuthManager处理
        mAuthManager.handleActivityResult(requestCode, resultCode, data);
    }
}

重构后的好处 #

• 解耦认证与业务：认证逻辑只在GoogleAuthManager里维护，所有API请求都不用关心认证细节，只需要等待认证成功的回调。
• 轻松扩展新API：要加第三个API？只需要新建一个GoogleApiTask的子类，实现具体的请求逻辑就行，完全不用碰认证代码。
• 代码更清晰：Activity里只处理UI交互和回调分发，不会再出现多次调用getResultsFromApi()的混乱情况。

如果你的项目已经在使用Coroutines或者RxJava，还可以把AsyncTask换成更现代的异步方案，进一步提升代码的可读性和可维护性，不过上面的方案已经能解决你当前的核心问题了。

内容的提问来源于stack exchange，提问作者Rhubarb65