BookmarkManager.java

  1. /**
  2.  *
  3.  * Copyright 2003-2007 Jive Software.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */

  18. package org.jivesoftware.smackx.bookmarks;

  20. import java.util.Collections;
  21. import java.util.Iterator;
  22. import java.util.List;
  23. import java.util.Map;
  24. import java.util.WeakHashMap;

  26. import org.jivesoftware.smack.SmackException;
  27. import org.jivesoftware.smack.SmackException.NoResponseException;
  28. import org.jivesoftware.smack.SmackException.NotConnectedException;
  29. import org.jivesoftware.smack.XMPPConnection;
  30. import org.jivesoftware.smack.XMPPException;
  31. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  32. import org.jivesoftware.smackx.iqprivate.PrivateDataManager;


  35. /**
  36.  * Provides methods to manage bookmarks in accordance with XEP-0048. Methods for managing URLs and
  37.  * Conferences are provided.
  38.  * </p>
  39.  * It should be noted that some extensions have been made to the XEP. There is an attribute on URLs
  40.  * that marks a url as a news feed and also a sub-element can be added to either a URL or conference
  41.  * indicated that it is shared amongst all users on a server.
  42.  *
  43.  * @author Alexander Wenckus
  44.  */
  45. public class BookmarkManager {
  46.     private static final Map<XMPPConnection, BookmarkManager> bookmarkManagerMap = new WeakHashMap<XMPPConnection, BookmarkManager>();

  48.     static {
  49.         PrivateDataManager.addPrivateDataProvider("storage", "storage:bookmarks",
  50.                 new Bookmarks.Provider());
  51.     }

  53.     /**
  54.      * Returns the <i>BookmarkManager</i> for a connection, if it doesn't exist it is created.
  55.      *
  56.      * @param connection the connection for which the manager is desired.
  57.      * @return Returns the <i>BookmarkManager</i> for a connection, if it doesn't
  58.      * exist it is created.
  59.      * @throws XMPPException 
  60.      * @throws SmackException thrown has not been authenticated.
  61.      * @throws IllegalArgumentException when the connection is null.
  62.      */
  63.     public synchronized static BookmarkManager getBookmarkManager(XMPPConnection connection)
  64.                     throws XMPPException, SmackException
  65.     {
  66.         BookmarkManager manager = (BookmarkManager) bookmarkManagerMap.get(connection);
  67.         if (manager == null) {
  68.             manager = new BookmarkManager(connection);
  69.         }
  70.         return manager;
  71.     }

  73.     private PrivateDataManager privateDataManager;
  74.     private Bookmarks bookmarks;
  75.     private final Object bookmarkLock = new Object();

  77.     /**
  78.      * Default constructor. Registers the data provider with the private data manager in the
  79.      * storage:bookmarks namespace.
  80.      *
  81.      * @param connection the connection for persisting and retrieving bookmarks.
  82.      */
  83.     private BookmarkManager(XMPPConnection connection) throws XMPPException, SmackException {
  84.         privateDataManager = PrivateDataManager.getInstanceFor(connection);
  85.         bookmarkManagerMap.put(connection, this);
  86.     }

  88.     /**
  89.      * Returns all currently bookmarked conferences.
  90.      *
  91.      * @return returns all currently bookmarked conferences
  92.      * @throws XMPPErrorException 
  93.      * @throws NoResponseException 
  94.      * @throws NotConnectedException 
  95.      * @throws InterruptedException 
  96.      * @see BookmarkedConference
  97.      */
  98.     public List<BookmarkedConference> getBookmarkedConferences() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  99.         retrieveBookmarks();
  100.         return Collections.unmodifiableList(bookmarks.getBookmarkedConferences());
  101.     }

  103.     /**
  104.      * Adds or updates a conference in the bookmarks.
  105.      *
  106.      * @param name the name of the conference
  107.      * @param jid the jid of the conference
  108.      * @param isAutoJoin whether or not to join this conference automatically on login
  109.      * @param nickname the nickname to use for the user when joining the conference
  110.      * @param password the password to use for the user when joining the conference
  111.      * @throws XMPPErrorException thrown when there is an issue retrieving the current bookmarks from
  112.      * the server.
  113.      * @throws NoResponseException if there was no response from the server.
  114.      * @throws NotConnectedException 
  115.      * @throws InterruptedException 
  116.      */
  117.     public void addBookmarkedConference(String name, String jid, boolean isAutoJoin,
  118.             String nickname, String password) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  119.     {
  120.         retrieveBookmarks();
  121.         BookmarkedConference bookmark
  122.                 = new BookmarkedConference(name, jid, isAutoJoin, nickname, password);
  123.         List<BookmarkedConference> conferences = bookmarks.getBookmarkedConferences();
  124.         if(conferences.contains(bookmark)) {
  125.             BookmarkedConference oldConference = conferences.get(conferences.indexOf(bookmark));
  126.             if(oldConference.isShared()) {
  127.                 throw new IllegalArgumentException("Cannot modify shared bookmark");
  128.             }
  129.             oldConference.setAutoJoin(isAutoJoin);
  130.             oldConference.setName(name);
  131.             oldConference.setNickname(nickname);
  132.             oldConference.setPassword(password);
  133.         }
  134.         else {
  135.             bookmarks.addBookmarkedConference(bookmark);
  136.         }
  137.         privateDataManager.setPrivateData(bookmarks);
  138.     }

  140.     /**
  141.      * Removes a conference from the bookmarks.
  142.      *
  143.      * @param jid the jid of the conference to be removed.
  144.      * @throws XMPPErrorException thrown when there is a problem with the connection attempting to
  145.      * retrieve the bookmarks or persist the bookmarks.
  146.      * @throws NoResponseException if there was no response from the server.
  147.      * @throws NotConnectedException 
  148.      * @throws InterruptedException 
  149.      * @throws IllegalArgumentException thrown when the conference being removed is a shared
  150.      * conference
  151.      */
  152.     public void removeBookmarkedConference(String jid) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  153.         retrieveBookmarks();
  154.         Iterator<BookmarkedConference> it = bookmarks.getBookmarkedConferences().iterator();
  155.         while(it.hasNext()) {
  156.             BookmarkedConference conference = it.next();
  157.             if(conference.getJid().equalsIgnoreCase(jid)) {
  158.                 if(conference.isShared()) {
  159.                     throw new IllegalArgumentException("Conference is shared and can't be removed");
  160.                 }
  161.                 it.remove();
  162.                 privateDataManager.setPrivateData(bookmarks);
  163.                 return;
  164.             }
  165.         }
  166.     }

  168.     /**
  169.      * Returns an unmodifiable collection of all bookmarked urls.
  170.      *
  171.      * @return returns an unmodifiable collection of all bookmarked urls.
  172.      * @throws XMPPErrorException thrown when there is a problem retriving bookmarks from the server.
  173.      * @throws NoResponseException if there was no response from the server.
  174.      * @throws NotConnectedException 
  175.      * @throws InterruptedException 
  176.      */
  177.     public List<BookmarkedURL> getBookmarkedURLs() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  178.         retrieveBookmarks();
  179.         return Collections.unmodifiableList(bookmarks.getBookmarkedURLS());
  180.     }

  182.     /**
  183.      * Adds a new url or updates an already existing url in the bookmarks.
  184.      *
  185.      * @param URL the url of the bookmark
  186.      * @param name the name of the bookmark
  187.      * @param isRSS whether or not the url is an rss feed
  188.      * @throws XMPPErrorException thrown when there is an error retriving or saving bookmarks from or to
  189.      * the server
  190.      * @throws NoResponseException if there was no response from the server.
  191.      * @throws NotConnectedException 
  192.      * @throws InterruptedException 
  193.      */
  194.     public void addBookmarkedURL(String URL, String name, boolean isRSS) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  195.         retrieveBookmarks();
  196.         BookmarkedURL bookmark = new BookmarkedURL(URL, name, isRSS);
  197.         List<BookmarkedURL> urls = bookmarks.getBookmarkedURLS();
  198.         if(urls.contains(bookmark)) {
  199.             BookmarkedURL oldURL = urls.get(urls.indexOf(bookmark));
  200.             if(oldURL.isShared()) {
  201.                 throw new IllegalArgumentException("Cannot modify shared bookmarks");
  202.             }
  203.             oldURL.setName(name);
  204.             oldURL.setRss(isRSS);
  205.         }
  206.         else {
  207.             bookmarks.addBookmarkedURL(bookmark);
  208.         }
  209.         privateDataManager.setPrivateData(bookmarks);
  210.     }

  212.     /**
  213.      *  Removes a url from the bookmarks.
  214.      *
  215.      * @param bookmarkURL the url of the bookmark to remove
  216.      * @throws XMPPErrorException thrown if there is an error retriving or saving bookmarks from or to
  217.      * the server.
  218.      * @throws NoResponseException if there was no response from the server.
  219.      * @throws NotConnectedException 
  220.      * @throws InterruptedException 
  221.      */
  222.     public void removeBookmarkedURL(String bookmarkURL) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  223.         retrieveBookmarks();
  224.         Iterator<BookmarkedURL> it = bookmarks.getBookmarkedURLS().iterator();
  225.         while(it.hasNext()) {
  226.             BookmarkedURL bookmark = it.next();
  227.             if(bookmark.getURL().equalsIgnoreCase(bookmarkURL)) {
  228.                 if(bookmark.isShared()) {
  229.                     throw new IllegalArgumentException("Cannot delete a shared bookmark.");
  230.                 }
  231.                 it.remove();
  232.                 privateDataManager.setPrivateData(bookmarks);
  233.                 return;
  234.             }
  235.         }
  236.     }

  238.     private Bookmarks retrieveBookmarks() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  239.         synchronized(bookmarkLock) {
  240.             if(bookmarks == null) {
  241.                 bookmarks = (Bookmarks) privateDataManager.getPrivateData("storage",
  242.                         "storage:bookmarks");
  243.             }
  244.             return bookmarks;
  245.         }
  246.     }
  247. }
Created with JaCoCo 0.7.4.201502262128