001/**
002 *
003 * Copyright 2003-2006 Jive Software, 2014 Florian Schmaus
004 *
005 * Licensed under the Apache License, Version 2.0 (the "License");
006 * you may not use this file except in compliance with the License.
007 * You may obtain a copy of the License at
008 *
009 *     http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.jivesoftware.smackx.iqlast;
019
020import java.util.Map;
021import java.util.WeakHashMap;
022
023import org.jivesoftware.smack.SmackException.NoResponseException;
024import org.jivesoftware.smack.SmackException.NotConnectedException;
025import org.jivesoftware.smack.XMPPConnection;
026import org.jivesoftware.smack.ConnectionCreationListener;
027import org.jivesoftware.smack.StanzaListener;
028import org.jivesoftware.smack.Manager;
029import org.jivesoftware.smack.XMPPConnectionRegistry;
030import org.jivesoftware.smack.XMPPException.XMPPErrorException;
031import org.jivesoftware.smack.filter.StanzaTypeFilter;
032import org.jivesoftware.smack.iqrequest.AbstractIqRequestHandler;
033import org.jivesoftware.smack.iqrequest.IQRequestHandler.Mode;
034import org.jivesoftware.smack.packet.IQ;
035import org.jivesoftware.smack.packet.IQ.Type;
036import org.jivesoftware.smack.packet.Message;
037import org.jivesoftware.smack.packet.Stanza;
038import org.jivesoftware.smack.packet.Presence;
039import org.jivesoftware.smack.packet.XMPPError;
040import org.jivesoftware.smack.packet.XMPPError.Condition;
041import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
042import org.jivesoftware.smackx.iqlast.packet.LastActivity;
043
044/**
045 * A last activity manager for handling information about the last activity
046 * associated with a Jabber ID. A manager handles incoming LastActivity requests
047 * of existing Connections. It also allows to request last activity information
048 * of other users.
049 * <p>
050 * 
051 * LastActivity (XEP-0012) based on the sending JID's type allows for retrieval
052 * of:
053 * <ol>
054 * <li>How long a particular user has been idle
055 * <li>How long a particular user has been logged-out and the message the
056 * specified when doing so.
057 * <li>How long a host has been up.
058 * </ol>
059 * <p/>
060 * 
061 * For example to get the idle time of a user logged in a resource, simple send
062 * the LastActivity stanza(/packet) to them, as in the following code:
063 * <p>
064 * 
065 * <pre>
066 * XMPPConnection con = new XMPPTCPConnection(&quot;jabber.org&quot;);
067 * con.login(&quot;john&quot;, &quot;doe&quot;);
068 * LastActivity activity = LastActivity.getLastActivity(con, &quot;xray@jabber.org/Smack&quot;);
069 * </pre>
070 * 
071 * To get the lapsed time since the last user logout is the same as above but
072 * with out the resource:
073 * 
074 * <pre>
075 * LastActivity activity = LastActivity.getLastActivity(con, &quot;xray@jabber.org&quot;);
076 * </pre>
077 * 
078 * To get the uptime of a host, you simple send the LastActivity stanza(/packet) to it,
079 * as in the following code example:
080 * <p>
081 * 
082 * <pre>
083 * LastActivity activity = LastActivity.getLastActivity(con, &quot;jabber.org&quot;);
084 * </pre>
085 * 
086 * @author Gabriel Guardincerri
087 * @author Florian Schmaus
088 * @see <a href="http://xmpp.org/extensions/xep-0012.html">XEP-0012: Last
089 *      Activity</a>
090 */
091
092public class LastActivityManager extends Manager {
093    private static final Map<XMPPConnection, LastActivityManager> instances = new WeakHashMap<XMPPConnection, LastActivityManager>();
094//    private static final PacketFilter IQ_GET_LAST_FILTER = new AndFilter(IQTypeFilter.GET,
095//                    new StanzaTypeFilter(LastActivity.class));
096
097    private static boolean enabledPerDefault = true;
098
099    /**
100     * Enable or disable Last Activity for new XMPPConnections.
101     *
102     * @param enabledPerDefault
103     */
104    public static void setEnabledPerDefault(boolean enabledPerDefault) {
105        LastActivityManager.enabledPerDefault = enabledPerDefault;
106    }
107
108    // Enable the LastActivity support on every established connection
109    static {
110        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
111            public void connectionCreated(XMPPConnection connection) {
112                LastActivityManager.getInstanceFor(connection);
113            }
114        });
115    }
116
117    public static synchronized LastActivityManager getInstanceFor(XMPPConnection connection) {
118        LastActivityManager lastActivityManager = instances.get(connection);
119        if (lastActivityManager == null)
120            lastActivityManager = new LastActivityManager(connection);
121        return lastActivityManager;
122    }
123
124    private volatile long lastMessageSent;
125    private boolean enabled = false;
126
127    /**
128     * Creates a last activity manager to response last activity requests.
129     * 
130     * @param connection
131     *            The XMPPConnection that the last activity requests will use.
132     */
133    private LastActivityManager(XMPPConnection connection) {
134        super(connection);
135
136        // Listen to all the sent messages to reset the idle time on each one
137        connection.addPacketSendingListener(new StanzaListener() {
138            public void processPacket(Stanza packet) {
139                Presence presence = (Presence) packet;
140                Presence.Mode mode = presence.getMode();
141                if (mode == null) return;
142                switch (mode) {
143                case available:
144                case chat:
145                    // We assume that only a switch to available and chat indicates user activity
146                    // since other mode changes could be also a result of some sort of automatism
147                    resetIdleTime();
148                    break;
149                default:
150                    break;
151                }
152            }
153        }, StanzaTypeFilter.PRESENCE);
154
155        connection.addPacketSendingListener(new StanzaListener() {
156            @Override
157            public void processPacket(Stanza packet) {
158                Message message = (Message) packet;
159                // if it's not an error message, reset the idle time
160                if (message.getType() == Message.Type.error) return;
161                resetIdleTime();
162            }
163        }, StanzaTypeFilter.MESSAGE);
164
165        // Register a listener for a last activity query
166        connection.registerIQRequestHandler(new AbstractIqRequestHandler(LastActivity.ELEMENT, LastActivity.NAMESPACE,
167                        Type.get, Mode.async) {
168            @Override
169            public IQ handleIQRequest(IQ iqRequest) {
170                if (!enabled)
171                    return IQ.createErrorResponse(iqRequest, new XMPPError(Condition.not_acceptable));
172                LastActivity message = new LastActivity();
173                message.setType(IQ.Type.result);
174                message.setTo(iqRequest.getFrom());
175                message.setFrom(iqRequest.getTo());
176                message.setStanzaId(iqRequest.getStanzaId());
177                message.setLastActivity(getIdleTime());
178
179                return message;
180            }
181        });
182
183        if (enabledPerDefault) {
184            enable();
185        }
186        resetIdleTime();
187        instances.put(connection, this);
188    }
189
190    public synchronized void enable() {
191        ServiceDiscoveryManager.getInstanceFor(connection()).addFeature(LastActivity.NAMESPACE);
192        enabled = true;
193    }
194
195    public synchronized void disable() {
196        ServiceDiscoveryManager.getInstanceFor(connection()).removeFeature(LastActivity.NAMESPACE);
197        enabled = false;
198    }
199
200    /**
201     * Resets the idle time to 0, this should be invoked when a new message is
202     * sent.
203     */
204    private void resetIdleTime() {
205        lastMessageSent = System.currentTimeMillis();
206    }
207
208    /**
209     * The idle time is the lapsed time between the last message sent and now.
210     * 
211     * @return the lapsed time between the last message sent and now.
212     */
213    private long getIdleTime() {
214        long lms = lastMessageSent;
215        long now = System.currentTimeMillis();
216        return ((now - lms) / 1000);
217    }
218
219    /**
220     * Returns the last activity of a particular jid. If the jid is a full JID
221     * (i.e., a JID of the form of 'user@host/resource') then the last activity
222     * is the idle time of that connected resource. On the other hand, when the
223     * jid is a bare JID (e.g. 'user@host') then the last activity is the lapsed
224     * time since the last logout or 0 if the user is currently logged in.
225     * Moreover, when the jid is a server or component (e.g., a JID of the form
226     * 'host') the last activity is the uptime.
227     * 
228     * @param jid
229     *            the JID of the user.
230     * @return the LastActivity stanza(/packet) of the jid.
231     * @throws XMPPErrorException
232     *             thrown if a server error has occured.
233     * @throws NoResponseException if there was no response from the server.
234     * @throws NotConnectedException 
235     */
236    public LastActivity getLastActivity(String jid) throws NoResponseException, XMPPErrorException,
237                    NotConnectedException {
238        LastActivity activity = new LastActivity(jid);
239        return (LastActivity) connection().createPacketCollectorAndSend(activity).nextResultOrThrow();
240    }
241
242    /**
243     * Returns true if Last Activity (XEP-0012) is supported by a given JID
244     * 
245     * @param jid a JID to be tested for Last Activity support
246     * @return true if Last Activity is supported, otherwise false
247     * @throws NotConnectedException 
248     * @throws XMPPErrorException 
249     * @throws NoResponseException 
250     */
251    public boolean isLastActivitySupported(String jid) throws NoResponseException, XMPPErrorException, NotConnectedException {
252        return ServiceDiscoveryManager.getInstanceFor(connection()).supportsFeature(jid, LastActivity.NAMESPACE);
253    }
254}