/* ********************************************************************** **
** Copyright notice **
** **
** (c) 2005-2009 RSSOwl Development Team **
** http://www.rssowl.org/ **
** **
** All rights reserved **
** **
** This program and the accompanying materials are made available under **
** the terms of the Eclipse Public License v1.0 which accompanies this **
** distribution, and is available at: **
** http://www.rssowl.org/legal/epl-v10.html **
** **
** A copy is found in the file epl-v10.html and important notices to the **
** license from the team is found in the textfile LICENSE.txt distributed **
** in this package. **
** **
** This copyright notice MUST APPEAR in all copies of the file! **
** **
** Contributors: **
** RSSOwl Development Team - initial API and implementation **
** **
** ********************************************************************** */
package org.rssowl.ui.internal;
import org.eclipse.core.commands.Command;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.program.Program;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IActionDelegate;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.update.ui.UpdateJob;
import org.rssowl.core.IApplicationService;
import org.rssowl.core.Owl;
import org.rssowl.core.connection.AuthenticationRequiredException;
import org.rssowl.core.connection.ConnectionException;
import org.rssowl.core.connection.CredentialsException;
import org.rssowl.core.connection.IConnectionPropertyConstants;
import org.rssowl.core.connection.MonitorCanceledException;
import org.rssowl.core.connection.NotModifiedException;
import org.rssowl.core.connection.SyncConnectionException;
import org.rssowl.core.connection.UnknownProtocolException;
import org.rssowl.core.internal.InternalOwl;
import org.rssowl.core.internal.persist.pref.DefaultPreferences;
import org.rssowl.core.interpreter.ITypeExporter.Options;
import org.rssowl.core.interpreter.InterpreterException;
import org.rssowl.core.interpreter.ParserException;
import org.rssowl.core.persist.IBookMark;
import org.rssowl.core.persist.IConditionalGet;
import org.rssowl.core.persist.IEntity;
import org.rssowl.core.persist.IFeed;
import org.rssowl.core.persist.IFolder;
import org.rssowl.core.persist.ILabel;
import org.rssowl.core.persist.IModelFactory;
import org.rssowl.core.persist.INews;
import org.rssowl.core.persist.INewsMark;
import org.rssowl.core.persist.ISearchCondition;
import org.rssowl.core.persist.ISearchMark;
import org.rssowl.core.persist.dao.DynamicDAO;
import org.rssowl.core.persist.dao.IBookMarkDAO;
import org.rssowl.core.persist.dao.IConditionalGetDAO;
import org.rssowl.core.persist.dao.ILabelDAO;
import org.rssowl.core.persist.dao.INewsDAO;
import org.rssowl.core.persist.dao.ISearchMarkDAO;
import org.rssowl.core.persist.event.BookMarkAdapter;
import org.rssowl.core.persist.event.BookMarkEvent;
import org.rssowl.core.persist.event.LabelEvent;
import org.rssowl.core.persist.event.LabelListener;
import org.rssowl.core.persist.event.runnable.EventType;
import org.rssowl.core.persist.pref.IPreferenceScope;
import org.rssowl.core.persist.service.PersistenceException;
import org.rssowl.core.util.CoreUtils;
import org.rssowl.core.util.DateUtils;
import org.rssowl.core.util.ExtensionUtils;
import org.rssowl.core.util.ITask;
import org.rssowl.core.util.JobQueue;
import org.rssowl.core.util.LoggingSafeRunnable;
import org.rssowl.core.util.StringUtils;
import org.rssowl.core.util.SyncUtils;
import org.rssowl.core.util.TaskAdapter;
import org.rssowl.core.util.Triple;
import org.rssowl.core.util.URIUtils;
import org.rssowl.ui.internal.OwlUI.Layout;
import org.rssowl.ui.internal.actions.FindUpdatesAction;
import org.rssowl.ui.internal.actions.OpenInBrowserAction;
import org.rssowl.ui.internal.actions.SendLinkAction;
import org.rssowl.ui.internal.dialogs.FatalOutOfMemoryErrorDialog;
import org.rssowl.ui.internal.dialogs.LoginDialog;
import org.rssowl.ui.internal.dialogs.properties.EntityPropertyPageWrapper;
import org.rssowl.ui.internal.dialogs.welcome.TutorialWizard;
import org.rssowl.ui.internal.dialogs.welcome.WelcomeWizard;
import org.rssowl.ui.internal.handler.LabelNewsHandler;
import org.rssowl.ui.internal.handler.ShareNewsHandler;
import org.rssowl.ui.internal.notifier.NotificationService;
import org.rssowl.ui.internal.services.CleanUpReminderService;
import org.rssowl.ui.internal.services.ContextService;
import org.rssowl.ui.internal.services.DownloadService;
import org.rssowl.ui.internal.services.FeedReloadService;
import org.rssowl.ui.internal.services.SavedSearchService;
import org.rssowl.ui.internal.services.SyncService;
import org.rssowl.ui.internal.util.ImportUtils;
import org.rssowl.ui.internal.util.JobRunner;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* <p>
* Note: The Controller should not be responsible for handling Exceptions, e.g.
* showing a Dialog when Authentication is required. Its only responsible for
* calling the appropiate methods on a complex operation like loading a Feed.
* </p>
* <p>
* Note: As required by the UI, the controller should be filled with more
* methods.
* </p>
*
* @author bpasero
*/
public class Controller {
/* Backup Files */
public static final String DAILY_BACKUP = "backup.opml"; //$NON-NLS-1$
public static final String WEEKLY_BACKUP = "backup_weekly.opml"; //$NON-NLS-1$
private static final String BACKUP_TMP = "backup.tmp"; //$NON-NLS-1$
/* Extension-Points */
private static final String ENTITY_PROPERTY_PAGE_EXTENSION_POINT = "org.rssowl.ui.EntityPropertyPage"; //$NON-NLS-1$
/** Property to store info about a Realm in a Bookmark */
public static final String BM_REALM_PROPERTY = "org.rssowl.ui.BMRealmProperty"; //$NON-NLS-1$
/** Prefix for dynamic Label Actions */
public static final String LABEL_ACTION_PREFIX = "org.rssowl.ui.LabelAction"; //$NON-NLS-1$
/** Key to store error messages into entities during reload */
public static final String LOAD_ERROR_KEY = "org.rssowl.ui.internal.LoadErrorKey"; //$NON-NLS-1$
public static final String LOAD_ERROR_LINK_KEY = "org.rssowl.ui.internal.LoadErrorLinkKey"; //$NON-NLS-1$
/* ID of RSSOwl's Keybinding Category */
private static final String RSSOWL_KEYBINDING_CATEGORY = "org.rssowl.ui.commands.category.RSSOwl"; //$NON-NLS-1$
/* The Singleton Instance */
private static Controller fInstance;
/* Default Max. number of concurrent running reload Jobs */
private static final int DEFAULT_MAX_CONCURRENT_RELOAD_JOBS = 10;
/* System Property to override default Max. number of concurrent running reload Jobs */
private static final String MAX_CONCURRENT_RELOAD_JOBS_PROPERTY = "maxReloadJobs"; //$NON-NLS-1$
/* Max. number of concurrent Jobs for saving a Feed */
private static final int MAX_CONCURRENT_SAVE_JOBS = 1;
/* Max number of jobs in the queue used for saving feeds before it blocks */
private static final int MAX_SAVE_QUEUE_SIZE = 1;
/* Connection Timeouts in MS */
private static final int DEFAULT_FEED_CON_TIMEOUT = 30000;
/* System Property to override default connection timeout */
private static final String FEED_CON_TIMEOUT_PROPERTY = "conTimeout"; //$NON-NLS-1$
/* System Property to import a file on first startup */
private static final String IMPORT_PROPERTY = "import"; //$NON-NLS-1$
/* System Property indicating that the application is running portable */
private static final String PORTABLE_PROPERTY = "portable"; //$NON-NLS-1$
/* System Property indicating that the application should not support update */
private static final String DISABLE_UPDATE_PROPERTY = "disableUpdate"; //$NON-NLS-1$
/* Flag for an Out of Memory Exception and Emergency Shutdown */
private static final AtomicBoolean OOM_EMERGENCY_SHUTDOWN = new AtomicBoolean(false);
/* Flag to turn RSSOwl into Offline Mode */
private static final AtomicBoolean IS_OFFLINE = new AtomicBoolean(false);
/* Queue for reloading Feeds */
private final JobQueue fReloadFeedQueue;
/* Queue for saving Feeds */
private final JobQueue fSaveFeedQueue;
/* Notification Service */
private NotificationService fNotificationService;
/* Saved Search Service */
private SavedSearchService fSavedSearchService;
/* Download Service */
private DownloadService fDownloadService;
/* Feed-Reload Service */
private FeedReloadService fFeedReloadService;
/* Synchronization Service */
private SyncService fSyncService;
/* Contributed Entity-Property-Pages */
final List<EntityPropertyPageWrapper> fEntityPropertyPages;
/* Flag is set to TRUE when the application is done starting */
private boolean fIsStarted;
/* Flag is set to TRUE when shutting down the application */
private boolean fShuttingDown;
/* Flag is set to TRUE when restarting the application */
private boolean fRestarting;
/* Service to manage Contexts */
private ContextService fContextService;
/* Link Transformer Extension Point */
private static final String LINK_TRANSFORMER_EXTENSION_POINT = "org.rssowl.ui.LinkTransformer"; //$NON-NLS-1$
/* Share News Provider Extension Point */
private static final String SHARE_PROVIDER_EXTENSION_POINT = "org.rssowl.ui.ShareProvider"; //$NON-NLS-1$
/* Feed Search Extension Point */
private static final String FEED_SEARCH_EXTENSION_POINT = "org.rssowl.ui.FeedSearch"; //$NON-NLS-1$
/* Token to replace keywords with in the Feed Search Link */
private static final String FEED_SEARCH_KEYWORD_TOKEN = "[K]"; //$NON-NLS-1$
/* Some legacy preferences from pre 2.1 */
private static final String LEGACY_PREF_LAYOUT_CLASSIC = "org.rssowl.ui.internal.editors.feed.LayoutVertical"; //$NON-NLS-1$
private static final String LEGACY_PREF_BROWSER_MAXIMIZED = "org.rssowl.ui.internal.editors.feed.BrowserMaximized"; //$NON-NLS-1$
/* News Transformation Constants */
private static final String DEFAULT_TRANSFORMER_ID = "org.rssowl.ui.ReadabilityTransformer"; //$NON-NLS-1$
private static final String DEFAULT_TRANSFORMER_EMBEDDED_PARAMETER = "&embedded"; //$NON-NLS-1$
/* Misc. */
private final IApplicationService fAppService;
private CleanUpReminderService fCleanUpReminderService;
private final IBookMarkDAO fBookMarkDAO;
private final ISearchMarkDAO fSearchMarkDAO;
private final IConditionalGetDAO fConditionalGetDAO;
private final ILabelDAO fLabelDao;
private final IModelFactory fFactory;
private final Lock fLoginDialogLock = new ReentrantLock();
private final AtomicLong fLastGoogleLoginCancel = new AtomicLong(0);
private BookMarkAdapter fBookMarkListener;
private LabelListener fLabelListener;
private ListenerList fBookMarkLoadListeners = new ListenerList();
private final int fConnectionTimeout;
private List<ShareProvider> fShareProviders = new ArrayList<ShareProvider>();
private Map<String, LinkTransformer> fLinkTransformers = new HashMap<String, LinkTransformer>();
private Map<Long, Long> fDeletedBookmarksCache = new ConcurrentHashMap<Long, Long>();
private String fFeedSearchUrl;
private boolean fShowWelcome;
private boolean fPortable;
private boolean fDisableUpdate;
private String fNl;
/**
* A listener that informs when a {@link IBookMark} is getting reloaded from
* the {@link Controller}.
*/
public static interface BookMarkLoadListener {
/**
* @param bookmark the {@link IBookMark} that is about to load.
*/
void bookMarkAboutToLoad(IBookMark bookmark);
/**
* @param bookmark the {@link IBookMark} that is done loading.
*/
void bookMarkDoneLoading(IBookMark bookmark);
}
/* Task to perform Reload-Operations */
private class ReloadTask implements ITask {
private final Long fId;
private final IBookMark fBookMark;
private final Shell fShell;
private final Priority fPriority;
private final Map<Object, Object> fProperties;
ReloadTask(IBookMark bookmark, Map<Object, Object> properties, Shell shell, ITask.Priority priority) {
fProperties = properties;
Assert.isNotNull(bookmark);
Assert.isNotNull(bookmark.getId());
fBookMark = bookmark;
fId = bookmark.getId();
fShell = shell;
fPriority = priority;
}
public IStatus run(IProgressMonitor monitor) {
IStatus status = reload(fBookMark, fProperties, fShell, monitor);
return status;
}
public String getName() {
return fBookMark.getName();
}
public Priority getPriority() {
return fPriority;
}
@Override
public int hashCode() {
return fId.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final ReloadTask other = (ReloadTask) obj;
return fId.equals(other.fId);
}
}
private Controller() {
int maxConcurrentReloadJobs = getSystemProperty(MAX_CONCURRENT_RELOAD_JOBS_PROPERTY, 0, DEFAULT_MAX_CONCURRENT_RELOAD_JOBS);
fReloadFeedQueue = new JobQueue(Messages.Controller_UPDATING_FEEDS, Messages.Controller_UPDATING, maxConcurrentReloadJobs, Integer.MAX_VALUE, true, 0);
fSaveFeedQueue = new JobQueue(Messages.Controller_UPDATING_FEEDS, MAX_CONCURRENT_SAVE_JOBS, MAX_SAVE_QUEUE_SIZE, false, 0);
fSaveFeedQueue.setUnknownProgress(true);
fEntityPropertyPages = loadEntityPropertyPages();
fBookMarkDAO = DynamicDAO.getDAO(IBookMarkDAO.class);
fSearchMarkDAO = DynamicDAO.getDAO(ISearchMarkDAO.class);
fConditionalGetDAO = DynamicDAO.getDAO(IConditionalGetDAO.class);
fLabelDao = DynamicDAO.getDAO(ILabelDAO.class);
fAppService = Owl.getApplicationService();
fFactory = Owl.getModelFactory();
fConnectionTimeout = getSystemProperty(FEED_CON_TIMEOUT_PROPERTY, DEFAULT_FEED_CON_TIMEOUT, DEFAULT_FEED_CON_TIMEOUT);
fPortable = System.getProperty(PORTABLE_PROPERTY) != null;
fDisableUpdate = Boolean.getBoolean(DISABLE_UPDATE_PROPERTY);
fNl = System.getProperty("line.separator"); //$NON-NLS-1$
if (!StringUtils.isSet(fNl))
fNl = "\n"; //$NON-NLS-1$
}
private int getSystemProperty(String key, int minValue, int defaultValue) {
String strVal = System.getProperty(key);
if (strVal != null) {
int intVal = 0;
try {
intVal = Integer.parseInt(strVal);
} catch (NumberFormatException e) {
Activator.getDefault().logError(e.getMessage(), e);
return defaultValue;
}
if (intVal > minValue)
return intVal;
}
return defaultValue;
}
private void registerListeners() {
/* Delete Favicon when Bookmark gets deleted and remember ID */
fBookMarkListener = new BookMarkAdapter() {
@Override
public void entitiesDeleted(Set<BookMarkEvent> events) {
if (!fShuttingDown) {
for (BookMarkEvent event : events) {
Long id = event.getEntity().getId();
if (id != null) {
OwlUI.deleteImage(id);
fDeletedBookmarksCache.put(id, id);
}
}
}
}
};
DynamicDAO.addEntityListener(IBookMark.class, fBookMarkListener);
/* Update Label conditions when Label name changes */
fLabelListener = new LabelListener() {
public void entitiesAdded(Set<LabelEvent> events) {
if (fShuttingDown)
return;
onLabelsChange(events, EventType.PERSIST);
if (PlatformUI.isWorkbenchRunning())
updateLabelCommands();
}
public void entitiesUpdated(Set<LabelEvent> events) {
if (fShuttingDown)
return;
onLabelsChange(events, EventType.UPDATE);
if (PlatformUI.isWorkbenchRunning()) {
updateLabelCommands();
for (LabelEvent event : events) {
ILabel oldLabel = event.getOldLabel();
ILabel updatedLabel = event.getEntity();
if (!oldLabel.getName().equals(updatedLabel.getName())) {
updateLabelConditions(oldLabel.getName(), updatedLabel.getName());
}
}
}
}
public void entitiesDeleted(Set<LabelEvent> events) {
if (fShuttingDown)
return;
onLabelsChange(events, EventType.REMOVE);
if (PlatformUI.isWorkbenchRunning())
updateLabelCommands();
}
};
DynamicDAO.addEntityListener(ILabel.class, fLabelListener);
}
private void onLabelsChange(Set<LabelEvent> events, EventType type) {
boolean needsSave = false;
/* Retrieve List of Deleted Labels */
IPreferenceScope preferences = Owl.getPreferenceService().getGlobalScope();
String[] deletedLabels = preferences.getStrings(DefaultPreferences.DELETED_LABELS);
Set<String> deletedLabelsSet = new HashSet<String>();
if (deletedLabels != null) {
for (String label : deletedLabels) {
deletedLabelsSet.add(label);
}
}
/* Can return early if no deleted labels known and labels added or updated */
else if (type == EventType.PERSIST || type == EventType.UPDATE) {
return;
}
/* Handle Events */
switch (type) {
/* Labels Added */
case PERSIST:
for (LabelEvent event : events) {
if (deletedLabelsSet.remove(event.getEntity().getName()))
needsSave = true;
}
break;
/* Labels Deleted */
case REMOVE:
for (LabelEvent event : events) {
deletedLabelsSet.add(event.getEntity().getName());
}
needsSave = true;
break;
/* Labels Updated (only react on name change) */
case UPDATE:
for (LabelEvent event : events) {
if (event.getOldLabel() != null) {
String oldName = event.getOldLabel().getName();
String newName = event.getEntity().getName();
if (newName != null && !newName.equals(oldName)) {
if (deletedLabelsSet.remove(newName))
needsSave = true;
}
}
}
break;
}
/* Update List of Deleted Labels */
if (needsSave) {
if (deletedLabelsSet.isEmpty())
preferences.delete(DefaultPreferences.DELETED_LABELS);
else
preferences.putStrings(DefaultPreferences.DELETED_LABELS, deletedLabelsSet.toArray(new String[deletedLabelsSet.size()]));
}
}
private void updateLabelConditions(String oldLabelName, String newLabelName) {
Set<ISearchMark> searchMarksToUpdate = new HashSet<ISearchMark>(1);
for (ISearchMark searchMark : fSearchMarkDAO.loadAll()) {
List<ISearchCondition> conditions = searchMark.getSearchConditions();
for (ISearchCondition condition : conditions) {
if (condition.getField().getId() == INews.LABEL && condition.getValue().equals(oldLabelName)) {
condition.setValue(newLabelName);
searchMarksToUpdate.add(searchMark);
}
}
}
DynamicDAO.getDAO(ISearchMarkDAO.class).saveAll(searchMarksToUpdate);
}
private void unregisterListeners() {
DynamicDAO.removeEntityListener(IBookMark.class, fBookMarkListener);
DynamicDAO.removeEntityListener(ILabel.class, fLabelListener);
}
private List<EntityPropertyPageWrapper> loadEntityPropertyPages() {
List<EntityPropertyPageWrapper> pages = new ArrayList<EntityPropertyPageWrapper>();
IExtensionRegistry reg = Platform.getExtensionRegistry();
IConfigurationElement elements[] = reg.getConfigurationElementsFor(ENTITY_PROPERTY_PAGE_EXTENSION_POINT);
/* For each contributed property Page */
for (IConfigurationElement element : elements) {
try {
String id = element.getAttribute("id"); //$NON-NLS-1$
String name = element.getAttribute("name"); //$NON-NLS-1$
int order = Integer.valueOf(element.getAttribute("order")); //$NON-NLS-1$
boolean handlesMultipleEntities = Boolean.valueOf(element.getAttribute("handlesMultipleEntities")); //$NON-NLS-1$
List<Class<?>> targetEntities = new ArrayList<Class<?>>();
IConfigurationElement[] entityTargets = element.getChildren("targetEntity"); //$NON-NLS-1$
for (IConfigurationElement entityTarget : entityTargets)
targetEntities.add(Class.forName(entityTarget.getAttribute("class"))); //$NON-NLS-1$
pages.add(new EntityPropertyPageWrapper(id, element, targetEntities, name, order, handlesMultipleEntities));
} catch (ClassNotFoundException e) {
Activator.getDefault().logError(e.getMessage(), e);
}
}
return pages;
}
/**
* @return The Singleton Instance.
*/
public static Controller getDefault() {
if (fInstance == null)
fInstance = new Controller();
return fInstance;
}
/**
* @return <code>true</code> if the {@link Controller} has been initialized
* before and <code>false</code> otherwise.
*/
public static boolean isInitialized() {
return fInstance != null;
}
/**
* @param entities
* @return The EntityPropertyPageWrappers for the given Entity.
*/
public Set<EntityPropertyPageWrapper> getEntityPropertyPagesFor(List<IEntity> entities) {
Set<EntityPropertyPageWrapper> pages = new HashSet<EntityPropertyPageWrapper>();
/* Retrieve Class-Objects from Entities */
Set<Class<? extends IEntity>> entityClasses = new HashSet<Class<? extends IEntity>>();
for (IEntity entity : entities)
entityClasses.add(entity.getClass());
/* For each contributed Entity Property-Page */
for (EntityPropertyPageWrapper pageWrapper : fEntityPropertyPages) {
/* Ignore Pages that dont handle Multi-Selection */
if (!pageWrapper.isHandlingMultipleEntities() && entities.size() > 1)
continue;
/* Check if Page is handling all of the given Entity-Classes */
if (pageWrapper.handles(entityClasses))
pages.add(pageWrapper);
}
return pages;
}
/**
* @return Returns the savedSearchService.
*/
public SavedSearchService getSavedSearchService() {
return fSavedSearchService;
}
/**
* @return Returns the download service.
*/
public DownloadService getDownloadService() {
return fDownloadService;
}
/**
* @return Returns the notificationService.
*/
public NotificationService getNotificationService() {
return fNotificationService;
}
/**
* @return Returns the synchronization service.
*/
public SyncService getSyncService() {
return fSyncService;
}
/**
* @return Returns the contextService.
*/
public ContextService getContextService() {
/* Create the Context Service if not yet done */
if (fContextService == null)
fContextService = new ContextService();
return fContextService;
}
/**
* @return Returns the JobFamily all reload-jobs belong to.
*/
public Object getReloadFamily() {
return fReloadFeedQueue;
}
/**
* @return Returns the reload-service.
*/
public FeedReloadService getReloadService() {
return fFeedReloadService;
}
/**
* Reload the given List of BookMarks. The BookMarks are processed in a queue
* that stores all Tasks of this kind and guarantees that a certain amount of
* Jobs process the Task concurrently.
*
* @param bookmarks The BookMarks to reload.
* @param properties any kind of properties to use for the reload or
* <code>null</code> if none.
* @param shell The Shell this operation is running in, used to open Dialogs
* if necessary.
*/
public void reloadQueued(Set<IBookMark> bookmarks, Map<Object, Object> properties, final Shell shell) {
/* Decide wether this is a high prio Job */
boolean highPrio = bookmarks.size() == 1;
/* Create a Task for each Feed to Reload */
List<ITask> tasks = new ArrayList<ITask>();
for (final IBookMark bookmark : bookmarks) {
ReloadTask task = new ReloadTask(bookmark, properties, shell, highPrio ? ITask.Priority.SHORT : ITask.Priority.DEFAULT);
/* Check if Task is not yet Queued already */
if (!fReloadFeedQueue.isQueued(task))
tasks.add(task);
}
fReloadFeedQueue.schedule(tasks);
}
/**
* Reload the given BookMark. The BookMark is processed in a queue that stores
* all Tasks of this kind and guarantees that a certain amount of Jobs process
* the Task concurrently.
*
* @param bookmark The BookMark to reload.
* @param properties any kind of properties to use for the reload or
* <code>null</code> if none.
* @param shell The Shell this operation is running in, used to open Dialogs
* if necessary.
*/
public void reloadQueued(IBookMark bookmark, Map<Object, Object> properties, final Shell shell) {
/* Create a Task for the Bookmark to Reload */
ReloadTask task = new ReloadTask(bookmark, properties, shell, ITask.Priority.DEFAULT);
/* Check if Task is not yet Queued already */
if (!fReloadFeedQueue.isQueued(task))
fReloadFeedQueue.schedule(task);
}
/**
* Reload the given BookMark.
*
* @param bookmark The BookMark to reload.
* @param shell The Shell this operation is running in, used to open Dialogs
* if necessary, or <code>NULL</code> if no Shell is available.
* @param monitor A monitor to report progress and respond to cancelation. Use
* a <code>NullProgressMonitor</code> if no progress is to be reported.
* @return Returns the Status of the Operation.
*/
public IStatus reload(final IBookMark bookmark, Shell shell, final IProgressMonitor monitor) {
return reload(bookmark, null, shell, monitor);
}
private IStatus reload(final IBookMark bookmark, Map<Object, Object> properties, Shell shell, final IProgressMonitor monitor) {
Assert.isNotNull(bookmark);
CoreException ex = null;
/* Ignore Reload in Offline Mode */
if (isOffline())
return Status.OK_STATUS;
/* Keep URL and Homepage of Feed as final var */
final URI feedLink = bookmark.getFeedLinkReference().getLink();
URI feedHomepage = null;
try {
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark))
return Status.CANCEL_STATUS;
/* Notify about Bookmark getting loaded */
fireBookMarkAboutToLoad(bookmark);
/* Load Conditional Get for the URL */
IConditionalGet conditionalGet = fConditionalGetDAO.load(feedLink);
/* Define Properties for Connection */
if (properties == null)
properties = new HashMap<Object, Object>();
properties.put(IConnectionPropertyConstants.CON_TIMEOUT, fConnectionTimeout);
/* Sync Specific Item Limit derived from retention settings */
if (SyncUtils.isSynchronized(bookmark)) {
IPreferenceScope defaultPreferences = Owl.getPreferenceService().getDefaultScope();
IPreferenceScope preferences = Owl.getPreferenceService().getEntityScope(bookmark);
/* Item Limit */
int itemLimit;
if (preferences.getBoolean(DefaultPreferences.DEL_NEWS_BY_COUNT_STATE))
itemLimit = preferences.getInteger(DefaultPreferences.DEL_NEWS_BY_COUNT_VALUE);
else
itemLimit = defaultPreferences.getInteger(DefaultPreferences.DEL_NEWS_BY_COUNT_VALUE);
properties.put(IConnectionPropertyConstants.ITEM_LIMIT, itemLimit);
/* Date Limit */
long dateLimit = 0;
if (preferences.getBoolean(DefaultPreferences.DEL_NEWS_BY_AGE_STATE)) {
int days = preferences.getInteger(DefaultPreferences.DEL_NEWS_BY_AGE_VALUE);
dateLimit = DateUtils.getToday().getTimeInMillis() - (days * DateUtils.DAY);
}
if (dateLimit != 0)
properties.put(IConnectionPropertyConstants.DATE_LIMIT, dateLimit);
/* Uncommitted Synchronized Items */
if (fSyncService != null)
properties.put(IConnectionPropertyConstants.UNCOMMITTED_ITEMS, fSyncService.getUncommittedItems());
}
/* Add Conditional GET Headers if present */
if (conditionalGet != null) {
String ifModifiedSince = conditionalGet.getIfModifiedSince();
if (ifModifiedSince != null)
properties.put(IConnectionPropertyConstants.IF_MODIFIED_SINCE, ifModifiedSince);
String ifNoneMatch = conditionalGet.getIfNoneMatch();
if (ifNoneMatch != null)
properties.put(IConnectionPropertyConstants.IF_NONE_MATCH, ifNoneMatch);
}
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark))
return Status.CANCEL_STATUS;
/* Load the Feed */
final Triple<IFeed, IConditionalGet, URI> result = Owl.getConnectionService().reload(feedLink, monitor, properties);
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark) || result == null)
return Status.CANCEL_STATUS;
/* Remember Homepage of feed */
feedHomepage = result.getFirst().getHomepage();
/* Update ConditionalGet Entity */
boolean conditionalGetIsNull = (conditionalGet == null);
conditionalGet = updateConditionalGet(feedLink, conditionalGet, result.getSecond());
boolean deleteConditionalGet = (!conditionalGetIsNull && conditionalGet == null);
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark))
return Status.CANCEL_STATUS;
/* Load the Favicon directly afterwards if required */
if (!InternalOwl.PERF_TESTING && OwlUI.getFavicon(bookmark) == null)
loadFavicon(bookmark, monitor, result.getThird(), feedHomepage);
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark))
return Status.CANCEL_STATUS;
/* Merge and Save Feed */
if (!InternalOwl.TESTING) {
final IConditionalGet finalConditionalGet = conditionalGet;
final boolean finalDeleteConditionalGet = deleteConditionalGet;
fSaveFeedQueue.schedule(new TaskAdapter() {
public IStatus run(IProgressMonitor otherMonitor) {
/* Return on Cancelation or shutdown or deletion */
if (otherMonitor.isCanceled() || !shouldProceedReloading(monitor, bookmark))
return Status.CANCEL_STATUS;
/* Find out if retention required or not */
INewsMark activeFeedViewNewsMark = OwlUI.getActiveFeedViewNewsMark();
boolean runRetention = true;
if (activeFeedViewNewsMark != null) {
if (activeFeedViewNewsMark.equals(bookmark))
runRetention = false; //Avoid clean up on feed the user is reading on
else if (activeFeedViewNewsMark instanceof FolderNewsMark && ((FolderNewsMark) activeFeedViewNewsMark).contains(bookmark))
runRetention = false; //Avoid clean up on folder the user is reading on if feed contained
}
/* Handle Feed Reload */
fAppService.handleFeedReload(bookmark, result.getFirst(), finalConditionalGet, finalDeleteConditionalGet, runRetention, otherMonitor);
return Status.OK_STATUS;
}
@Override
public String getName() {
return Messages.Controller_UPDATING_FEEDS_JOB;
}
});
} else {
fAppService.handleFeedReload(bookmark, result.getFirst(), conditionalGet, deleteConditionalGet, true, new NullProgressMonitor());
}
}
/* Error while reloading */
catch (CoreException e) {
ex = e;
/* Authentication Required */
final Shell[] shellAr = new Shell[] { shell };
if (e instanceof AuthenticationRequiredException && shouldProceedReloading(monitor, bookmark)) {
/* Resolve active Shell if necessary */
if (shellAr[0] == null || shellAr[0].isDisposed()) {
SafeRunner.run(new LoggingSafeRunnable() {
public void run() throws Exception {
shellAr[0] = OwlUI.getActiveShell();
}
});
}
/* Only one Login Dialog at the same time */
if (shellAr[0] != null && !shellAr[0].isDisposed()) {
final boolean isSynchronizedFeed = SyncUtils.isSynchronized(bookmark);
boolean openLoginDialog = false;
/* Normal Feed (one Login Dialog per feed) */
if (!isSynchronizedFeed) {
fLoginDialogLock.lock();
openLoginDialog = true;
}
/* Synchronized Feed (only open login dialog once) */
else {
openLoginDialog = fLoginDialogLock.tryLock();
}
/* Open Login Dialog */
final AuthenticationRequiredException authEx = (AuthenticationRequiredException) e;
if (openLoginDialog) {
try {
JobRunner.runSyncedInUIThread(shellAr[0], new Runnable() {
public void run() {
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark))
return;
/* Credentials might have been provided meanwhile in another dialog */
if (!isSynchronizedFeed) {
try {
URI normalizedUri = URIUtils.normalizeUri(feedLink, true);
if (Owl.getConnectionService().getAuthCredentials(normalizedUri, authEx.getRealm()) != null) {
reloadQueued(bookmark, null, shellAr[0]);
return;
}
} catch (CredentialsException exe) {
Activator.getDefault().getLog().log(exe.getStatus());
}
}
/* Show Login Dialog */
int status = -1;
if (isSynchronizedFeed)
status = OwlUI.openSyncLogin(shellAr[0]);
else
status = new LoginDialog(shellAr[0], feedLink, authEx.getRealm()).open();
/* Remember time when user hit cancel from a Google Reader login challenge */
if (status == Window.CANCEL && isSynchronizedFeed)
fLastGoogleLoginCancel.set(System.currentTimeMillis());
/* Trigger another Reload if credentials have been provided */
if (status == Window.OK && shouldProceedReloading(monitor, bookmark)) {
/* Store info about Realm in Bookmark */
if (StringUtils.isSet(authEx.getRealm())) {
bookmark.setProperty(BM_REALM_PROPERTY, authEx.getRealm());
fBookMarkDAO.save(bookmark);
}
/* Re-Reload Bookmark */
reloadQueued(bookmark, null, shellAr[0]);
}
/* Update Error Flag if user hit Cancel */
else if (shouldProceedReloading(monitor, bookmark) && !bookmark.isErrorLoading()) {
updateErrorLoading(bookmark, authEx);
}
}
});
return Status.OK_STATUS;
} finally {
fLoginDialogLock.unlock();
}
}
/* Update error flag for other synchronized feeds not loading */
else if (shouldProceedReloading(monitor, bookmark) && !bookmark.isErrorLoading()) {
updateErrorLoading(bookmark, authEx);
}
}
}
/* Load the Favicon directly afterwards if required */
else if (!InternalOwl.TESTING && (e instanceof NotModifiedException || e instanceof InterpreterException || e instanceof ParserException) && OwlUI.getFavicon(bookmark) == null && shouldProceedReloading(monitor, bookmark)) {
loadFavicon(bookmark, monitor, feedLink, feedHomepage);
}
/* Feed has not been Modified Since */
if (e instanceof NotModifiedException)
return Status.OK_STATUS;
/* Reload was canceled (avoid logging to avoid spam) */
if (e.getStatus() != null && e.getStatus().getException() instanceof MonitorCanceledException)
return Status.OK_STATUS;
/* Report Exceptions as Info to avoid Log Spam */
return createInfoStatus(e.getStatus(), bookmark, feedLink);
}
/* Save Error State to the Bookmark if present */
finally {
updateErrorIndicator(bookmark, monitor, ex);
/* Notify about Bookmark done loading */
fireBookMarkDoneLoading(bookmark);
}
return Status.OK_STATUS;
}
private void updateErrorLoading(final IBookMark bookmark, final AuthenticationRequiredException authEx) {
bookmark.setErrorLoading(true);
if (StringUtils.isSet(authEx.getMessage()))
bookmark.setProperty(LOAD_ERROR_KEY, authEx.getMessage());
bookmark.removeProperty(LOAD_ERROR_LINK_KEY);
fBookMarkDAO.save(bookmark);
}
private void loadFavicon(final IBookMark bookmark, final IProgressMonitor monitor, final URI feedLink, URI feedHomepage) {
try {
byte[] faviconBytes = null;
/* Specially Handle Synchronized Feeds if matching a set of URLs */
if (SyncUtils.isSynchronized(bookmark)) {
String link = bookmark.getFeedLinkReference().getLinkAsText();
if (SyncUtils.GOOGLE_READER_ALL_ITEMS_FEED.equals(link))
faviconBytes = toByte("/icons/obj16/bookmark.gif"); //$NON-NLS-1$
else if (SyncUtils.GOOGLE_READER_STARRED_FEED.equals(link))
faviconBytes = toByte("/icons/obj16/gr_starred.gif"); //$NON-NLS-1$
else if (SyncUtils.GOOGLE_READER_SHARED_ITEMS_FEED.equals(link))
faviconBytes = toByte("/icons/obj16/gr_shared.gif"); //$NON-NLS-1$
else if (SyncUtils.GOOGLE_READER_RECOMMENDED_ITEMS_FEED.equals(link))
faviconBytes = toByte("/icons/obj16/gr_recommended.gif"); //$NON-NLS-1$
else if (SyncUtils.GOOGLE_READER_NOTES_FEED.equals(link))
faviconBytes = toByte("/icons/obj16/gr_notes.gif"); //$NON-NLS-1$
}
/* First try using the Homepage of the Feed */
if (faviconBytes == null && feedHomepage != null && StringUtils.isSet(feedHomepage.toString()) && feedHomepage.isAbsolute())
faviconBytes = Owl.getConnectionService().getFeedIcon(feedHomepage, monitor);
/* Then try with Feed address itself */
if (faviconBytes == null)
faviconBytes = Owl.getConnectionService().getFeedIcon(feedLink, monitor);
/* Store locally */
if (shouldProceedReloading(monitor, bookmark))
OwlUI.storeImage(bookmark.getId(), faviconBytes, OwlUI.BOOKMARK, 16, 16);
/* This will trigger an update to the viewer to show the favicon */
if (faviconBytes != null)
DynamicDAO.save(bookmark);
} catch (UnknownProtocolException e) {
Activator.getDefault().getLog().log(e.getStatus());
} catch (ConnectionException e) {
Activator.getDefault().getLog().log(e.getStatus());
}
}
private byte[] toByte(String file) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
InputStream fileStream = getClass().getResourceAsStream(file);
CoreUtils.copy(fileStream, out);
return out.toByteArray();
}
private void updateErrorIndicator(final IBookMark bookmark, final IProgressMonitor monitor, CoreException ex) {
/* Return on Cancelation or shutdown or deletion */
if (!shouldProceedReloading(monitor, bookmark))
return;
/* Reset Error-Loading flag if necessary */
if (bookmark.isErrorLoading() && (ex == null || ex instanceof NotModifiedException)) {
bookmark.setErrorLoading(false);
bookmark.removeProperty(LOAD_ERROR_KEY);
bookmark.removeProperty(LOAD_ERROR_LINK_KEY);
fBookMarkDAO.save(bookmark);
}
/* Set Error-Loading flag if necessary */
else if (ex != null && !(ex instanceof NotModifiedException) && !(ex instanceof AuthenticationRequiredException)) {
boolean wasShowingError = bookmark.isErrorLoading();
bookmark.setErrorLoading(true);
Object oldMessage = bookmark.getProperty(LOAD_ERROR_KEY);
Object oldLink = bookmark.getProperty(LOAD_ERROR_LINK_KEY);
String message = CoreUtils.toMessage(ex);
if (StringUtils.isSet(message))
bookmark.setProperty(LOAD_ERROR_KEY, message);
else
bookmark.removeProperty(LOAD_ERROR_KEY);
String link = null;
if (ex instanceof SyncConnectionException)
link = ((SyncConnectionException) ex).getUserUrl();
if (StringUtils.isSet(link))
bookmark.setProperty(LOAD_ERROR_LINK_KEY, link);
else
bookmark.removeProperty(LOAD_ERROR_LINK_KEY);
if (!wasShowingError || (oldMessage != null && message == null) || (message != null && !message.equals(oldMessage)) || (oldLink != null && link == null) || (link != null && !link.equals(oldLink)))
fBookMarkDAO.save(bookmark);
}
}
private boolean shouldProceedReloading(IProgressMonitor monitor, IBookMark mark) {
if (InternalOwl.TESTING)
return true;
if (fShuttingDown)
return false;
if (monitor.isCanceled())
return false;
if (isDeleted(mark))
return false;
return true;
}
private boolean isDeleted(IBookMark mark) {
Long id = mark.getId();
if (id != null)
return fDeletedBookmarksCache.containsKey(id);
return false;
}
/*
* Note that this does not save the conditional get, it just updates the its
* values.
*/
private IConditionalGet updateConditionalGet(final URI feedLink, IConditionalGet oldConditionalGet, IConditionalGet newConditionalGet) {
/* Conditional Get not provided, return */
if (newConditionalGet == null)
return null;
String ifModifiedSince = newConditionalGet.getIfModifiedSince();
String ifNoneMatch = newConditionalGet.getIfNoneMatch();
if (ifModifiedSince != null || ifNoneMatch != null) {
/* Create new */
if (oldConditionalGet == null)
return fFactory.createConditionalGet(ifModifiedSince, feedLink, ifNoneMatch);
/* Else: Update old */
oldConditionalGet.setHeaders(ifModifiedSince, ifNoneMatch);
return oldConditionalGet;
}
return null;
}
/**
* Tells the Controller to start. This method is called automatically from
* osgi as soon as the org.rssowl.ui bundle gets activated.
*/
public void startup() {
/* Create Relations and Import Default Feeds if required */
if (!InternalOwl.TESTING) {
SafeRunner.run(new LoggingSafeRunnable() {
public void run() throws Exception {
/* First check wether this action is required */
IPreferenceScope preferences = Owl.getPreferenceService().getGlobalScope();
boolean isSubsequentStartup = preferences.hasKey(DefaultPreferences.FIRST_START_TOKEN);
if (isSubsequentStartup) {
/* Pre 2.1 the boolean was not stored, so add it if necessary */
if (!preferences.getBoolean(DefaultPreferences.FIRST_START_TOKEN))
preferences.putBoolean(DefaultPreferences.FIRST_START_TOKEN, true);
onSubsequentStartup();
return;
}
/* First Startup overall */
onFirstStartup();
/* Mark this as the first start */
preferences.putBoolean(DefaultPreferences.FIRST_START_TOKEN, true);
}
});
}
/* Set hidden News from previous Session to deleted */
SafeRunner.run(new LoggingSafeRunnable() {
public void run() throws Exception {
DynamicDAO.getDAO(INewsDAO.class).setState(EnumSet.of(INews.State.HIDDEN), INews.State.DELETED, false);
}
});
/* Create the Notification Service */
if (!InternalOwl.TESTING)
fNotificationService = new NotificationService();
/* Create the Saved Search Service */
fSavedSearchService = new SavedSearchService();
/* Create the Download Service */
fDownloadService = new DownloadService();
/* Create the Sync Service */
if (!InternalOwl.TESTING)
fSyncService = new SyncService();
/* Register Listeners */
registerListeners();
/* Load Contributed News Share Providers */
loadShareProviders();
/* Load Feed Search Provider */
fFeedSearchUrl = loadFeedSearchUrl();
/* Load Contributed Link Transformers */
loadLinkTransformers();
}
private void loadShareProviders() {
IExtensionRegistry reg = Platform.getExtensionRegistry();
IConfigurationElement elements[] = reg.getConfigurationElementsFor(SHARE_PROVIDER_EXTENSION_POINT);
/* For each contributed property keyword feed */
for (int i = 0; i < elements.length; i++) {
IConfigurationElement element = elements[i];
String id = element.getAttribute("id"); //$NON-NLS-1$
String name = element.getAttribute("name"); //$NON-NLS-1$
String iconPath = element.getAttribute("icon"); //$NON-NLS-1$
String url = element.getAttribute("url"); //$NON-NLS-1$
String maxTitleLength = element.getAttribute("maxTitleLength"); //$NON-NLS-1$
String enabled = element.getAttribute("enabled"); //$NON-NLS-1$
boolean isEnabled = (enabled != null && Boolean.parseBoolean(enabled));
fShareProviders.add(new ShareProvider(id, element.getNamespaceIdentifier(), i, name, iconPath, url, maxTitleLength, isEnabled));
}
}
private void loadLinkTransformers() {
IExtensionRegistry reg = Platform.getExtensionRegistry();
IConfigurationElement elements[] = reg.getConfigurationElementsFor(LINK_TRANSFORMER_EXTENSION_POINT);
/* For each contributed transformer */
for (int i = 0; i < elements.length; i++) {
IConfigurationElement element = elements[i];
String id = element.getAttribute("id"); //$NON-NLS-1$
String name = element.getAttribute("name"); //$NON-NLS-1$
String url = element.getAttribute("url"); //$NON-NLS-1$
fLinkTransformers.put(id, new LinkTransformer(id, name, url));
}
}
private String loadFeedSearchUrl() {
String feedSearch = null;
IExtensionRegistry reg = Platform.getExtensionRegistry();
IConfigurationElement elements[] = reg.getConfigurationElementsFor(FEED_SEARCH_EXTENSION_POINT);
for (IConfigurationElement element : elements) {
try {
feedSearch = element.getAttribute("searchUrl"); //$NON-NLS-1$
/* Let 3d-Party contributions override our contributions */
String nsId = element.getNamespaceIdentifier();
if (!nsId.contains(ExtensionUtils.RSSOWL_NAMESPACE))
return feedSearch;
} catch (InvalidRegistryObjectException e) {
Activator.getDefault().logError(e.getMessage(), e);
}
}
return feedSearch;
}
/**
* @return a sorted {@link List} of all contributed providers for sharing
* links.
*/
public List<ShareProvider> getShareProviders() {
IPreferenceScope preferences = Owl.getPreferenceService().getGlobalScope();
int[] providerState = preferences.getIntegers(DefaultPreferences.SHARE_PROVIDER_STATE);
/* Ignore State if Number of Providers got smaller */
if (providerState.length > fShareProviders.size())
return fShareProviders;
List<ShareProvider> sortedProviders = new ArrayList<ShareProvider>();
for (int i = 0; i < providerState.length; i++) {
int providerIndex = providerState[i];
boolean enabled = providerIndex > 0;
if (providerIndex < 0)
providerIndex = providerIndex * -1;
providerIndex--; //Adjust to zero-indexing
if (providerIndex < fShareProviders.size()) {
ShareProvider provider = fShareProviders.get(providerIndex);
provider.setEnabled(enabled);
sortedProviders.add(provider);
}
}
/* Add missing ones as disabled if any (can happen for new contributions) */
for (ShareProvider shareProvider : fShareProviders) {
if (!sortedProviders.contains(shareProvider)) {
shareProvider.setEnabled(false);
sortedProviders.add(shareProvider);
}
}
return sortedProviders;
}
/**
* @param selection the {@link IStructuredSelection} to share.
* @param provider the {@link ShareProvider} to use.
*/
public void share(IStructuredSelection selection, ShareProvider provider) {
/* Special Case "Send E-Mail" action */
if (SendLinkAction.ID.equals(provider.getId())) {
IActionDelegate action = new SendLinkAction();
action.selectionChanged(null, selection);
action.run(null);
}
/* Other Action */
else {
Object obj = selection.getFirstElement();
if (obj != null && obj instanceof INews) {
String shareLink = provider.toShareUrl((INews) obj);
new OpenInBrowserAction(new StructuredSelection(shareLink)).run();
}
}
}
/**
* @return a {@link List} of {@link LinkTransformer} sorted by name;
*/
public List<LinkTransformer> getLinkTransformers() {
List<LinkTransformer> transformers = new ArrayList<LinkTransformer>();
transformers.addAll(fLinkTransformers.values());
Collections.sort(transformers, new Comparator<LinkTransformer>() {
public int compare(LinkTransformer lt1, LinkTransformer lt2) {
return lt1.getName().compareTo(lt2.getName());
}
});
return transformers;
}
/**
* @param id the unique identifier of the {@link LinkTransformer}
* @return the {@link LinkTransformer} matching the given identifier or
* <code>null</code> if none.
*/
public LinkTransformer getLinkTransformer(String id) {
if (id == null)
return null;
return fLinkTransformers.get(id);
}
/**
* @param preferences the preferences to find the used link transformer from.
* @return the currently used {@link LinkTransformer} from the given
* preferences. Never <code>null</code>.
*/
public LinkTransformer getLinkTransformer(IPreferenceScope preferences) {
LinkTransformer transformer = null;
String transformerId = preferences.getString(DefaultPreferences.BM_TRANSFORMER_ID);
if (transformerId != null)
transformer = getLinkTransformer(transformerId);
if (transformer != null)
return transformer;
return getLinkTransformers().get(0);
}
/**
* @param link the link to transform to be shown in an embedded context.
* @return a link that will be transformed so that it can be showed in an
* embedded context.
*/
public String getEmbeddedTransformedUrl(String link) {
LinkTransformer transformer = getLinkTransformer(DEFAULT_TRANSFORMER_ID);
return transformer.toTransformedUrl(link) + DEFAULT_TRANSFORMER_EMBEDDED_PARAMETER;
}
/**
* Tells the Controller to stop. This method is called automatically from osgi
* as soon as the org.rssowl.ui bundle gets stopped.
*
* @param emergency If set to <code>TRUE</code>, this method is called from a
* shutdown hook that got triggered from a non-normal shutdown (e.g. System
* Shutdown).
*/
public void shutdown(boolean emergency) {
fShuttingDown = true;
/* Emergency Shutdown */
if (emergency || OOM_EMERGENCY_SHUTDOWN.get())
emergencyShutdown();
/* Normal Shutdown */
else
normalShutdown();
}
private void normalShutdown() {
fShuttingDown = true;
/* Unregister Listeners */
unregisterListeners();
/* Cancel any pending Update Jobs */
if (!Application.IS_ECLIPSE && !fDisableUpdate)
Job.getJobManager().cancel(UpdateJob.FAMILY);
/* Stop the Download Service */
if (fDownloadService != null)
fDownloadService.stopService();
/* Stop Clean-Up Reminder Service */
if (!InternalOwl.TESTING && fCleanUpReminderService != null)
fCleanUpReminderService.stopService();
/* Stop the Feed Reload Service */
if (!InternalOwl.TESTING && fFeedReloadService != null)
fFeedReloadService.stopService();
/* Cancel/Seal the reload queue */
if (fReloadFeedQueue != null)
fReloadFeedQueue.cancel(false, true);
/* Cancel the feed-save queue (join) */
if (fSaveFeedQueue != null)
fSaveFeedQueue.cancel(true, true);
/* Stop the Notification Service */
if (!InternalOwl.TESTING && fNotificationService != null)
fNotificationService.stopService();
/* Stop the Saved Search Service */
if (fSavedSearchService != null)
fSavedSearchService.stopService();
/* Stop the Sync Service */
if (fSyncService != null)
fSyncService.stopService(false);
/* Shutdown ApplicationServer */
ApplicationServer.getDefault().shutdown();
}
private void emergencyShutdown() {
fShuttingDown = true;
/* Cancel/Seal the reload queue */
if (fReloadFeedQueue != null)
fReloadFeedQueue.seal();
/* Cancel the feed-save queue (join) */
if (fSaveFeedQueue != null)
fSaveFeedQueue.cancel(true, true);
}
/**
* This method is called just after the Window has opened.
*/
public void postWindowOpen() {
/* Create the Feed-Reload Service */
if (!InternalOwl.TESTING)
fFeedReloadService = new FeedReloadService();
/* Create the Clean-Up Reminder Service */
fCleanUpReminderService = new CleanUpReminderService();
/* Support Keybindings for assigning Labels */
defineLabelCommands(CoreUtils.loadSortedLabels());
/* Support Keybindings for sharing News */
defineSharingCommands(getShareProviders());
/* Backup Subscriptions as OPML if no error */
JobRunner.runDelayedInBackgroundThread(new Runnable() {
public void run() {
SafeRunner.run(new LoggingSafeRunnable() {
public void run() throws Exception {
if (!fShuttingDown)
backupSubscriptions();
}
});
}
});
/* Show the Welcome & Tutorial Wizard if this is the first startup */
if (fShowWelcome) {
fShowWelcome = false; //Set to false to avoid another Wizard when opening new window
JobRunner.runInUIThread(200, OwlUI.getActiveShell(), new Runnable() {
public void run() {
showWelcomeAndTutorial();
}
});
}
/* Check for Updates if Set */
else if (!Application.IS_ECLIPSE && !fDisableUpdate) {
JobRunner.runInUIThread(5000, OwlUI.getActiveShell(), new Runnable() {
public void run() {
if (!fShuttingDown && Owl.getPreferenceService().getGlobalScope().getBoolean(DefaultPreferences.UPDATE_ON_STARTUP)) {
FindUpdatesAction action = new FindUpdatesAction(false);
action.init(OwlUI.getWindow());
action.run();
}
}
});
}
/* Inform the User if the ApplicationServer is not running */
ApplicationServer server = ApplicationServer.getDefault();
if (!server.isRunning()) {
Shell shell = OwlUI.getPrimaryShell();
if (shell != null)
MessageDialog.openError(shell, Messages.Controller_ERROR, NLS.bind(Messages.Controller_ERROR_STARTING_SERVER, server.getPort(), server.getHost()));
}
/* Update Saved Searches if not yet done (required if feeds view hidden on startup) */
JobRunner.runInBackgroundThread(50, new Runnable() {
public void run() {
if (!fShuttingDown)
fSavedSearchService.updateSavedSearches(false);
}
});
/* Indicate Application is started */
fIsStarted = true;
}
private void showWelcomeAndTutorial() {
Shell activeShell = OwlUI.getActiveShell();
/* Show Welcome */
WelcomeWizard welcomeWizard = new WelcomeWizard();
OwlUI.openWizard(activeShell, welcomeWizard, true, true, null);
/* Show Tutorial */
if (PlatformUI.isWorkbenchRunning() && !fShuttingDown) { //Do not show if User asked to Restart
TutorialWizard tutorialWizard = new TutorialWizard();
OwlUI.openWizard(activeShell, tutorialWizard, false, false, null);
}
}
private void backupSubscriptions() {
IPath rootPath = Platform.getLocation();
File root = rootPath.toFile();
if (!root.exists())
root.mkdir();
IPath dailyBackupPath = rootPath.append(DAILY_BACKUP);
IPath backupTmpPath = rootPath.append(BACKUP_TMP);
IPath weeklyBackupPath = rootPath.append(WEEKLY_BACKUP);
File dailyBackupFile = dailyBackupPath.toFile();
File backupTmpFile = backupTmpPath.toFile();
backupTmpFile.deleteOnExit();
File weeklyBackupFile = weeklyBackupPath.toFile();
if (dailyBackupFile.exists()) {
/* Update Weekly Backup if required */
if (!weeklyBackupFile.exists() || (weeklyBackupFile.lastModified() + DateUtils.WEEK < System.currentTimeMillis())) {
weeklyBackupFile.delete();
dailyBackupFile.renameTo(weeklyBackupFile);
}
/* Check 1 Day Condition */
long lastModified = dailyBackupFile.lastModified();
if (lastModified + DateUtils.DAY > System.currentTimeMillis())
return;
}
/* Create Daily Backup */
try {
Set<IFolder> rootFolders = CoreUtils.loadRootFolders();
if (!rootFolders.isEmpty() && !fShuttingDown) {
Owl.getInterpreter().exportTo(backupTmpFile, rootFolders, EnumSet.of(Options.EXPORT_FILTERS, Options.EXPORT_LABELS, Options.EXPORT_PREFERENCES));
/* Rename to actual backup in a short op to avoid corrupt data */
if (!backupTmpFile.renameTo(dailyBackupFile)) {
dailyBackupFile.delete();
backupTmpFile.renameTo(dailyBackupFile);
}
}
} catch (InterpreterException e) {
if (!fShuttingDown)
Activator.safeLogError(e.getMessage(), e);
}
}
/**
* Returns wether the application is in process of shutting down.
*
* @return <code>TRUE</code> if the application has been closed, and
* <code>FALSE</code> otherwise.
*/
public boolean isShuttingDown() {
return fShuttingDown;
}
/**
* Returns wether the application is in process of an emergency shut down.
*
* @return <code>TRUE</code> if the application is in the process of an
* emergency shut down, and <code>FALSE</code> otherwise.
*/
public boolean isEmergencyShutdown() {
return OOM_EMERGENCY_SHUTDOWN.get();
}
/**
* Returns wether the application is in process of restarting.
*
* @return <code>TRUE</code> if the application is restarting, and
* <code>FALSE</code> otherwise.
*/
public boolean isRestarting() {
return fRestarting;
}
/**
* Returns wether the application has finished starting.
*
* @return <code>TRUE</code> if the application is started, and
* <code>FALSE</code> otherwise if still initializing.
*/
public boolean isStarted() {
return fIsStarted;
}
/**
* @return <code>true</code> if RSSOwl is currently in offline modus and
* <code>false</code> otherwise.
*/
public boolean isOffline() {
return IS_OFFLINE.get();
}
/**
* @param offline <code>true</code> to set RSSOwl into offline mode and
* <code>false</code> otherwise.
*/
public void setOffline(boolean offline) {
IS_OFFLINE.set(offline);
}
/**
* This method is called immediately prior to workbench shutdown before any
* windows have been closed.
*
* @return <code>true</code> to allow the workbench to proceed with shutdown,
* <code>false</code> to veto a non-forced shutdown
*/
public boolean preUIShutdown() {
/* If a download is currently running, warn the user */
if (!isRestarting() && !isShuttingDown() && !isEmergencyShutdown() && fDownloadService != null && fDownloadService.isActive()) {
if (!openWarningConfirm(OwlUI.getActiveShell(), Messages.Controller_EXIT_RSSOWL, Messages.Controller_CANCEL_ACTIVE_DOWNLOADS)) {
return false; //Cancel Shutdown based on user choice
}
}
/* This flag is checked everywhere to signal a shutdown */
fShuttingDown = true;
/* Proceed normal shutdown */
return true;
}
private boolean openWarningConfirm(Shell parent, String title, String message) {
MessageDialog dialog = new MessageDialog(parent, title, null, message, MessageDialog.WARNING, new String[] { IDialogConstants.OK_LABEL, IDialogConstants.CANCEL_LABEL }, 0);
return dialog.open() == 0;
}
/* First startup overall */
private void onFirstStartup() {
/* Import File if specified */
boolean isDefaultStartup = true;
boolean addDefaultLabels = true;
String importFile = System.getProperty(IMPORT_PROPERTY);
if (StringUtils.isSet(importFile) && new File(importFile).exists()) {
try {
List<? extends IEntity> importedEntities = initialImportFile(importFile);
if (importedEntities != null) {
for (IEntity entity : importedEntities) {
if (entity instanceof ILabel) {
addDefaultLabels = false;
break;
}
}
}
isDefaultStartup = false;
} catch (Exception e) {
Activator.safeLogError(e.getMessage(), e);
}
}
/* Add Default Labels */
if (addDefaultLabels)
addDefaultLabels();
/* Create initial bookmark set and show welcome after UI is opened */
if (isDefaultStartup) {
fShowWelcome = true;
/* This setting has changed as of 2.1 but should not impact existing users */
IPreferenceScope globalPreferences = Owl.getPreferenceService().getGlobalScope();
globalPreferences.putBoolean(DefaultPreferences.ALWAYS_REUSE_FEEDVIEW, true);
/* Initial Bookmark Set */
DynamicDAO.save(Owl.getModelFactory().createFolder(null, null, Messages.Controller_MY_BOOKMARKS));
}
}
/* User has started RSSOwl before */
private void onSubsequentStartup() {
IPreferenceScope pref = Owl.getPreferenceService().getGlobalScope();
/* Return if new layout setting has already been stored */
if (pref.hasKey(DefaultPreferences.FV_LAYOUT))
return;
/* Migrate old layout options from pre 2.1 to 2.1 */
if (pref.hasKey(LEGACY_PREF_BROWSER_MAXIMIZED) || pref.hasKey(LEGACY_PREF_LAYOUT_CLASSIC)) {
boolean browserMaximized = pref.getBoolean(LEGACY_PREF_BROWSER_MAXIMIZED);
boolean layoutClassic = pref.getBoolean(LEGACY_PREF_LAYOUT_CLASSIC);
pref.delete(LEGACY_PREF_BROWSER_MAXIMIZED);
pref.delete(LEGACY_PREF_LAYOUT_CLASSIC);
/* Restore Newspaper Mode */
if (browserMaximized && !layoutClassic)
pref.putInteger(DefaultPreferences.FV_LAYOUT, Layout.NEWSPAPER.ordinal());
/* Restore Vertical Mode */
else if (!browserMaximized && !layoutClassic)
pref.putInteger(DefaultPreferences.FV_LAYOUT, Layout.VERTICAL.ordinal());
}
/* Migrate old image/media setting from pre 2.1 to 2.1 */
if (pref.hasKey(DefaultPreferences.BM_LOAD_IMAGES) && !pref.getBoolean(DefaultPreferences.BM_LOAD_IMAGES)) {
pref.putBoolean(DefaultPreferences.ENABLE_IMAGES, false);
pref.putBoolean(DefaultPreferences.ENABLE_MEDIA, false);
pref.delete(DefaultPreferences.BM_LOAD_IMAGES);
}
}
private void addDefaultLabels() throws PersistenceException {
ILabel label = fFactory.createLabel(null, Messages.Controller_IMPORTANT);
label.setColor("163,21,2"); //$NON-NLS-1$
label.setOrder(0);
fLabelDao.save(label);
label = fFactory.createLabel(null, Messages.Controller_WORK);
label.setColor("200,118,10"); //$NON-NLS-1$
label.setOrder(1);
fLabelDao.save(label);
label = fFactory.createLabel(null, Messages.Controller_PERSONAL);
label.setColor("82,92,58"); //$NON-NLS-1$
label.setOrder(2);
fLabelDao.save(label);
label = fFactory.createLabel(null, Messages.Controller_TODO);
label.setColor("92,101,126"); //$NON-NLS-1$
label.setOrder(3);
fLabelDao.save(label);
label = fFactory.createLabel(null, Messages.Controller_LATER);
label.setColor("82,16,0"); //$NON-NLS-1$
label.setOrder(4);
fLabelDao.save(label);
}
private List<? extends IEntity> initialImportFile(String file) throws PersistenceException, InterpreterException, ParserException, FileNotFoundException {
InputStream inS = new FileInputStream(file);
List<? extends IEntity> types = Owl.getInterpreter().importFrom(inS);
ImportUtils.doImport(null, types, false);
return types;
}
private IStatus createInfoStatus(IStatus status, IBookMark bookmark, URI feedLink) {
StringBuilder msg = createLogEntry(bookmark, feedLink, status.getMessage());
return new Status(IStatus.INFO, status.getPlugin(), status.getCode(), msg.toString(), null);
}
StringBuilder createLogEntry(IBookMark bookmark, URI feedLink, String msg) {
StringBuilder entry = new StringBuilder();
entry.append(NLS.bind(Messages.Controller_ERROR_LOADING, bookmark.getName()));
if (StringUtils.isSet(msg))
entry.append(fNl).append(NLS.bind(Messages.Controller_PROBLEM, msg));
if (feedLink != null)
entry.append(fNl).append(NLS.bind(Messages.Controller_LINK, feedLink));
else if (bookmark.getFeedLinkReference() != null)
entry.append(fNl).append(NLS.bind(Messages.Controller_LINK, bookmark.getFeedLinkReference().getLinkAsText()));
return entry;
}
/*
* Registeres a command per Label to assign key-bindings. Should be called
* when {@link ILabel} get added, updated or removed and must be called once
* after startup.
*/
private void defineLabelCommands(Collection<ILabel> labels) {
if (InternalOwl.TESTING)
return;
ICommandService commandService = (ICommandService) PlatformUI.getWorkbench().getService(ICommandService.class);
if (commandService == null)
return;
/* Define Command For Each Label */
for (final ILabel label : labels) {
Command command = commandService.getCommand(LABEL_ACTION_PREFIX + label.getOrder());
command.define(NLS.bind(Messages.Controller_LABEL, label.getName()), NLS.bind(Messages.Controller_LABEL_MSG, label.getName()), commandService.getCategory(RSSOWL_KEYBINDING_CATEGORY));
command.setHandler(new LabelNewsHandler(label));
}
}
private void defineSharingCommands(List<ShareProvider> shareProviders) {
if (InternalOwl.TESTING)
return;
ICommandService commandService = (ICommandService) PlatformUI.getWorkbench().getService(ICommandService.class);
if (commandService == null)
return;
/* Define Command For Each Share Provider */
for (final ShareProvider provider : shareProviders) {
Command command = commandService.getCommand(provider.getId());
command.define(NLS.bind(Messages.Controller_SHARE, provider.getName()), NLS.bind(Messages.Controller_SHARE_MSG, provider.getName()), commandService.getCategory(RSSOWL_KEYBINDING_CATEGORY));
command.setHandler(new ShareNewsHandler(provider));
}
}
private void updateLabelCommands() {
Set<ILabel> labels = CoreUtils.loadSortedLabels();
undefineLabelCommands(labels);
defineLabelCommands(labels);
}
/* TODO Also need to remove any keybinding associated with Label if existing */
private void undefineLabelCommands(Collection<ILabel> labels) {
if (InternalOwl.TESTING)
return;
ICommandService commandService = (ICommandService) PlatformUI.getWorkbench().getService(ICommandService.class);
if (commandService == null)
return;
for (ILabel label : labels) {
commandService.getCommand(LABEL_ACTION_PREFIX + label.getOrder()).undefine();
}
}
/**
* @param listener the listener thats gets informed when a bookmark is loaded
* from the controller.
*/
public void addBookMarkLoadListener(BookMarkLoadListener listener) {
fBookMarkLoadListeners.add(listener);
}
/**
* @param listener the listener thats gets informed when a bookmark is done
* loading from the controller.
*/
public void removeBookMarkLoadListener(BookMarkLoadListener listener) {
fBookMarkLoadListeners.remove(listener);
}
/**
* @return the {@link Lock} used to ensure that at any time only a single
* login dialog is showing.
*/
public Lock getLoginDialogLock() {
return fLoginDialogLock;
}
/**
* @param keywords the keywords to use as search for feeds.
* @return a {@link String} that can be used as link for search.
*/
public String toFeedSearchLink(String keywords) {
String encodedKeywords = URIUtils.urlEncode(keywords.trim());
return StringUtils.replaceAll(fFeedSearchUrl, FEED_SEARCH_KEYWORD_TOKEN, encodedKeywords);
}
private void fireBookMarkAboutToLoad(final IBookMark bookmark) {
Object[] listeners = fBookMarkLoadListeners.getListeners();
for (final Object listener : listeners) {
SafeRunner.run(new LoggingSafeRunnable() {
public void run() throws Exception {
((BookMarkLoadListener) listener).bookMarkAboutToLoad(bookmark);
}
});
}
}
private void fireBookMarkDoneLoading(final IBookMark bookmark) {
Object[] listeners = fBookMarkLoadListeners.getListeners();
for (final Object listener : listeners) {
SafeRunner.run(new LoggingSafeRunnable() {
public void run() throws Exception {
((BookMarkLoadListener) listener).bookMarkDoneLoading(bookmark);
}
});
}
}
/**
* Cancels all pending Updates to Feeds.
*/
public void stopUpdate() {
fReloadFeedQueue.cancel(false, false);
}
/**
* @return <code>true</code> if this application runs in portable mode and
* <code>false</code> otherwise.
*/
public boolean isPortable() {
return fPortable;
}
/**
* @return <code>true</code> if updates should be disabled and
* <code>false</code> otherwise.
*/
public boolean isUpdateDisabled() {
return fDisableUpdate;
}
/**
* Restart the Application.
*/
public void restart() {
/* First Check for active Downloads */
if (fDownloadService.isActive()) {
MessageDialog.openWarning(OwlUI.getActiveShell(), Messages.Controller_RESTART_RSSOWL, Messages.Controller_ACTIVE_DOWNLOADS_WARNING);
return;
}
fRestarting = true;
/* Run the restart() */
PlatformUI.getWorkbench().restart();
}
/**
* Start a Workbench emergency shutdown due to an unrecoverable Out of Memory
* error.
*
* @param error the {@link OutOfMemoryError} that causes an emergent shutdown.
*/
public void emergencyOutOfMemoryShutdown(final OutOfMemoryError error) {
/* Flag shutdown sequence about to start to reduce Job load */
fShuttingDown = true;
/* Return early if OOM Exception already handled from a different thread */
if (OOM_EMERGENCY_SHUTDOWN.getAndSet(true))
return;
/* Shutdown needs to run from UI Thread */
JobRunner.runInUIThread(null, new Runnable() {
public void run() {
try {
/* Initialize Emergent Shutdown */
ApplicationWorkbenchAdvisor.fgPrimaryApplicationWorkbenchWindowAdvisor.getWindowConfigurer().getWorkbenchConfigurer().emergencyClose();
/* Inform the User */
IStatus errorStatus = new Status(IStatus.ERROR, "org.rssowl.ui", IStatus.ERROR, error.getMessage(), error); //$NON-NLS-1$
FatalOutOfMemoryErrorDialog dialog = new FatalOutOfMemoryErrorDialog(errorStatus);
if (dialog.open() == IDialogConstants.HELP_ID)
Program.launch("http://www.rssowl.org/help#item_6g"); //$NON-NLS-1$;
}
/* Serious problem - Exit (gives Shutdown Hook a chance to run) */
catch (Error err) {
System.exit(0);
}
}
});
}
}