path: root/src/main/java/com/juick/PushComponent.java

/*
 * Juick
 * Copyright (C) 2013, Ugnich Anton
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.juick;

import com.google.android.gcm.server.Message;
import com.google.android.gcm.server.MulticastResult;
import com.google.android.gcm.server.Result;
import com.google.android.gcm.server.Sender;
import com.juick.json.MessageSerializer;
import com.juick.server.PushQueries;
import com.juick.xmpp.JID;
import com.juick.xmpp.Message.MessageListener;
import com.juick.xmpp.utils.XmlUtils;
import com.juick.xmpp.Stream;
import com.juick.xmpp.StreamComponent;
import com.juick.xmpp.extensions.JuickMessage;
import com.notnoop.apns.APNS;
import com.notnoop.apns.ApnsService;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.Socket;
import java.net.URL;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

/**
 *
 * @author Ugnich Anton
 */
public class PushComponent implements ServletContextListener, Stream.StreamListener, MessageListener {

    private static Logger logger = Logger.getLogger(PushComponent.class.getName());

    private ExecutorService executorService;
    String wns_client_secret;
    Connection sql;
    Socket socket;
    Stream xmpp;
    Sender GCMSender;

    @Override
    public void contextInitialized(final ServletContextEvent sce) {
        logger.info("component initialized");
        executorService = Executors.newSingleThreadExecutor();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                Properties conf = new Properties();
                try {
                    conf.load(sce.getServletContext().getResourceAsStream("WEB-INF/juick.conf"));
                    LogManager.getLogManager().readConfiguration(
                            sce.getServletContext().getResourceAsStream("WEB-INF/logging.properties"));
                    GCMSender = new Sender(conf.getProperty("gcm_key"));

                    setupSql(conf.getProperty("mysql_host"), conf.getProperty("mysql_username"),
                            conf.getProperty("mysql_password", ""), conf.getProperty("mysql_database", ""));
                    setupXmppComponent(new JID("", conf.getProperty("push_jid"), ""), conf.getProperty("xmpp_host", "localhost"),
                            Integer.parseInt(conf.getProperty("xmpp_port", "5347")), conf.getProperty("push_xmpp_password", ""));
                    wns_client_secret = conf.getProperty("wns_client_secret", "");
                } catch (IOException e) {
                    logger.log(Level.SEVERE, e.getMessage(), e);
                }
            }
        });
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // Now deregister JDBC drivers in this context's ClassLoader:
        // Get the webapp's ClassLoader
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        // Loop through all drivers
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver driver = drivers.nextElement();
            if (driver.getClass().getClassLoader() == cl) {
                // This driver was registered by the webapp's ClassLoader, so deregister it:
                try {
                    logger.info(String.format("Deregistering JDBC driver %s", driver.toString()));
                    DriverManager.deregisterDriver(driver);
                } catch (SQLException ex) {
                    logger.log(Level.SEVERE, String.format("Error deregistering JDBC driver %s", driver), ex);
                }
            } else {
                // driver was not registered by the webapp's ClassLoader and may be in use elsewhere
                logger.log(Level.SEVERE, String.format("Not deregistering JDBC driver %s as it does not belong to this webapp's ClassLoader", driver));
            }
        }
        executorService.shutdown();
        logger.info("component destroyed");
    }

    public void setupSql(String host, String username, String password, String database) {
        try {
            sql = DriverManager.getConnection(
                    String.format("jdbc:mysql://%s/%s?autoReconnect=true&user=%s&password=%s",
                            host, database, username, password));
        } catch (SQLException e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
        }
    }

    public void setupXmppComponent(JID jid, String host, int port, String password) {
        try {
            socket = new Socket(host, port);
            xmpp = new StreamComponent(jid, socket.getInputStream(), socket.getOutputStream(), password);
            xmpp.addChildParser(new JuickMessage());
            xmpp.addListener((Stream.StreamListener) this);
            xmpp.addListener((MessageListener) this);
            xmpp.startParsing();
        } catch (IOException e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
        }
    }

    @Override
    public void onStreamReady() {
        logger.info("XMPP STREAM READY");
    }

    @Override
    public void onStreamFail(Exception e) {logger.log(Level.SEVERE, "XMPP STREAM FAIL", e);}

    @Override
    public void onMessage(com.juick.xmpp.Message msg) {
        JuickMessage jmsg = (JuickMessage) msg.getChild(JuickMessage.XMLNS);
        if (jmsg == null) {
            return;
        }

        int uid_to = jmsg.User.UID;

        /*** ANDROID ***/
        ArrayList<String> regids;
        if (uid_to > 0) {
            regids = new ArrayList<String>();
            String targetId = PushQueries.getAndroidRegID(sql, uid_to);
            if (targetId != null && !targetId.isEmpty()) {
                regids.add(targetId);
            }
        } else {
            regids = PushQueries.getAndroidSubscribers(sql, jmsg.User.UID);
        }

        if (!regids.isEmpty()) {
            MessageSerializer messageSerializer = new MessageSerializer();
            String json = messageSerializer.serialize(jmsg).toString();
            logger.info(json);
            Message message = new Message.Builder().addData("message", json).build();
            try {
                MulticastResult result = GCMSender.send(message, regids, 3);
                List<Result> results = result.getResults();
                for (int i = 0; i < results.size(); i++) {
                    logger.fine("RES " + i + ": " + results.get(i).toString());
                }
            } catch (IOException e) {
                logger.log(Level.SEVERE, e.getMessage(), e);
            } catch (IllegalArgumentException err) {
                logger.warning("Android: Invalid API Key");
            }
        }

        /*** WinPhone ***/
        ArrayList<String> urls;
        if (uid_to > 0) {
            urls = new ArrayList<String>();
            String targetURL = PushQueries.getWinPhoneURL(sql, uid_to);
            if (targetURL != null && !targetURL.isEmpty()) {
                urls.add(targetURL);
            }
        } else {
            urls = PushQueries.getWinPhoneSubscribers(sql, jmsg.User.UID);
        }

        if (!urls.isEmpty()) {
            String text1 = "@" + jmsg.User.UName;
            if (!jmsg.Tags.isEmpty()) {
                text1 += ":" + XmlUtils.escape(jmsg.getTagsString());
            }
            String text2;
            if (jmsg.Text.length() > 250) {
                text2 = XmlUtils.escape(jmsg.Text.substring(0, 255)) + "...";
            } else {
                text2 = XmlUtils.escape(jmsg.Text);
            }
            String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
                    + "<toast>"
                    +  "<visual>"
                    +   "<binding template=\"ToastText02\">"
                    +    "<text id=\"1\">" + text1 + "</text>"
                    +    "<text id=\"2\">" + text2 + "</text>"
                    //+    "<image id=\"3\" src=\"http://i.juick.com/as/" + jmsg.User.UID + ".png\" />"  // todo: user avatar
                    +   "</binding>"
                    +  "</visual>"
                    +  "<commands>"
                    +   "<command arguments=\"?mid=" + jmsg.MID + "\" />"
                    +  "</commands>"
                    + "</toast>";
            logger.fine(xml);
            for (int i = 0; i < urls.size(); i++) {
                String url = urls.get(i);
                logger.fine("WNS: " + url);
                sendWNS(url, xml);
            }
        }

        /*** iOS ***/
        List<String> tokens;
        if (uid_to > 0) {
            tokens = new ArrayList<String>();
            String targetToken = PushQueries.getAPNSToken(sql, uid_to);
            if (targetToken != null && !targetToken.isEmpty()) {
                tokens.add(targetToken);
            }
        } else {
            tokens = PushQueries.getAPNSSubscribers(sql, jmsg.User.UID);
        }
        if (!tokens.isEmpty()) {
            ApnsService service = APNS.newService().withCert("/etc/juick/ios.p12", "juick")
                    .withSandboxDestination().build();
            for (String token : tokens) {
                String payload = APNS.newPayload().alertTitle("@" + jmsg.User.UName).alertBody(jmsg.Text).build();
                logger.fine("APNS: " + token);
                service.push(token, payload);
            }
        }
    }

    public boolean sendWNS(String url, String xml) {
        boolean ret = false;
        try {
            HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
            OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());

            conn.setRequestProperty("Content-Type", "text/xml; charset=utf-8");
            Integer contentLength = xml.getBytes(wr.getEncoding()).length;
            conn.setRequestProperty("Content-Length", contentLength.toString());
            String token = "Bearer " + wns_client_secret;
            conn.setRequestProperty("Authorization", token);
            conn.setRequestProperty("X-WNS-Type", "wns/toast"); // todo: mb use "wns/badge" or "wns/tile"

            conn.setUseCaches(false);
            conn.setDoInput(true);
            conn.setDoOutput(true);
            conn.setRequestMethod("POST");
            conn.connect();

            wr.write(xml);
            wr.close();

            if (conn.getResponseCode() == 200) {
                ret = streamToString(conn.getInputStream()) != null;
            }

            conn.disconnect();
        } catch (Exception e) {
            logger.log(Level.SEVERE, "sendWNS error: ", e);
        }
        return ret;
    }

    public String streamToString(InputStream is) {
        try {
            BufferedReader buf = new BufferedReader(new InputStreamReader(is));
            StringBuilder str = new StringBuilder();
            String line;
            do {
                line = buf.readLine();
                str.append(line).append("\n");
            } while (line != null);
            return str.toString();
        } catch (Exception e) {
            logger.severe("streamToString: " + e.toString());
        }
        return null;
    }
}