Gmail API认证后出现UserRecoverableAuthIOException问题求助

看起来你遇到的核心问题是用户的Gmail授权令牌在无交互情况下失效/被撤销，但你的邮件发送流程没有处理这种场景的恢复逻辑。虽然你在初始认证阶段处理了授权，但后续发送时没有捕获并处理UserRecoverableAuthIOException，导致用户遇到功能失效或非致命崩溃。

为什么会出现这个问题？ #

这种NeedPermission异常通常由以下场景触发：

• Google会自动撤销长期未使用的应用授权（比如用户几个月没用到你的邮件功能）
• 用户在Google账号的「第三方应用访问权限」列表中手动移除了你的应用授权（你已经复现的情况）
• OAuth令牌过期或自动刷新失败（虽然GoogleAccountCredential会自动处理令牌刷新，但偶尔会出现异常）
• 应用的OAuth范围变更后，旧令牌失效（不过你提到已经通过审核，这个可能性较低）

解决方案：完善发送流程的异常处理与授权恢复 #

1. 修复发送邮件时的异常捕获逻辑 #

在sendEmail()方法的IOException捕获块中，专门处理UserRecoverableAuthIOException，引导用户重新授权：

// 发送邮件的catch块修改为：
catch (IOException e) {
    e.printStackTrace();
    if (e instanceof UserRecoverableAuthIOException) {
        // 启动Google授权界面，让用户重新授予权限
        Intent recoverIntent = ((UserRecoverableAuthIOException) e).getIntent();
        startActivityForResult(recoverIntent, REQUEST_AUTHORIZATION);
    } else if (e instanceof SocketTimeoutException) {
        // 网络超时，提示用户检查网络或重试
        Toast.makeText(context, "网络连接超时，请稍后重试", Toast.LENGTH_SHORT).show();
    } else {
        // 其他通用IO错误处理
        Toast.makeText(context, "邮件发送失败，请检查账户设置", Toast.LENGTH_SHORT).show();
    }
}

2. 添加发送前的授权预检查 #

在正式构造和发送邮件前，先验证当前授权是否有效，提前发现问题并引导恢复，避免发送到一半才报错：

private void sendEmail(){
    GoogleAccountCredential mCredential = GoogleAccountCredential.usingOAuth2(
            context, Arrays.asList(SCOPES))
            .setBackOff(new ExponentialBackOff());
    String senderAccount = prefs.getString(Constants.SENDER_ACCOUNT, null);
    if(senderAccount == null) {
        Toast.makeText(context, "请先设置发件账户", Toast.LENGTH_SHORT).show();
        return;
    }
    mCredential.setSelectedAccount(new Account(senderAccount, BuildConfig.APPLICATION_ID));

    // 初始化服务对象
    HttpTransport transport = AndroidHttp.newCompatibleTransport();
    JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
    Gmail mGmailApiService = new Gmail.Builder(
            transport, jsonFactory, mCredential)
            .setApplicationName("My-App")
            .build();

    // ===== 新增：预检查授权有效性 =====
    new AsyncTask<Void, Void, Boolean>() {
        private Exception authError;

        @Override
        protected Boolean doInBackground(Void... voids) {
            try {
                // 尝试获取令牌，验证授权是否有效
                mCredential.getToken();
                return true;
            } catch (Exception e) {
                authError = e;
                return false;
            }
        }

        @Override
        protected void onPostExecute(Boolean isAuthValid) {
            if (isAuthValid) {
                // 授权有效，继续执行邮件发送逻辑
                proceedWithEmailSending(mGmailApiService, mCredential);
            } else {
                // 处理授权异常
                if (authError instanceof UserRecoverableAuthException || authError instanceof UserRecoverableAuthIOException) {
                    Intent recoverIntent = authError instanceof UserRecoverableAuthException 
                        ? ((UserRecoverableAuthException) authError).getIntent() 
                        : ((UserRecoverableAuthIOException) authError).getIntent();
                    startActivityForResult(recoverIntent, REQUEST_AUTHORIZATION);
                } else {
                    Toast.makeText(context, "授权已失效，请重新设置发件账户", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }.execute();
}

// 把原有的构造邮件、发送逻辑抽成独立方法
private void proceedWithEmailSending(Gmail mGmailApiService, GoogleAccountCredential mCredential) {
    com.google.api.services.gmail.model.Message message;
    try {
        // 原有的构造MimeMessage代码...
        Properties props = new Properties();
        Session session = Session.getDefaultInstance(props, null);
        MimeMessage mimeMessage = new MimeMessage(session);
        mimeMessage.setSubject("Test email");
        mimeMessage.setText("Hello this is an email sent from android");
        mimeMessage.setFrom(new InternetAddress(mCredential.getSelectedAccountName()));
        mimeMessage.setRecipients(javax.mail.Message.RecipientType.TO, InternetAddress.parse(mCredential.getSelectedAccountName()));

        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        mimeMessage.writeTo(bytes);
        String encodedEmail = Base64.encodeBase64URLSafeString(bytes.toByteArray());
        message = new com.google.api.services.gmail.model.Message();
        message.setRaw(encodedEmail);
    } catch (MessagingException | IOException e) {
        e.printStackTrace();
        Toast.makeText(context, "邮件构造失败", Toast.LENGTH_SHORT).show();
        return;
    }

    // 添加重试机制处理网络超时
    int retryCount = 3;
    boolean sendSuccess = false;
    ExponentialBackOff backOff = new ExponentialBackOff();

    while (retryCount > 0 && !sendSuccess) {
        try {
            mGmailApiService.users().messages().send("me", message).execute();
            sendSuccess = true;
            Toast.makeText(context, "邮件发送成功", Toast.LENGTH_SHORT).show();
        } catch (SocketTimeoutException e) {
            retryCount--;
            try {
                Thread.sleep(backOff.nextBackOffMillis());
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                break;
            }
        } catch (IOException e) {
            if (e instanceof UserRecoverableAuthIOException) {
                Intent recoverIntent = ((UserRecoverableAuthIOException) e).getIntent();
                startActivityForResult(recoverIntent, REQUEST_AUTHORIZATION);
            } else {
                Toast.makeText(context, "邮件发送失败", Toast.LENGTH_SHORT).show();
            }
            break;
        }
    }

    if (!sendSuccess && retryCount == 0) {
        Toast.makeText(context, "多次尝试发送失败，请检查网络", Toast.LENGTH_SHORT).show();
    }
}

3. 优化授权回调的处理逻辑 #

在onActivityResult中，当用户完成重新授权后，自动重新触发邮件发送，提升用户体验：

switch(requestCode) {
    // ... 其他case ...
    case REQUEST_AUTHORIZATION:
        if (resultCode == Activity.RESULT_OK) {
            // 授权成功，重新尝试发送邮件
            sendEmail();
        } else {
            // 用户取消授权，给出提示
            Toast.makeText(context, "需要授权才能发送邮件，请重新操作", Toast.LENGTH_SHORT).show();
        }
        break;
}

额外说明 #

• 对于SocketTimeoutException，添加指数退避的重试机制可以有效降低网络波动导致的失败率
• 长期来看，可以考虑将GoogleAccountCredential的实例进行全局复用，避免每次发送都重新创建，提升令牌刷新的稳定性

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