Search in sources :

Example 1 with ImErrorInfo

use of org.awesomeapp.messenger.model.ImErrorInfo in project Zom-Android by zom.

the class XmppConnection method doHeartbeat.

// Runs in executor thread
public void doHeartbeat(long heartbeatInterval) {
    heartbeatSequence++;
    if (getState() == SUSPENDED) {
        debug(TAG, "heartbeat during suspend");
        return;
    }
    if (mConnection == null && mRetryLogin) {
        debug(TAG, "reconnect with login");
        do_login();
        return;
    }
    if (mConnection == null)
        return;
    if (mNeedReconnect) {
        reconnect();
    } else if (!mConnection.isConnected() && getState() == LOGGED_IN) {
        // Smack failed to tell us about a disconnect
        debug(TAG, "reconnect on unreported state change");
        setState(LOGGING_IN, new ImErrorInfo(ImErrorInfo.NETWORK_ERROR, "network disconnected"));
        force_reconnect();
    } else if (getState() == LOGGED_IN) {
        if (PING_ENABLED) {
            // Check ping on every heartbeat.  checkPing() will return true immediately if we already checked.
            if (!mPingSuccess) {
                debug(TAG, "reconnect on ping failed: " + mUser.getAddress().getAddress());
                setState(LOGGING_IN, new ImErrorInfo(ImErrorInfo.NETWORK_ERROR, "network timeout"));
                maybe_reconnect();
            } else {
                // Send pings only at intervals configured by the user
                if (heartbeatSequence >= heartbeatInterval) {
                    heartbeatSequence = 0;
                    debug(TAG, "ping");
                    sendPing();
                }
            }
        }
    }
}
Also used : ImErrorInfo(org.awesomeapp.messenger.model.ImErrorInfo)

Example 2 with ImErrorInfo

use of org.awesomeapp.messenger.model.ImErrorInfo in project Zom-Android by zom.

the class XmppConnection method initConnection.

// Runs in executor thread
private void initConnection(Imps.ProviderSettings.QueryMap providerSettings, String userName) throws InterruptedException, NoSuchAlgorithmException, KeyManagementException, XMPPException, SmackException, IOException {
    // never! // providerSettings.getAllowPlainAuth();
    boolean allowPlainAuth = false;
    // providerSettings.getRequireTls(); //always!
    boolean requireTls = true;
    boolean doDnsSrv = providerSettings.getDoDnsSrv();
    // boolean tlsCertVerify = providerSettings.getTlsCertVerify();
    // boolean useSASL = true;//!allowPlainAuth;
    // boolean useProxy = providerSettings.getUseTor();
    String domain = providerSettings.getDomain();
    mPriority = providerSettings.getXmppResourcePrio();
    int serverPort = providerSettings.getPort();
    String server = providerSettings.getServer();
    if ("".equals(server))
        server = null;
    if (domain.equals("dukgo.com")) {
        doDnsSrv = false;
        server = "dukgo.com";
    }
    debug(TAG, "TLS required? " + requireTls);
    if (// if serverPort is set to 0 then use 5222 as default
    serverPort == 0)
        serverPort = 5222;
    mConfig = XMPPTCPConnectionConfiguration.builder();
    mConfig.setServiceName(JidCreate.domainBareFrom(domain));
    mConfig.setPort(serverPort);
    mConfig.setCompressionEnabled(true);
    mConfig.setConnectTimeout(CONNECT_TIMEOUT);
    mConfig.setXmppDomain(domain);
    mConfig.setHost(domain);
    if (!TextUtils.isEmpty(server))
        mConfig.setHost(server);
    if (!TextUtils.isEmpty(Preferences.getProxyServerHost())) {
        setProxy("SOCKS5", Preferences.getProxyServerHost(), Preferences.getProxyServerPort());
    } else if (Preferences.useAdvancedNetworking()) {
        setProxy("SOCKS5", "127.0.0.1", 31059);
    } else {
        mProxyInfo = null;
        // SRV lookup shouldn't be done through a proxy
        if (doDnsSrv) {
            // java.lang.System.setProperty("java.net.preferIPv4Stack", "true");
            // java.lang.System.setProperty("java.net.preferIPv6Addresses", "false");
            debug(TAG, "(DNS SRV) resolving: " + domain);
            List<HostAddress> listHostsFailed = new ArrayList<>();
            List<HostAddress> listHosts = DNSUtil.resolveXMPPServiceDomain(domain, listHostsFailed, ConnectionConfiguration.DnssecMode.disabled);
            if (listHosts.size() > 0) {
                server = listHosts.get(0).getFQDN();
                serverPort = listHosts.get(0).getPort();
                debug(TAG, "(DNS SRV) resolved: " + domain + "=" + server + ":" + serverPort);
                if (!TextUtils.isEmpty(server))
                    mConfig.setHost(server);
                if (serverPort != -1)
                    mConfig.setPort(serverPort);
            }
        }
        if (!TextUtils.isEmpty(server)) {
            try {
                String[] addressParts = server.split("\\.");
                if (Integer.parseInt(addressParts[0]) != -1) {
                    byte[] parts = new byte[addressParts.length];
                    for (int i = 0; i < 4; i++) parts[i] = (byte) Integer.parseInt(addressParts[i]);
                    byte[] ipAddr = new byte[] { parts[0], parts[1], parts[2], parts[3] };
                    InetAddress addr = InetAddress.getByAddress(ipAddr);
                    mConfig.setHostAddress(addr);
                } else {
                    mConfig.setHostAddress(InetAddress.getByName(server));
                }
            } catch (Exception e) {
                debug(TAG, "error parsing server as IP address; using as hostname instead");
                mConfig.setHostAddress(InetAddress.getByName(server));
            }
        }
    }
    mConfig.setProxyInfo(mProxyInfo);
    mConfig.setDebuggerEnabled(Debug.DEBUG_ENABLED);
    SmackConfiguration.DEBUG = Debug.DEBUG_ENABLED;
    SmackConfiguration.setDebuggerFactory(new SmackDebuggerFactory() {

        @Override
        public SmackDebugger create(XMPPConnection xmppConnection, Writer writer, Reader reader) throws IllegalArgumentException {
            return new AndroidDebugger(xmppConnection, writer, reader);
        }
    });
    // mConfig.setSASLAuthenticationEnabled(useSASL);
    // Android has no support for Kerberos or GSSAPI, so disable completely
    SASLAuthentication.unregisterSASLMechanism("KERBEROS_V4");
    SASLAuthentication.unregisterSASLMechanism("GSSAPI");
    if (allowPlainAuth)
        SASLAuthentication.unBlacklistSASLMechanism("PLAIN");
    SASLAuthentication.unBlacklistSASLMechanism("DIGEST-MD5");
    if (mMemTrust == null)
        mMemTrust = new MemorizingTrustManager(mContext);
    if (sslContext == null) {
        sslContext = SSLContext.getInstance(SSLCONTEXT_TYPE);
        secureRandom = new java.security.SecureRandom();
        sslContext.init(null, MemorizingTrustManager.getInstanceList(mContext), secureRandom);
        while (true) {
            try {
                if (Build.VERSION.SDK_INT >= 20) {
                    sslContext.getDefaultSSLParameters().setCipherSuites(XMPPCertPins.SSL_IDEAL_CIPHER_SUITES_API_20);
                } else {
                    sslContext.getDefaultSSLParameters().setCipherSuites(XMPPCertPins.SSL_IDEAL_CIPHER_SUITES);
                }
                break;
            } catch (IllegalStateException e) {
                debug(TAG, "error setting cipher suites; waiting for SSLContext to init...");
                try {
                    Thread.sleep(1000);
                } catch (Exception e2) {
                }
            }
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
            mConfig.setKeystoreType("AndroidCAStore");
            mConfig.setKeystorePath(null);
        } else {
            mConfig.setKeystoreType("BKS");
            String path = System.getProperty("javax.net.ssl.trustStore");
            if (path == null)
                path = System.getProperty("java.home") + File.separator + "etc" + File.separator + "security" + File.separator + "cacerts.bks";
            mConfig.setKeystorePath(path);
        }
        // wait a second while the ssl context init's
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
        }
    }
    int currentapiVersion = android.os.Build.VERSION.SDK_INT;
    if (currentapiVersion >= 16) {
        while (true) {
            try {
                mConfig.setEnabledSSLProtocols(new String[] { "TLSv1.2", "TLSv1.1", "TLSv1" });
                sslContext.getDefaultSSLParameters().setProtocols(new String[] { "TLSv1.2", "TLSv1.1", "TLSv1" });
                break;
            } catch (IllegalStateException ise) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                }
            }
        }
    }
    if (currentapiVersion >= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
        mConfig.setEnabledSSLCiphers(XMPPCertPins.SSL_IDEAL_CIPHER_SUITES);
    }
    mConfig.setCustomSSLContext(sslContext);
    mConfig.setSecurityMode(ConnectionConfiguration.SecurityMode.required);
    mConfig.setHostnameVerifier(mMemTrust.wrapHostnameVerifier(new org.apache.http.conn.ssl.StrictHostnameVerifier()));
    mConfig.setSendPresence(true);
    XMPPTCPConnection.setUseStreamManagementDefault(true);
    XMPPTCPConnection.setUseStreamManagementResumptiodDefault(true);
    mConnection = new XMPPTCPConnection(mConfig.build());
    DeliveryReceiptManager.getInstanceFor(mConnection).addReceiptReceivedListener(new ReceiptReceivedListener() {

        @Override
        public void onReceiptReceived(Jid fromJid, Jid toJid, String receiptId, Stanza receipt) {
            ChatSession session = mSessionManager.findSession(fromJid.asBareJid());
            if (session != null)
                session.onMessageReceipt(receiptId);
        }
    });
    mConnection.addSyncStanzaListener(new StanzaListener() {

        @Override
        public void processStanza(Stanza stanza) {
            debug(TAG, "receive message: " + stanza.getFrom() + " to " + stanza.getTo());
            org.jivesoftware.smack.packet.Message smackMessage = (org.jivesoftware.smack.packet.Message) stanza;
            handleMessage(smackMessage, false, true);
            String msg_xml = smackMessage.toXML().toString();
            try {
                handleChatState(smackMessage.getFrom().toString(), msg_xml);
            } catch (RemoteException re) {
            // no worries
            }
        }
    }, new StanzaTypeFilter(org.jivesoftware.smack.packet.Message.class));
    mConnection.addSyncStanzaListener(new StanzaListener() {

        @Override
        public void processStanza(Stanza packet) {
            org.jivesoftware.smack.packet.Presence presence = (org.jivesoftware.smack.packet.Presence) packet;
            qPresence.add(presence);
        }
    }, new StanzaTypeFilter(org.jivesoftware.smack.packet.Presence.class));
    if (mTimerPackets != null)
        mTimerPackets.cancel();
    initPacketProcessor();
    if (mTimerPresence != null)
        mTimerPresence.cancel();
    initPresenceProcessor();
    if (mTimerNewContacts != null)
        mTimerNewContacts.cancel();
    initNewContactProcessor();
    ConnectionListener connectionListener = new ConnectionListener() {

        /**
         * Called from smack when connect() is fully successful
         *
         * This is called on the executor thread while we are in reconnect()
         */
        @Override
        public void reconnectionSuccessful() {
            if (mStreamHandler == null || !mStreamHandler.isResumePending()) {
                debug(TAG, "Reconnection success");
                onReconnectionSuccessful();
                mRoster = Roster.getInstanceFor(mConnection);
                sendPresencePacket();
                mChatGroupManager.reconnectAll();
            } else {
                debug(TAG, "Ignoring reconnection callback due to pending resume");
            }
        }

        @Override
        public void reconnectionFailed(Exception e) {
            debug(TAG, "reconnection failed", e);
            // We are not using the reconnection manager
            // throw new UnsupportedOperationException();
            execute(new Runnable() {

                public void run() {
                    mNeedReconnect = true;
                    setState(LOGGING_IN, new ImErrorInfo(ImErrorInfo.NETWORK_ERROR, "network error"));
                    reconnect();
                }
            });
        }

        @Override
        public void reconnectingIn(int seconds) {
            // // We are not using the reconnection manager
            // throw new UnsupportedOperationException();
            debug(TAG, "reconnecting in " + seconds + " seconds...");
        }

        @Override
        public void connectionClosedOnError(final Exception e) {
            /*
                 * This fires when:
                 * - Packet reader or writer detect an error
                 * - Stream compression failed
                 * - TLS fails but is required
                 * - Network error
                 * - We forced a socket shutdown
                 */
            debug(TAG, "reconnect on error: " + e.getMessage(), e);
            if (e.getMessage().contains("conflict")) {
                execute(new Runnable() {

                    @Override
                    public void run() {
                        // disconnect();
                        disconnected(new ImErrorInfo(ImpsErrorInfo.ALREADY_LOGGED, "logged in from another location"));
                    }
                });
            } else if (!mNeedReconnect) {
                execute(new Runnable() {

                    public void run() {
                        if (getState() == LOGGED_IN) {
                            mNeedReconnect = true;
                            setState(LOGGING_IN, new ImErrorInfo(ImErrorInfo.NETWORK_ERROR, "network error"));
                            reconnect();
                        }
                    }
                });
            }
        }

        @Override
        public void connected(XMPPConnection connection) {
            debug(TAG, "connected");
            try {
                initOmemo((XMPPTCPConnection) connection);
            } catch (Exception e) {
                debug("OMEMO", "There was a problem init'g omemo", e);
            }
        }

        @Override
        public void authenticated(XMPPConnection connection, boolean resumed) {
            debug(TAG, "authenticated: resumed=" + resumed);
            sendPresencePacket();
            mChatGroupManager.reconnectAll();
        }

        @Override
        public void connectionClosed() {
            debug(TAG, "connection closed");
            // if the state is logged in, we should try to reconnect!
            if (getState() == LOGGED_IN) {
                execute(new Runnable() {

                    public void run() {
                        mNeedReconnect = true;
                        setState(LOGGING_IN, new ImErrorInfo(ImErrorInfo.NETWORK_ERROR, "network error"));
                        reconnect();
                    }
                });
            }
        }
    };
    mConnection.addConnectionListener(connectionListener);
    mStreamHandler = new XmppStreamHandler(mConnection, connectionListener);
    Exception xmppConnectException = null;
    AbstractXMPPConnection conn = mConnection.connect();
}
Also used : AndroidDebugger(org.jivesoftware.smackx.debugger.android.AndroidDebugger) XMPPTCPConnection(org.jivesoftware.smack.tcp.XMPPTCPConnection) Message(org.awesomeapp.messenger.model.Message) Reader(java.io.Reader) StanzaListener(org.jivesoftware.smack.StanzaListener) ReceiptReceivedListener(org.jivesoftware.smackx.receipts.ReceiptReceivedListener) AbstractXMPPConnection(org.jivesoftware.smack.AbstractXMPPConnection) XMPPConnection(org.jivesoftware.smack.XMPPConnection) ConnectionListener(org.jivesoftware.smack.ConnectionListener) ChatSession(org.awesomeapp.messenger.model.ChatSession) IChatSession(org.awesomeapp.messenger.service.IChatSession) SecureRandom(java.security.SecureRandom) StanzaTypeFilter(org.jivesoftware.smack.filter.StanzaTypeFilter) SmackDebuggerFactory(org.jivesoftware.smack.debugger.SmackDebuggerFactory) SmackDebugger(org.jivesoftware.smack.debugger.SmackDebugger) Presence(org.awesomeapp.messenger.model.Presence) LinkedList(java.util.LinkedList) ArrayList(java.util.ArrayList) ContactList(org.awesomeapp.messenger.model.ContactList) List(java.util.List) EntityBareJid(org.jxmpp.jid.EntityBareJid) Jid(org.jxmpp.jid.Jid) EntityFullJid(org.jxmpp.jid.EntityFullJid) BareJid(org.jxmpp.jid.BareJid) EntityJid(org.jxmpp.jid.EntityJid) DomainBareJid(org.jxmpp.jid.DomainBareJid) Stanza(org.jivesoftware.smack.packet.Stanza) OmemoFingerprint(org.jivesoftware.smackx.omemo.OmemoFingerprint) KeyStoreException(java.security.KeyStoreException) UndecidedOmemoIdentityException(org.jivesoftware.smackx.omemo.exceptions.UndecidedOmemoIdentityException) XMPPException(org.jivesoftware.smack.XMPPException) RemoteException(android.os.RemoteException) IOException(java.io.IOException) ImException(org.awesomeapp.messenger.model.ImException) KeyManagementException(java.security.KeyManagementException) InvocationTargetException(java.lang.reflect.InvocationTargetException) XmppStringprepException(org.jxmpp.stringprep.XmppStringprepException) NoSuchAlgorithmException(java.security.NoSuchAlgorithmException) SmackException(org.jivesoftware.smack.SmackException) RejectedExecutionException(java.util.concurrent.RejectedExecutionException) MultiUserChatException(org.jivesoftware.smackx.muc.MultiUserChatException) CryptoFailedException(org.jivesoftware.smackx.omemo.exceptions.CryptoFailedException) CertificateException(java.security.cert.CertificateException) MemorizingTrustManager(de.duenndns.ssl.MemorizingTrustManager) RemoteException(android.os.RemoteException) InetAddress(java.net.InetAddress) Writer(java.io.Writer) ImErrorInfo(org.awesomeapp.messenger.model.ImErrorInfo) AbstractXMPPConnection(org.jivesoftware.smack.AbstractXMPPConnection)

Example 3 with ImErrorInfo

use of org.awesomeapp.messenger.model.ImErrorInfo in project Zom-Android by zom.

the class XmppConnection method do_login_async.

private void do_login_async() {
    if (getState() == LOGGED_IN || getState() == SUSPENDED || getState() == SUSPENDING) {
        mNeedReconnect = false;
        return;
    }
    /*
        if (mConnection != null) {
            setState(getState(), new ImErrorInfo(ImErrorInfo.CANT_CONNECT_TO_SERVER,
                    "still trying..."));
            return;
        }*/
    ContentResolver contentResolver = mContext.getContentResolver();
    Cursor cursor = contentResolver.query(Imps.ProviderSettings.CONTENT_URI, new String[] { Imps.ProviderSettings.NAME, Imps.ProviderSettings.VALUE }, Imps.ProviderSettings.PROVIDER + "=?", new String[] { Long.toString(mProviderId) }, null);
    if (cursor == null)
        // not going to work
        return;
    Imps.ProviderSettings.QueryMap providerSettings = new Imps.ProviderSettings.QueryMap(cursor, contentResolver, mProviderId, false, null);
    // providerSettings is closed in initConnection();
    mUsername = Imps.Account.getUserName(contentResolver, mAccountId);
    String defaultStatus = null;
    mNeedReconnect = true;
    setState(LOGGING_IN, null);
    mUserPresence = new Presence(Presence.AVAILABLE, defaultStatus, Presence.CLIENT_TYPE_MOBILE);
    try {
        if (mUsername == null || mUsername.length() == 0)
            throw new Exception("empty username not allowed");
        initConnectionAndLogin(providerSettings, mUsername);
        setState(LOGGED_IN, null);
        debug(TAG, "logged in");
        mNeedReconnect = false;
    } catch (XMPPException e) {
        debug(TAG, "exception thrown on connection", e);
        ImErrorInfo info = new ImErrorInfo(ImErrorInfo.CANT_CONNECT_TO_SERVER, e.getMessage());
        // our default behavior is to retry
        mRetryLogin = true;
        if (mConnection != null && mConnection.isConnected()) {
            if (!mConnection.isAuthenticated()) {
                debug(TAG, "not authorized - will not retry");
                info = new ImErrorInfo(ImErrorInfo.INVALID_USERNAME, "invalid user/password");
                setState(SUSPENDED, info);
                mRetryLogin = false;
                mNeedReconnect = false;
            }
        }
        if (mRetryLogin && getState() != SUSPENDED) {
            debug(TAG, "will retry");
            setState(LOGGING_IN, info);
            maybe_reconnect();
        } else {
            // debug(TAG, "will not retry"); //WE MUST ALWAYS RETRY!
            disconnect();
            disconnected(info);
        }
    } catch (Exception e) {
        debug(TAG, "login failed: " + e.getMessage(), e);
        if (getState() != SUSPENDED || getState() != SUSPENDING) {
            mRetryLogin = true;
            mNeedReconnect = true;
            debug(TAG, "will retry");
            ImErrorInfo info = new ImErrorInfo(ImErrorInfo.UNKNOWN_ERROR, "keymanagement exception");
            setState(LOGGING_IN, info);
        } else {
            mRetryLogin = false;
            mNeedReconnect = true;
        }
    } finally {
        providerSettings.close();
        if (!cursor.isClosed())
            cursor.close();
    }
}
Also used : Imps(org.awesomeapp.messenger.provider.Imps) Presence(org.awesomeapp.messenger.model.Presence) Cursor(android.database.Cursor) XMPPException(org.jivesoftware.smack.XMPPException) KeyStoreException(java.security.KeyStoreException) UndecidedOmemoIdentityException(org.jivesoftware.smackx.omemo.exceptions.UndecidedOmemoIdentityException) XMPPException(org.jivesoftware.smack.XMPPException) RemoteException(android.os.RemoteException) IOException(java.io.IOException) ImException(org.awesomeapp.messenger.model.ImException) KeyManagementException(java.security.KeyManagementException) InvocationTargetException(java.lang.reflect.InvocationTargetException) XmppStringprepException(org.jxmpp.stringprep.XmppStringprepException) NoSuchAlgorithmException(java.security.NoSuchAlgorithmException) SmackException(org.jivesoftware.smack.SmackException) RejectedExecutionException(java.util.concurrent.RejectedExecutionException) MultiUserChatException(org.jivesoftware.smackx.muc.MultiUserChatException) CryptoFailedException(org.jivesoftware.smackx.omemo.exceptions.CryptoFailedException) CertificateException(java.security.cert.CertificateException) ContentResolver(android.content.ContentResolver) ImErrorInfo(org.awesomeapp.messenger.model.ImErrorInfo)

Example 4 with ImErrorInfo

use of org.awesomeapp.messenger.model.ImErrorInfo in project Zom-Android by zom.

the class RemoteImService method do_createConnection.

private IImConnection do_createConnection(long providerId, long accountId) {
    if (providerId == -1)
        return null;
    Map<String, String> settings = loadProviderSettings(providerId);
    // make sure OTR is init'd before you create your first connection
    initOtrChatManager();
    ConnectionFactory factory = ConnectionFactory.getInstance();
    try {
        ImConnection conn = factory.createConnection(settings, this);
        conn.initUser(providerId, accountId);
        ImConnectionAdapter imConnectionAdapter = new ImConnectionAdapter(providerId, accountId, conn, this);
        conn.addConnectionListener(new ConnectionListener() {

            @Override
            public void onStateChanged(int state, ImErrorInfo error) {
            }

            @Override
            public void onUserPresenceUpdated() {
            }

            @Override
            public void onUpdatePresenceError(ImErrorInfo error) {
            }
        });
        ContentResolver contentResolver = getContentResolver();
        Cursor cursor = contentResolver.query(Imps.ProviderSettings.CONTENT_URI, new String[] { Imps.ProviderSettings.NAME, Imps.ProviderSettings.VALUE }, Imps.ProviderSettings.PROVIDER + "=?", new String[] { Long.toString(providerId) }, null);
        if (cursor == null)
            throw new ImException("unable to query the provider settings");
        Imps.ProviderSettings.QueryMap providerSettings = new Imps.ProviderSettings.QueryMap(cursor, contentResolver, providerId, false, null);
        String userName = Imps.Account.getUserName(contentResolver, accountId);
        String domain = providerSettings.getDomain();
        providerSettings.close();
        mConnections.put(providerId + "." + accountId, imConnectionAdapter);
        mConnectionsByUser.put(imConnectionAdapter.getLoginUser().getAddress().getBareAddress(), imConnectionAdapter);
        Debug.recordTrail(this, CONNECTIONS_TRAIL_TAG, "" + mConnections.size());
        synchronized (mRemoteListeners) {
            try {
                final int N = mRemoteListeners.beginBroadcast();
                for (int i = 0; i < N; i++) {
                    IConnectionCreationListener listener = mRemoteListeners.getBroadcastItem(i);
                    try {
                        listener.onConnectionCreated(imConnectionAdapter);
                    } catch (RemoteException e) {
                    // The RemoteCallbackList will take care of removing the
                    // dead listeners.
                    }
                }
            } finally {
                mRemoteListeners.finishBroadcast();
            }
        }
        return imConnectionAdapter;
    } catch (ImException e) {
        debug("Error creating connection", e);
        return null;
    }
}
Also used : Imps(org.awesomeapp.messenger.provider.Imps) ConnectionListener(org.awesomeapp.messenger.model.ConnectionListener) Cursor(android.database.Cursor) ContentResolver(android.content.ContentResolver) ConnectionFactory(org.awesomeapp.messenger.model.ConnectionFactory) ImException(org.awesomeapp.messenger.model.ImException) ImConnection(org.awesomeapp.messenger.model.ImConnection) RemoteException(android.os.RemoteException) ImConnectionAdapter(org.awesomeapp.messenger.service.adapters.ImConnectionAdapter) ImErrorInfo(org.awesomeapp.messenger.model.ImErrorInfo)

Example 5 with ImErrorInfo

use of org.awesomeapp.messenger.model.ImErrorInfo in project Zom-Android by zom.

the class SimpleAlertHandler method promptDisconnectedEvent.

protected void promptDisconnectedEvent(Message msg) {
    ImErrorInfo error = (ImErrorInfo) msg.obj;
    String promptMsg = null;
    if (error != null) {
        promptMsg = mActivity.getString(R.string.signed_out_prompt_with_error, "", ErrorResUtils.getErrorRes(mRes, error.getCode()));
    } else {
        promptMsg = mActivity.getString(R.string.error);
    }
    if (promptMsg != null)
        showAlert(R.string.error, promptMsg);
}
Also used : ImErrorInfo(org.awesomeapp.messenger.model.ImErrorInfo)

Aggregations

ImErrorInfo (org.awesomeapp.messenger.model.ImErrorInfo)7 RemoteException (android.os.RemoteException)4 ImException (org.awesomeapp.messenger.model.ImException)4 IOException (java.io.IOException)3 InvocationTargetException (java.lang.reflect.InvocationTargetException)3 KeyManagementException (java.security.KeyManagementException)3 KeyStoreException (java.security.KeyStoreException)3 NoSuchAlgorithmException (java.security.NoSuchAlgorithmException)3 CertificateException (java.security.cert.CertificateException)3 RejectedExecutionException (java.util.concurrent.RejectedExecutionException)3 SmackException (org.jivesoftware.smack.SmackException)3 XMPPException (org.jivesoftware.smack.XMPPException)3 MultiUserChatException (org.jivesoftware.smackx.muc.MultiUserChatException)3 CryptoFailedException (org.jivesoftware.smackx.omemo.exceptions.CryptoFailedException)3 UndecidedOmemoIdentityException (org.jivesoftware.smackx.omemo.exceptions.UndecidedOmemoIdentityException)3 XmppStringprepException (org.jxmpp.stringprep.XmppStringprepException)3 ContentResolver (android.content.ContentResolver)2 Cursor (android.database.Cursor)2 ChatSession (org.awesomeapp.messenger.model.ChatSession)2 Presence (org.awesomeapp.messenger.model.Presence)2