Examples with AndroidDebugger org.jivesoftware.smackx.debugger.android.AndroidDebugger used on opensource projects

Example 1 with AndroidDebugger

use of org.jivesoftware.smackx.debugger.android.AndroidDebugger 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();
}