Android AsyncTask已随机停止工作

我有一个连接到XMPP的应用程序。每5分钟我就断开并重新连接一次（不要问，老板想要它…）-到目前为止，我有一个

AsyncTask

在后台完成这项任务，并且一直运行良好。然而，今天的情况不同了（请记住，代码已经有一段时间没有更改了！而且是通过SVN进行SC的，我已经检查过自上次发布以来没有发生任何更改）

今天，它将在5分钟后断开并启动连接，但仅在重新启动后。任何后续的尝试都不会费心去尝试

重新连接的runnable：

private final Runnable killConnection = new Runnable()
{
    @Override
    public void run()
    {
        synchronized(checkLock)
        {
            Log.d("BXC", "Killing connection and restarting");

            // Manually disconnect and restart the connection every 5 minutes
            destroyConnectionAndRestart();
            new LoginTask().execute();

            mHandler.postDelayed(this, mInterval5m);
        }
    }
};

以及AsynTask本身：

private class LoginTask extends AsyncTask<Void, Void, Void>
{
    @Override
    protected Void doInBackground(Void... params)
    {
        android.os.Debug.waitForDebugger();

        String deviceUsername = Utility.getAndroidID(GaggleApplication.getInstance());
        try
        {   
                //bConnecting = true;
                Log.d("BXC", "Beginning connection");
                synchronized(connectLock)
                {                   
                    // First ensure we've got a connection to work with first
                    if(Utility.hasActiveInternetConnection(getApplicationContext()) && 
                            ((!bConnecting) && (!Globals.backgroundXmppConnectorRunning)))
                    {                       
                        String randomResource = Utility.randomString();
                        setupConnection();

                        if(xConnection != null)
                        {
                            xConnection.connect();
                        }
                        else
                        {
                            bConnecting = false;
                            Globals.backgroundXmppConnectorRunning = false;
                            setupConnection();
                            xConnection.connect();
                        }

                        /*
                            I know, I know... Don't specify a resource, but more often than not, OpenFire, doesn't
                            specify a unique resource, so at least this way, if we disconnect and then reconnect, 
                            we're at least promised a resource that isn't being used already and leave OpenFire to 
                            remove it's own idle connections, after X minutes.
                         */                             
                        if(accountManager.supportsAccountCreation() && (!SystemProperties.getBoolean("accountCreated")))
                        {
                            Log.d("BXC", "Server supports registering custom user accounts");
                            accountManager.createAccount(deviceUsername, AppSettings.XMPP_KEYSTORE_PASSWORD);   
                            SystemProperties.setBoolean("accountCreated", true);
                        }

                        xConnection.login(deviceUsername, AppSettings.XMPP_KEYSTORE_PASSWORD, randomResource);                  
                        ChatManager.getInstanceFor(xConnection).addChatListener(new ChatManagerListener(){
                            @Override
                            public void chatCreated(final Chat chat, boolean createdLocally)
                            {
                                if(!createdLocally)
                                {
                                    // add chat listener //
                                    chat.addMessageListener(new BackgroundMessageListener(BackgroundXmppConnector.this));
                                }
                            }                           
                        });                 

                        Presence p = new Presence(Presence.Type.subscribe);
                        p.setStatus("Out and About");
                        xConnection.sendPacket(p);

                        mBuilder.setSmallIcon(android.R.drawable.presence_online)
                        .setContentTitle("Connected")
                        .setContentText("Connected to XMPP server");

                        mNotificationManager.notify(mNotificationId, mBuilder.build());

                        Roster r = xConnection.getRoster();                 
                        r.setSubscriptionMode(SubscriptionMode.accept_all);
                        r.createEntry(AppSettings.BOT_NAME, "AbleBot", null);
                        r.addRosterListener(new RosterListener(){

                            @Override
                            public void entriesAdded(Collection<String> addresses) 
                            {               
                                for(String s : addresses)
                                {
                                    Log.d("BXC", "Entries Added: " + s);
                                }
                            }

                            @Override
                            public void entriesDeleted(Collection<String> addresses) 
                            {
                                for(String s : addresses)
                                {
                                    Log.d("BXC", "Entries Deleted: " + s);
                                }                           
                            }

                            @Override
                            public void entriesUpdated(Collection<String> addresses) 
                            {   
                                for(String s : addresses)
                                {
                                    Log.d("BXC", "Entries updated: " + s);
                                }                           
                            }

                            @Override
                            public void presenceChanged(Presence presence) 
                            {   
                                Log.d("BXC", "PresenceChanged: " + presence.getFrom());
                            }                       
                        });
                    }   
                    else{
                        Log.i("BXC", "Already connected or in process of connecting. ");
                    }
            }
        }
        catch(IllegalStateException ex)
        {
            Log.e("BXC", "IllegalStateException -->");
            if(ex.getMessage().contains("Already logged in to server"))
            {
                Globals.backgroundXmppConnectorRunning = true;                      
            }
            else
            {
                Globals.backgroundXmppConnectorRunning = false;
                Utility.writeExceptionToLog(getApplicationContext(), ex);

                ex.printStackTrace();
            }
        }
        catch(XMPPException ex)
        {
            Log.e("BXC", "XMPPException -->");
            Globals.backgroundXmppConnectorRunning = false;
            Utility.writeExceptionToLog(getApplicationContext(), ex);
            ex.printStackTrace();
        }
        catch(NullPointerException ex)
        {
            Log.e("BXC", "NullPointerException -->");
            Globals.backgroundXmppConnectorRunning = false;
            Utility.writeExceptionToLog(getApplicationContext(), ex);
            ex.printStackTrace();
        }
        catch(Exception ex)
        {
            Log.e("BXC", "Exception -->");
            Globals.backgroundXmppConnectorRunning = false;
            Utility.writeToLog(getApplicationContext(), ex.toString());
            ex.printStackTrace();
        }               
        return null;
    }

    @Override
    protected void onPostExecute(Void ignored)
    {
        if(xConnection != null)
        {
            if(xConnection.isConnected() && (!xConnection.isSocketClosed()))
            {
                Log.i("BXC", "Logged in to XMPP Server");
                Globals.backgroundXmppConnectorRunning = true;

                ConnectionState cs = new ConnectionState(true);
                GaggleApplication.getBusInstance().post(cs);
                cs = null;

                // SEND A WHOAMI TO UPDATE DEVICE FRIENDLY NAME //
                WhoAmI wai = new WhoAmI();          
                Intent intent = new Intent(GaggleApplication.getInstance(), BackgroundXmppConnector.class);
                intent.putExtra("MESSAGEDATA", new Gson().toJson(
                        Utility.makeTransaction(GaggleApplication.getInstance(), MessageType.Type.WHOAMI, wai)));
                sendMessage(intent);
                Log.i("MAIN", "Sent WHOAMI transaction");                   

                mHandler.postDelayed(checkConnection, mInterval1m);
            }
            else
            {
                Log.e("BXC", "Unable to log into XMPP Server.");    
                Globals.backgroundXmppConnectorRunning = false;

                destroyConnectionAndRestart();
            }
        }
        else
        {
            Log.e("BXC", "Xmpp Connection object is null");
            Globals.backgroundXmppConnectorRunning = false;

            ConnectionState cs = new ConnectionState(false);
            GaggleApplication.getBusInstance().post(cs);
            cs = null;
        }
    }
}

私有类登录任务扩展异步任务
{
@凌驾
受保护的Void doInBackground（Void…参数）
{
android.os.Debug.waitForDebugger（）；
String deviceUsername=Utility.getAndroid（GaggleApplication.getInstance（））；
尝试
{   
//b连接=真；
Log.d（“BXC”，“开始连接”）；
已同步（连接锁）
{                   
//首先，首先确保我们有一个可以合作的连接
if（Utility.hasActiveInternetConnection（getApplicationContext（））&&
（（！b连接）和（！Globals.backgroundXmppConnectorRunning）））
{                       
String randomResource=Utility.randomString（）；
setupConnection（）；
如果（xConnection！=null）
{
connection.connect（）；
}
其他的
{
b连接=错误；
Globals.backgroundXmppConnectorRunning=false；
setupConnection（）；
connection.connect（）；
}
/*
我知道，我知道…不指定资源，但OpenFire通常不指定
指定一个唯一的资源，至少这样，如果我们断开连接，然后重新连接，
我们至少得到了一个尚未被使用的资源的承诺，并将OpenFire留给我们
在X分钟后删除它自己的空闲连接。
*/                             
if（accountManager.supportsAccountCreation（）&（！SystemProperties.getBoolean（“accountCreated”））
{
Log.d（“BXC”，“服务器支持注册自定义用户帐户”）；
accountManager.createAccount（设备用户名、AppSettings.XMPP\u密钥库\u密码）；
setBoolean（“accountCreated”，true）；
}
xConnection.login（设备用户名、AppSettings.XMPP\u密钥库\u密码、随机资源）；
getInstanceFor（xConnection）.addChatListener（新的ChatManagerListener（）{
@凌驾
已创建公共无效聊天室（最终聊天室，布尔值createdLocally）
{
如果（！createdLocally）
{
//添加聊天侦听器//
addMessageListener（新的BackgroundMessageListener（BackgroundXmppConnector.this））；
}
}                           
});                 
状态p=新状态（状态.Type.subscribe）；
p、 setStatus（“外出”）；
xConnection.sendPacket（p）；
mBuilder.setSmallIcon（android.R.drawable.presence_在线）
.setContentTitle（“已连接”）
.setContentText（“连接到XMPP服务器”）；
mNotificationManager.notify（mNotificationId，mBuilder.build（））；
花名册r=xConnection.get花名册（）；
r、 setSubscriptionMode（SubscriptionMode.accept_all）；
r、 createEntry（AppSettings.BOT_名称，“AbleBot”，null）；
r、 addRosterListener（新的RosterListener（）{
@凌驾
添加了公共无效项（收款地址）
{               
用于（字符串s:地址）
{
日志d（“BXC”，“添加的条目：”+s）；
}
}
@凌驾
已删除公共无效条目（集合地址）
{
用于（字符串s:地址）
{
Log.d（“BXC”，“删除的条目：”+s）；
}                           
}
@凌驾
已更新公共无效条目（收集地址）
{   
用于（字符串s:地址）
{
Log.d（“BXC”，“更新的条目：”+s）；
}                           
}
@凌驾
公共无效状态已更改（状态）
{   
Log.d（“BXC”，“PresenceChanged:+presence.getFrom（））；
}
public void createXMPPConn() {
        Log.i(TAG, "creating connection");
        if (!NetworkUtil.isNetworkAvailable(getApplicationContext())) {
            return;
        }

        Thread conn = new Thread(new Runnable() {

            private String mPwd;

            @Override
            public void run() {
                do {
                    Log.i(TAG, "Trying to create connection");
                    try {
                        ConnectionConfiguration config = new ConnectionConfiguration(URLConstants.XMPP_HOST,
                                URLConstants.XMPP_PORT);
                        config.setSASLAuthenticationEnabled(false);
                        config.setSecurityMode(SecurityMode.disabled);
                        mXMPPCon = new XMPPConnection(config);
                        mPwd = csp.getString(StringConstants.PASSWORD, "");

                        mXMPPCon.connect();
                        Log.i(TAG, "Connected ");
                        if (!mPwd.equals("") && !mXMPPCon.isAuthenticated()) {
                            mXMPPCon.login(csp.getString(StringConstants.PHONE_NUMBER, ""), mPwd);
                            initIncomingChat(getApplicationContext());
                            setStatus(getmXMPPCon(), true, "");
                            sendBroadCastAsLoginSuccess();
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // Rotate loop until app is not connected to XMPP and do
                    // login, if app is registered.

                } while (!mXMPPCon.isConnected() && !(mPwd.equals("") || mXMPPCon.isAuthenticated()));
            }

        });
        conn.start();

public void login(final XMPPConnection xmppCon, final IAuthenticationListener iAuthenticationListener,
            final String username, final String password) {

        Log.i(TAG, "login() " + username + " " + password);

        Thread loginThread = new Thread(new Runnable() {

            @Override
            public void run() {
                Looper.prepare();
                try {
                    xmppCon.login(username, password);
                    Log.i(TAG, "LOGIN SUCCESS");
                    sendLoginSuccess(iAuthenticationListener);

                } catch (XMPPException e) {
                    Log.i(TAG, e.getMessage());
                    if (e.getXMPPError() != null && e.getXMPPError().getCode() == ErrorConstants.ERROR_SERVERDOWN) {

                    } else if (e.getXMPPError() != null
                            && e.getXMPPError().getCode() == ErrorConstants.ERROR_NOTCONNECTED) {

                    } else {

                    }
                    Log.i(TAG, "LOGIN FAILURE");
                    sendLoginFailure(iAuthenticationListener);

                } catch (IllegalStateException e) {
                    if (xmppCon.isAuthenticated()) {
                        sendLoginSuccess(iAuthenticationListener);
                    } else {
                        e.printStackTrace();
                        sendLoginFailure(iAuthenticationListener);
                    }
                }
                Looper.loop();
                try {
                    Thread.currentThread().join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        loginThread.start();

    }