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.ConnectionCreationListener; 024import org.jivesoftware.smack.Manager; 025import org.jivesoftware.smack.SmackException.NoResponseException; 026import org.jivesoftware.smack.SmackException.NotConnectedException; 027import org.jivesoftware.smack.StanzaListener; 028import org.jivesoftware.smack.XMPPConnection; 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.Presence; 038import org.jivesoftware.smack.packet.Stanza; 039import org.jivesoftware.smack.packet.StanzaError.Condition; 040 041import org.jivesoftware.smackx.disco.ServiceDiscoveryManager; 042import org.jivesoftware.smackx.iqlast.packet.LastActivity; 043 044import org.jxmpp.jid.Jid; 045 046/** 047 * A last activity manager for handling information about the last activity 048 * associated with a Jabber ID. A manager handles incoming LastActivity requests 049 * of existing Connections. It also allows to request last activity information 050 * of other users. 051 * 052 * LastActivity (XEP-0012) based on the sending JID's type allows for retrieval 053 * of: 054 * <ol> 055 * <li>How long a particular user has been idle 056 * <li>How long a particular user has been logged-out and the message the 057 * specified when doing so. 058 * <li>How long a host has been up. 059 * </ol> 060 * 061 * For example to get the idle time of a user logged in a resource, simple send 062 * the LastActivity stanza to them, as in the following code: 063 * 064 * <pre> 065 * XMPPConnection con = new XMPPTCPConnection("jabber.org"); 066 * con.login("john", "doe"); 067 * LastActivity activity = LastActivity.getLastActivity(con, "xray@jabber.org/Smack"); 068 * </pre> 069 * 070 * To get the lapsed time since the last user logout is the same as above but 071 * with out the resource: 072 * 073 * <pre> 074 * LastActivity activity = LastActivity.getLastActivity(con, "xray@jabber.org"); 075 * </pre> 076 * 077 * To get the uptime of a host, you simple send the LastActivity stanza to it, 078 * as in the following code example: 079 * <p> 080 * 081 * <pre> 082 * LastActivity activity = LastActivity.getLastActivity(con, "jabber.org"); 083 * </pre> 084 * 085 * @author Gabriel Guardincerri 086 * @author Florian Schmaus 087 * @see <a href="http://xmpp.org/extensions/xep-0012.html">XEP-0012: Last 088 * Activity</a> 089 */ 090 091public final class LastActivityManager extends Manager { 092 private static final Map<XMPPConnection, LastActivityManager> instances = new WeakHashMap<>(); 093// private static final PacketFilter IQ_GET_LAST_FILTER = new AndFilter(IQTypeFilter.GET, 094// new StanzaTypeFilter(LastActivity.class)); 095 096 private static boolean enabledPerDefault = true; 097 098 /** 099 * Enable or disable Last Activity for new XMPPConnections. 100 * 101 * @param enabledPerDefault 102 */ 103 public static void setEnabledPerDefault(boolean enabledPerDefault) { 104 LastActivityManager.enabledPerDefault = enabledPerDefault; 105 } 106 107 // Enable the LastActivity support on every established connection 108 static { 109 XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() { 110 @Override 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.addStanzaSendingListener(new StanzaListener() { 138 @Override 139 public void processStanza(Stanza packet) { 140 Presence presence = (Presence) packet; 141 Presence.Mode mode = presence.getMode(); 142 if (mode == null) return; 143 switch (mode) { 144 case available: 145 case chat: 146 // We assume that only a switch to available and chat indicates user activity 147 // since other mode changes could be also a result of some sort of automatism 148 resetIdleTime(); 149 break; 150 default: 151 break; 152 } 153 } 154 }, StanzaTypeFilter.PRESENCE); 155 156 connection.addStanzaSendingListener(new StanzaListener() { 157 @Override 158 public void processStanza(Stanza packet) { 159 Message message = (Message) packet; 160 // if it's not an error message, reset the idle time 161 if (message.getType() == Message.Type.error) return; 162 resetIdleTime(); 163 } 164 }, StanzaTypeFilter.MESSAGE); 165 166 // Register a listener for a last activity query 167 connection.registerIQRequestHandler(new AbstractIqRequestHandler(LastActivity.ELEMENT, LastActivity.NAMESPACE, 168 Type.get, Mode.async) { 169 @Override 170 public IQ handleIQRequest(IQ iqRequest) { 171 if (!enabled) 172 return IQ.createErrorResponse(iqRequest, Condition.not_acceptable); 173 LastActivity message = new LastActivity(); 174 message.setType(IQ.Type.result); 175 message.setTo(iqRequest.getFrom()); 176 message.setFrom(iqRequest.getTo()); 177 message.setStanzaId(iqRequest.getStanzaId()); 178 message.setLastActivity(getIdleTime()); 179 180 return message; 181 } 182 }); 183 184 if (enabledPerDefault) { 185 enable(); 186 } 187 resetIdleTime(); 188 instances.put(connection, this); 189 } 190 191 public synchronized void enable() { 192 ServiceDiscoveryManager.getInstanceFor(connection()).addFeature(LastActivity.NAMESPACE); 193 enabled = true; 194 } 195 196 public synchronized void disable() { 197 ServiceDiscoveryManager.getInstanceFor(connection()).removeFeature(LastActivity.NAMESPACE); 198 enabled = false; 199 } 200 201 /** 202 * Resets the idle time to 0, this should be invoked when a new message is 203 * sent. 204 */ 205 private void resetIdleTime() { 206 lastMessageSent = System.currentTimeMillis(); 207 } 208 209 /** 210 * The idle time is the lapsed time between the last message sent and now. 211 * 212 * @return the lapsed time between the last message sent and now. 213 */ 214 private long getIdleTime() { 215 long lms = lastMessageSent; 216 long now = System.currentTimeMillis(); 217 return ((now - lms) / 1000); 218 } 219 220 /** 221 * Returns the last activity of a particular jid. If the jid is a full JID 222 * (i.e., a JID of the form of 'user@host/resource') then the last activity 223 * is the idle time of that connected resource. On the other hand, when the 224 * jid is a bare JID (e.g. 'user@host') then the last activity is the lapsed 225 * time since the last logout or 0 if the user is currently logged in. 226 * Moreover, when the jid is a server or component (e.g., a JID of the form 227 * 'host') the last activity is the uptime. 228 * 229 * @param jid 230 * the JID of the user. 231 * @return the LastActivity stanza of the jid. 232 * @throws XMPPErrorException 233 * thrown if a server error has occured. 234 * @throws NoResponseException if there was no response from the server. 235 * @throws NotConnectedException 236 * @throws InterruptedException 237 */ 238 public LastActivity getLastActivity(Jid jid) throws NoResponseException, XMPPErrorException, 239 NotConnectedException, InterruptedException { 240 LastActivity activity = new LastActivity(jid); 241 return (LastActivity) connection().createStanzaCollectorAndSend(activity).nextResultOrThrow(); 242 } 243 244 /** 245 * Returns true if Last Activity (XEP-0012) is supported by a given JID. 246 * 247 * @param jid a JID to be tested for Last Activity support 248 * @return true if Last Activity is supported, otherwise false 249 * @throws NotConnectedException 250 * @throws XMPPErrorException 251 * @throws NoResponseException 252 * @throws InterruptedException 253 */ 254 public boolean isLastActivitySupported(Jid jid) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException { 255 return ServiceDiscoveryManager.getInstanceFor(connection()).supportsFeature(jid, LastActivity.NAMESPACE); 256 } 257}