Android JavaMail检测服务器是否脱机

我目前正在开发一个带有后台服务的电子邮件应用程序，该服务与JavaMail空闲功能结合使用。后台服务通过每29分钟发出一次检查来保持空闲功能正常工作（因为正在使用的服务器（Exchange server））有时会在连接30分钟后断开连接

虽然这样做效果很好，但如果Exchange服务器处于脱机状态，则应用程序将继续尝试不确定地重新连接到IMAP文件夹。我注意到在凌晨3点到6点之间（典型的Exchange更新时间），数据使用量会出现峰值

为了避免数据使用量的增加，我希望实现这样的功能：应用程序应尝试三次重新连接到IMAP文件夹，然后向用户显示服务器脱机的警告，并在30分钟后重试新的连接尝试

为了实现这一点，我如何检测Exchange服务器是否实际处于脱机/更新状态？如果应用程序无法连接到IMAP文件夹，是否会引发任何异常？就像抛出异常一样，我可以保存一个局部int变量，并在每次抛出异常时将其递增一，然后在第三次向用户显示警报

我当前的代码实现如下所示：

public void checkInboxEmail(final String host, final String user, final String password) {

    Log.d(TAG, "checkEmail");

    this.host = host;
    this.user = user;
    this.password = password;

    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Log.d(TAG, "checkEmail - run()");

                long databaseRecords;

                //create properties field
                Properties properties = new Properties();
                properties.put("mail.store.protocol", "imaps");
                properties.put("mail.imaps.ssl.trust", "*");
                properties.put("mail.debug", "true");

                emailSession = Session.getInstance(properties, new Authenticator() {
                    protected PasswordAuthentication getPasswordAuthentication() {
                        return new PasswordAuthentication(user, password);
                    }
                });


                IMAPStore imapStore = (IMAPStore) emailSession.getStore("imaps");
                // imapStore.connect();

                imapStore.connect(host, user, password);

                if (imapStore.isConnected()) {
                    Log.d("MailPush", "Successfully connected to IMAP");
                } else {
                    Log.d("MailPush", "Not connected to IMAP");
                }

                final IMAPFolder folder = (IMAPFolder) imapStore.getFolder("Inbox");
                folder.open(IMAPFolder.READ_WRITE);

                databaseRecords = dbManager.getReceivedEmailRecordsCount();

                if (databaseRecords < folder.getMessageCount()) {
                    Log.d(TAG, "Receiving Mail...");
                    receiveMail(folder.getMessages());
                } else {
                    Log.d(TAG, "Records match.");
                }

                Folder[] fdr = imapStore.getDefaultFolder().list();
                for (Folder fd : fdr)
                    System.out.println(">> " + fd.getName());

                folder.addMessageCountListener(new MessageCountListener() {

                    public void messagesAdded(MessageCountEvent e) {

                        System.out.println("Message Added Event Fired");
                        Log.d(TAG, "MESSAGE TYPE: " + e.getType());
                        //ADDED = 1 & REMOVED = 2

                        try {
                            Message[] messages = e.getMessages();

                            System.out.println("messages.length---" + messages.length);

                            for (Message message : messages) {
                                if (!message.getFlags().contains(Flags.Flag.SEEN)) {

                                    //Message is new (hasn't been seen) > Message Details
                                    System.out.println("---------------------------------");
                                    System.out.println("Email Number " + (message.getMessageNumber()));
                                    System.out.println("Subject: " + message.getSubject());
                                    System.out.println("From: " + message.getFrom()[0]);
                                    System.out.println("Text: " + message.getContent().toString());

                                    String from = message.getFrom()[0].toString();

                                    String cc = InternetAddress.toString(message.getRecipients(Message.RecipientType.CC));
                                    Log.d(TAG, "CC 1: " + cc);

                                    Address[] recipients = message.getRecipients(Message.RecipientType.CC);
                                    cc = InternetAddress.toString(recipients);
                                    Log.d(TAG, "CC 2: " + cc);

                                    //Check Encryption Details > Add SEEN Flag > Add to database
                                    checkEncryption((MimeMessage) message, from, cc);
                                }
                            }
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }

                    public void messagesRemoved(MessageCountEvent e) {
                        System.out.println("Message Removed Event fired");
                    }
                });

                folder.addMessageChangedListener(new MessageChangedListener() {

                    public void messageChanged(MessageChangedEvent e) {
                        System.out.println("Message Changed Event fired");
                    }
                });

                startListening(folder);

                //close the store and folder objects
                //   emailFolder.close(false);
                //   store.close();

            } catch (NoSuchProviderException e) {
                e.printStackTrace();
            } catch (MessagingException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }).start();
}

private void startListening(IMAPFolder imapFolder) {
    Log.d(TAG, "startListening");

    // We need to create a new thread to keep alive the connection
    Thread t = new Thread(
            new KeepAliveRunnable(imapFolder), "IdleConnectionKeepAlive"
    );

    t.start();

    while (!Thread.interrupted()) {
        Log.d(TAG, "Starting IDLE");
        try {
            Log.d(TAG, "Setting IDLE");
            imapFolder.idle();
        } catch (FolderClosedException fex) {
            //Server closes connection.
            Log.d(TAG, "FolderClosedException. Server potentially dropped connection. Retrying connection...");
            fex.printStackTrace();

            if (!isServiceRunning(MyService.class)) {
                Log.d(TAG, "Service isn't running. Starting service...");

                //Start service
                Intent intent = new Intent(context, MyService.class);
                intent.putExtra("host", host);
                intent.putExtra("email", user);
                intent.putExtra("password", password);

                context.startService(intent);
            } else {
                Log.d(TAG, "Service is already running. Checking email...");
                checkInboxEmail(host, user, password);
            }
        } catch (MessagingException e) {
            //Idle isn't supported by server.
            Log.d(TAG, "Messaging exception during IDLE: ");
            e.printStackTrace();
        }
    }

    // Shutdown keep alive thread
    if (t.isAlive()) {
        Log.d(TAG, "Interrupting thread");
        t.interrupt();
    }
}

private static class KeepAliveRunnable implements Runnable {

    private final String TAG = getClass().getName();

    private static final long KEEP_ALIVE_FREQ = 60000 * 29; // 29 minutes (Exchange connection drops after 20-30 minutes)

    private IMAPFolder folder;

    KeepAliveRunnable(IMAPFolder folder) {
        this.folder = folder;
    }

    @Override
    public void run() {
        while (!Thread.interrupted()) {
            try {
                Thread.sleep(KEEP_ALIVE_FREQ);

                // Perform a messageCount check just to keep alive the connection
                Log.d(TAG, "Performing a messageCount check to keep the connection alive");
                folder.getMessageCount();
            } catch (InterruptedException e) {
                // Ignore, just aborting the thread...
                Log.d(TAG, "Interrupted...");
                e.printStackTrace();
            } catch (MessagingException e) {
                // Shouldn't really happen...
                Log.d(TAG, "Unexpected exception while keeping alive the IDLE connection");
                e.printStackTrace();
            }
        }
    }
}

private void receiveMail(Message[] messages) {
    try {

        System.out.println("messages.length---" + messages.length);

        for (Message message : messages) {
            if (!message.getFlags().contains(Flags.Flag.SEEN)) {

                //Message is new (hasn't been seen) > Message Details
                System.out.println("---------------------------------");
                System.out.println("Email Number " + (message.getMessageNumber()));
                System.out.println("Subject: " + message.getSubject());
                System.out.println("From: " + message.getFrom()[0]);
                System.out.println("Text: " + message.getContent().toString());

                String from = message.getFrom()[0].toString();
                String cc = InternetAddress.toString(message.getRecipients(Message.RecipientType.CC));

                //Check Encryption Details > Add SEEN Flag > Add to database
                checkEncryption((MimeMessage) message, from, cc);
            }
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

public void checkinbox邮件（最终字符串主机、最终字符串用户、最终字符串密码）{
Log.d（标签“checkEmail”）；
this.host=host；
this.user=用户；
this.password=密码；
新线程（newrunnable（））{
@凌驾
公开募捐{
试一试{
d（标记“checkEmail-run（）”）；
长数据库记录；
//创建属性字段
属性=新属性（）；
properties.put（“mail.store.protocol”、“imaps”）；
properties.put（“mail.imaps.ssl.trust”、“*”）；
properties.put（“mail.debug”、“true”）；
emailSession=Session.getInstance（属性，新验证器（）{
受保护的密码身份验证getPasswordAuthentication（）{
返回新的PasswordAuthentication（用户、密码）；
}
});
IMAPStore IMAPStore=（IMAPStore）emailSession.getStore（“imaps”）；
//imapStore.connect（）；
连接（主机、用户、密码）；
if（imapStore.isConnected（））{
Log.d（“邮件推送”，“成功连接到IMAP”）；
}否则{
Log.d（“邮件推送”，“未连接到IMAP”）；
}
最终IMAPFolder文件夹=（IMAPFolder）imapStore.getFolder（“收件箱”）；
文件夹。打开（IMAPFolder.READ_WRITE）；
databaseRecords=dbManager.getReceivedEmailRecordsCount（）；
if（databaseRecords>”+fd.getName（））；
folder.addMessageCountListener（新MessageCountListener（）{
public void messagesAdded（MessageCountEvent e）{
System.out.println（“消息添加事件激发”）；
Log.d（标记，“消息类型：+e.getType（））；
//添加=1，删除=2
试一试{
Message[]messages=e.getMessages（）；
System.out.println（“messages.length----”+messages.length）；
用于（消息：消息）{
如果（！message.getFlags（）.包含（Flags.Flag.SEEN））{
//消息是新的（尚未看到）>消息详细信息
System.out.println（“-------------------------------------”）；
System.out.println（“电子邮件号码”+（message.getMessageNumber（））；
System.out.println（“主题：+message.getSubject（））；
System.out.println（“From:”+message.getFrom（）[0]）；
System.out.println（“文本：+message.getContent（）.toString（））；
字符串from=message.getFrom（）[0].toString（）；
字符串cc=InternetAddress.toString（message.getRecipients（message.RecipientType.cc））；
日志d（标签“CC 1:”+CC）；
Address[]recipients=message.getRecipients（message.RecipientType.CC）；
cc=InternetAddress.toString（收件人）；
日志d（标签“CC 2:”+CC）；
//检查加密详细信息>添加可见标志>添加到数据库
checkEncryption（（mimessage）消息，发件人，抄送）；
}
}
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
公共无效消息删除（MessageCountEvent e）{
System.out.println（“触发消息删除事件”）；
}
});
folder.addMessageChangedListener（新的MessageChangedListener（）{
public void messageChanged（MessageChangedEvent e）{
System.out.println（“触发消息更改事件”）；
}
});