001/**
002 *
003 * Copyright 2016 Fernando Ramirez
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 */
017package org.jivesoftware.smackx.muclight;
018
019import java.lang.ref.WeakReference;
020import java.util.ArrayList;
021import java.util.HashMap;
022import java.util.List;
023import java.util.Map;
024import java.util.WeakHashMap;
025
026import org.jivesoftware.smack.Manager;
027import org.jivesoftware.smack.SmackException.NoResponseException;
028import org.jivesoftware.smack.SmackException.NotConnectedException;
029import org.jivesoftware.smack.XMPPConnection;
030import org.jivesoftware.smack.XMPPException.XMPPErrorException;
031import org.jivesoftware.smack.filter.IQReplyFilter;
032import org.jivesoftware.smack.filter.StanzaFilter;
033import org.jivesoftware.smack.packet.IQ;
034import org.jivesoftware.smack.packet.IQ.Type;
035
036import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
037import org.jivesoftware.smackx.disco.packet.DiscoverItems;
038import org.jivesoftware.smackx.muclight.element.MUCLightBlockingIQ;
039
040import org.jxmpp.jid.DomainBareJid;
041import org.jxmpp.jid.EntityBareJid;
042import org.jxmpp.jid.Jid;
043
044/**
045 * Multi-User Chat Light manager class.
046 *
047 * @author Fernando Ramirez
048 *
049 */
050public final class MultiUserChatLightManager extends Manager {
051
052    private static final Map<XMPPConnection, MultiUserChatLightManager> INSTANCES = new WeakHashMap<XMPPConnection, MultiUserChatLightManager>();
053
054    /**
055     * Get a instance of a MUC Light manager for the given connection.
056     *
057     * @param connection
058     * @return a MUCLight manager.
059     */
060    public static synchronized MultiUserChatLightManager getInstanceFor(XMPPConnection connection) {
061        MultiUserChatLightManager multiUserChatLightManager = INSTANCES.get(connection);
062        if (multiUserChatLightManager == null) {
063            multiUserChatLightManager = new MultiUserChatLightManager(connection);
064            INSTANCES.put(connection, multiUserChatLightManager);
065        }
066        return multiUserChatLightManager;
067    }
068
069    /**
070     * A Map of MUC Light JIDs to instances. We use weak references for the
071     * values in order to allow those instances to get garbage collected.
072     */
073    private final Map<EntityBareJid, WeakReference<MultiUserChatLight>> multiUserChatLights = new HashMap<>();
074
075    private MultiUserChatLightManager(XMPPConnection connection) {
076        super(connection);
077    }
078
079    /**
080     * Obtain the MUC Light.
081     *
082     * @param jid
083     * @return the MUCLight.
084     */
085    public synchronized MultiUserChatLight getMultiUserChatLight(EntityBareJid jid) {
086        WeakReference<MultiUserChatLight> weakRefMultiUserChat = multiUserChatLights.get(jid);
087        if (weakRefMultiUserChat == null) {
088            return createNewMucLightAndAddToMap(jid);
089        }
090        MultiUserChatLight multiUserChatLight = weakRefMultiUserChat.get();
091        if (multiUserChatLight == null) {
092            return createNewMucLightAndAddToMap(jid);
093        }
094        return multiUserChatLight;
095    }
096
097    private MultiUserChatLight createNewMucLightAndAddToMap(EntityBareJid jid) {
098        MultiUserChatLight multiUserChatLight = new MultiUserChatLight(connection(), jid);
099        multiUserChatLights.put(jid, new WeakReference<>(multiUserChatLight));
100        return multiUserChatLight;
101    }
102
103    /**
104     * Returns true if Multi-User Chat Light feature is supported by the server.
105     *
106     * @param mucLightService
107     * @return true if Multi-User Chat Light feature is supported by the server.
108     * @throws NotConnectedException
109     * @throws XMPPErrorException
110     * @throws NoResponseException
111     * @throws InterruptedException
112     */
113    public boolean isFeatureSupported(DomainBareJid mucLightService)
114            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
115        return ServiceDiscoveryManager.getInstanceFor(connection()).discoverInfo(mucLightService)
116                .containsFeature(MultiUserChatLight.NAMESPACE);
117    }
118
119    /**
120     * Returns a List of the rooms the user occupies.
121     *
122     * @param mucLightService
123     * @return a List of the rooms the user occupies.
124     * @throws XMPPErrorException
125     * @throws NoResponseException
126     * @throws NotConnectedException
127     * @throws InterruptedException
128     */
129    public List<Jid> getOccupiedRooms(DomainBareJid mucLightService)
130            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
131        DiscoverItems result = ServiceDiscoveryManager.getInstanceFor(connection()).discoverItems(mucLightService);
132        List<DiscoverItems.Item> items = result.getItems();
133        List<Jid> answer = new ArrayList<>(items.size());
134
135        for (DiscoverItems.Item item : items) {
136            Jid mucLight = item.getEntityID();
137            answer.add(mucLight);
138        }
139
140        return answer;
141    }
142
143    /**
144     * Returns a collection with the XMPP addresses of the MUC Light services.
145     *
146     * @return a collection with the XMPP addresses of the MUC Light services.
147     * @throws XMPPErrorException
148     * @throws NoResponseException
149     * @throws NotConnectedException
150     * @throws InterruptedException
151     */
152    public List<DomainBareJid> getLocalServices()
153            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
154        ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection());
155        return sdm.findServices(MultiUserChatLight.NAMESPACE, false, false);
156    }
157
158    /**
159     * Get users and rooms blocked.
160     *
161     * @param mucLightService
162     * @return the list of users and rooms blocked
163     * @throws NoResponseException
164     * @throws XMPPErrorException
165     * @throws NotConnectedException
166     * @throws InterruptedException
167     */
168    public List<Jid> getUsersAndRoomsBlocked(DomainBareJid mucLightService)
169            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
170        MUCLightBlockingIQ muclIghtBlockingIQResult = getBlockingList(mucLightService);
171
172        List<Jid> jids = new ArrayList<>();
173        if (muclIghtBlockingIQResult.getRooms() != null) {
174            jids.addAll(muclIghtBlockingIQResult.getRooms().keySet());
175        }
176
177        if (muclIghtBlockingIQResult.getUsers() != null) {
178            jids.addAll(muclIghtBlockingIQResult.getUsers().keySet());
179        }
180
181        return jids;
182    }
183
184    /**
185     * Get rooms blocked.
186     *
187     * @param mucLightService
188     * @return the list of rooms blocked
189     * @throws NoResponseException
190     * @throws XMPPErrorException
191     * @throws NotConnectedException
192     * @throws InterruptedException
193     */
194    public List<Jid> getRoomsBlocked(DomainBareJid mucLightService)
195            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
196        MUCLightBlockingIQ mucLightBlockingIQResult = getBlockingList(mucLightService);
197
198        List<Jid> jids = new ArrayList<>();
199        if (mucLightBlockingIQResult.getRooms() != null) {
200            jids.addAll(mucLightBlockingIQResult.getRooms().keySet());
201        }
202
203        return jids;
204    }
205
206    /**
207     * Get users blocked.
208     *
209     * @param mucLightService
210     * @return the list of users blocked
211     * @throws NoResponseException
212     * @throws XMPPErrorException
213     * @throws NotConnectedException
214     * @throws InterruptedException
215     */
216    public List<Jid> getUsersBlocked(DomainBareJid mucLightService)
217            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
218        MUCLightBlockingIQ mucLightBlockingIQResult = getBlockingList(mucLightService);
219
220        List<Jid> jids = new ArrayList<>();
221        if (mucLightBlockingIQResult.getUsers() != null) {
222            jids.addAll(mucLightBlockingIQResult.getUsers().keySet());
223        }
224
225        return jids;
226    }
227
228    private MUCLightBlockingIQ getBlockingList(DomainBareJid mucLightService)
229            throws NoResponseException, XMPPErrorException, InterruptedException, NotConnectedException {
230        MUCLightBlockingIQ mucLightBlockingIQ = new MUCLightBlockingIQ(null, null);
231        mucLightBlockingIQ.setType(Type.get);
232        mucLightBlockingIQ.setTo(mucLightService);
233
234        StanzaFilter responseFilter = new IQReplyFilter(mucLightBlockingIQ, connection());
235        IQ responseIq = connection().createStanzaCollectorAndSend(responseFilter, mucLightBlockingIQ)
236                .nextResultOrThrow();
237        MUCLightBlockingIQ mucLightBlockingIQResult = (MUCLightBlockingIQ) responseIq;
238
239        return mucLightBlockingIQResult;
240    }
241
242    /**
243     * Block a room.
244     *
245     * @param mucLightService
246     * @param roomJid
247     * @throws NoResponseException
248     * @throws XMPPErrorException
249     * @throws NotConnectedException
250     * @throws InterruptedException
251     */
252    public void blockRoom(DomainBareJid mucLightService, Jid roomJid)
253            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
254        HashMap<Jid, Boolean> rooms = new HashMap<>();
255        rooms.put(roomJid, false);
256        sendBlockRooms(mucLightService, rooms);
257    }
258
259    /**
260     * Block rooms.
261     *
262     * @param mucLightService
263     * @param roomsJids
264     * @throws NoResponseException
265     * @throws XMPPErrorException
266     * @throws NotConnectedException
267     * @throws InterruptedException
268     */
269    public void blockRooms(DomainBareJid mucLightService, List<Jid> roomsJids)
270            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
271        HashMap<Jid, Boolean> rooms = new HashMap<>();
272        for (Jid jid : roomsJids) {
273            rooms.put(jid, false);
274        }
275        sendBlockRooms(mucLightService, rooms);
276    }
277
278    private void sendBlockRooms(DomainBareJid mucLightService, HashMap<Jid, Boolean> rooms)
279            throws NoResponseException, XMPPErrorException, InterruptedException, NotConnectedException {
280        MUCLightBlockingIQ mucLightBlockingIQ = new MUCLightBlockingIQ(rooms, null);
281        mucLightBlockingIQ.setType(Type.set);
282        mucLightBlockingIQ.setTo(mucLightService);
283        connection().createStanzaCollectorAndSend(mucLightBlockingIQ).nextResultOrThrow();
284    }
285
286    /**
287     * Block a user.
288     *
289     * @param mucLightService
290     * @param userJid
291     * @throws NoResponseException
292     * @throws XMPPErrorException
293     * @throws NotConnectedException
294     * @throws InterruptedException
295     */
296    public void blockUser(DomainBareJid mucLightService, Jid userJid)
297            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
298        HashMap<Jid, Boolean> users = new HashMap<>();
299        users.put(userJid, false);
300        sendBlockUsers(mucLightService, users);
301    }
302
303    /**
304     * Block users.
305     *
306     * @param mucLightService
307     * @param usersJids
308     * @throws NoResponseException
309     * @throws XMPPErrorException
310     * @throws NotConnectedException
311     * @throws InterruptedException
312     */
313    public void blockUsers(DomainBareJid mucLightService, List<Jid> usersJids)
314            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
315        HashMap<Jid, Boolean> users = new HashMap<>();
316        for (Jid jid : usersJids) {
317            users.put(jid, false);
318        }
319        sendBlockUsers(mucLightService, users);
320    }
321
322    private void sendBlockUsers(DomainBareJid mucLightService, HashMap<Jid, Boolean> users)
323            throws NoResponseException, XMPPErrorException, InterruptedException, NotConnectedException {
324        MUCLightBlockingIQ mucLightBlockingIQ = new MUCLightBlockingIQ(null, users);
325        mucLightBlockingIQ.setType(Type.set);
326        mucLightBlockingIQ.setTo(mucLightService);
327        connection().createStanzaCollectorAndSend(mucLightBlockingIQ).nextResultOrThrow();
328    }
329
330    /**
331     * Unblock a room.
332     *
333     * @param mucLightService
334     * @param roomJid
335     * @throws NoResponseException
336     * @throws XMPPErrorException
337     * @throws NotConnectedException
338     * @throws InterruptedException
339     */
340    public void unblockRoom(DomainBareJid mucLightService, Jid roomJid)
341            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
342        HashMap<Jid, Boolean> rooms = new HashMap<>();
343        rooms.put(roomJid, true);
344        sendUnblockRooms(mucLightService, rooms);
345    }
346
347    /**
348     * Unblock rooms.
349     *
350     * @param mucLightService
351     * @param roomsJids
352     * @throws NoResponseException
353     * @throws XMPPErrorException
354     * @throws NotConnectedException
355     * @throws InterruptedException
356     */
357    public void unblockRooms(DomainBareJid mucLightService, List<Jid> roomsJids)
358            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
359        HashMap<Jid, Boolean> rooms = new HashMap<>();
360        for (Jid jid : roomsJids) {
361            rooms.put(jid, true);
362        }
363        sendUnblockRooms(mucLightService, rooms);
364    }
365
366    private void sendUnblockRooms(DomainBareJid mucLightService, HashMap<Jid, Boolean> rooms)
367            throws NoResponseException, XMPPErrorException, InterruptedException, NotConnectedException {
368        MUCLightBlockingIQ mucLightBlockingIQ = new MUCLightBlockingIQ(rooms, null);
369        mucLightBlockingIQ.setType(Type.set);
370        mucLightBlockingIQ.setTo(mucLightService);
371        connection().createStanzaCollectorAndSend(mucLightBlockingIQ).nextResultOrThrow();
372    }
373
374    /**
375     * Unblock a user.
376     *
377     * @param mucLightService
378     * @param userJid
379     * @throws NoResponseException
380     * @throws XMPPErrorException
381     * @throws NotConnectedException
382     * @throws InterruptedException
383     */
384    public void unblockUser(DomainBareJid mucLightService, Jid userJid)
385            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
386        HashMap<Jid, Boolean> users = new HashMap<>();
387        users.put(userJid, true);
388        sendUnblockUsers(mucLightService, users);
389    }
390
391    /**
392     * Unblock users.
393     *
394     * @param mucLightService
395     * @param usersJids
396     * @throws NoResponseException
397     * @throws XMPPErrorException
398     * @throws NotConnectedException
399     * @throws InterruptedException
400     */
401    public void unblockUsers(DomainBareJid mucLightService, List<Jid> usersJids)
402            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
403        HashMap<Jid, Boolean> users = new HashMap<>();
404        for (Jid jid : usersJids) {
405            users.put(jid, true);
406        }
407        sendUnblockUsers(mucLightService, users);
408    }
409
410    private void sendUnblockUsers(DomainBareJid mucLightService, HashMap<Jid, Boolean> users)
411            throws NoResponseException, XMPPErrorException, InterruptedException, NotConnectedException {
412        MUCLightBlockingIQ mucLightBlockingIQ = new MUCLightBlockingIQ(null, users);
413        mucLightBlockingIQ.setType(Type.set);
414        mucLightBlockingIQ.setTo(mucLightService);
415        connection().createStanzaCollectorAndSend(mucLightBlockingIQ).nextResultOrThrow();
416    }
417
418}