private void initialize(final IRefreshSubscriberListener listener) {
    final GotoActionWrapper actionWrapper = new GotoActionWrapper();

    IProgressMonitor group = Job.getJobManager().createProgressGroup();
    group.beginTask(taskName, 100);
    setProgressGroup(group, 80);
    handleProgressGroupSet(group, 20);
    setProperty(IProgressConstants.ICON_PROPERTY, participant.getImageDescriptor());
    setProperty(IProgressConstants.ACTION_PROPERTY, actionWrapper);
    setProperty(IProgressConstants.KEEPONE_PROPERTY, Boolean.valueOf(!isJobModal()));
    // Listener delegate
    IRefreshSubscriberListener autoListener =
        new IRefreshSubscriberListener() {
          @Override
          public void refreshStarted(IRefreshEvent event) {
            if (listener != null) {
              listener.refreshStarted(event);
            }
          }

          @Override
          public ActionFactory.IWorkbenchAction refreshDone(IRefreshEvent event) {
            if (listener != null) {
              boolean isModal = isJobModal();
              event.setIsLink(!isModal);
              final ActionFactory.IWorkbenchAction runnable = listener.refreshDone(event);
              if (runnable != null) {
                // If the job is being run modally then simply prompt the user immediately
                if (isModal) {
                  if (runnable != null) {
                    Job update = new UIJob("") { // $NON-NLS-1$
                          @Override
                          public IStatus runInUIThread(IProgressMonitor monitor) {
                            runnable.run();
                            return Status.OK_STATUS;
                          }
                        };
                    update.setSystem(true);
                    update.schedule();
                  }
                } else {
                  // If the job is being run in the background, don't interrupt the user and simply
                  // update the goto action
                  // to perform the results.
                  actionWrapper.setGotoAction(runnable);
                }
              }
              RefreshParticipantJob.removeRefreshListener(this);
            }
            return null;
          }
        };

    if (listener != null) {
      RefreshParticipantJob.addRefreshListener(autoListener);
    }
  }
 private boolean isJobInFamilyRunning(Object family) {
   Job[] jobs = Job.getJobManager().find(family);
   if (jobs != null && jobs.length > 0) {
     for (int i = 0; i < jobs.length; i++) {
       Job job = jobs[i];
       if (job.getState() != Job.NONE) {
         return true;
       }
     }
   }
   return false;
 }
/**
 * Job to refresh a {@link Subscriber} in the background. The job can be configured to be
 * re-scheduled and run at a specified interval.
 *
 * <p>The job supports a basic work flow for modal/non-modal usage. If the job is run in the
 * foreground (e.g. in a modal progress dialog) the refresh listeners action is invoked immediately
 * after the refresh is completed. Otherwise the refresh listeners action is associated to the job
 * as a <i>goto</i> action. This will allow the user to select the action in the progress view and
 * run it when they choose.
 *
 * @since 3.0
 */
public abstract class RefreshParticipantJob extends Job {

  /** Uniquely identifies this type of job. This is used for cancellation. */
  private static final Object FAMILY_ID = new Object();

  /** If true this job will be restarted when it completes */
  private boolean reschedule = false;

  /** If true a rescheduled refresh job should be restarted when canceled */
  private boolean restartOnCancel = true;

  /** The schedule delay used when rescheduling a completed job */
  private static long scheduleDelay;

  /** The participant that is being refreshed. */
  private ISynchronizeParticipant participant;

  /** The task name for this refresh. This is usually more descriptive than the job name. */
  private String taskName;

  /** Refresh started/completed listener for every refresh */
  private static List listeners = new ArrayList(1);

  private static final int STARTED = 1;
  private static final int DONE = 2;

  /*
   * Lock used to sequence refresh jobs
   */
  private static final ILock lock = Job.getJobManager().newLock();

  /*
   * Constant used for postponement
   */
  private static final IStatus POSTPONED =
      new Status(
          IStatus.CANCEL,
          TeamUIPlugin.ID,
          0,
          "Scheduled refresh postponed due to conflicting operation",
          null); //$NON-NLS-1$

  /*
   * Action wrapper which allows the goto action
   * to be set later. It also handles errors
   * that have occurred during the refresh
   */
  private final class GotoActionWrapper extends WorkbenchAction {
    private ActionFactory.IWorkbenchAction gotoAction;
    private IStatus status;

    @Override
    public void run() {
      if (status != null && !status.isOK()) {
        ErrorDialog.openError(
            Utils.getShell(null), null, TeamUIMessages.RefreshSubscriberJob_3, status);
      } else if (gotoAction != null) {
        gotoAction.run();
      }
    }

    @Override
    public boolean isEnabled() {
      if (gotoAction != null) {
        return gotoAction.isEnabled();
      }
      return true;
    }

    @Override
    public String getText() {
      if (gotoAction != null) {
        return gotoAction.getText();
      }
      return null;
    }

    @Override
    public String getToolTipText() {
      if (status != null && !status.isOK()) {
        return status.getMessage();
      }
      if (gotoAction != null) {
        return gotoAction.getToolTipText();
      }
      return Utils.shortenText(
          SynchronizeView.MAX_NAME_LENGTH, RefreshParticipantJob.this.getName());
    }

    @Override
    public void dispose() {
      super.dispose();
      if (gotoAction != null) {
        gotoAction.dispose();
      }
    }

    public void setGotoAction(ActionFactory.IWorkbenchAction gotoAction) {
      this.gotoAction = gotoAction;
      setEnabled(isEnabled());
      setToolTipText(getToolTipText());
      gotoAction.addPropertyChangeListener(
          new IPropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent event) {
              if (event.getProperty().equals(IAction.ENABLED)) {
                Boolean bool = (Boolean) event.getNewValue();
                GotoActionWrapper.this.setEnabled(bool.booleanValue());
              }
            }
          });
    }

    public void setStatus(IStatus status) {
      this.status = status;
    }
  }

  /** Notification for safely notifying listeners of refresh lifecycle. */
  private abstract class Notification implements ISafeRunnable {
    private IRefreshSubscriberListener listener;

    @Override
    public void handleException(Throwable exception) {
      // don't log the exception....it is already being logged in Platform#run
    }

    public void run(IRefreshSubscriberListener listener) {
      this.listener = listener;
      SafeRunner.run(this);
    }

    @Override
    public void run() throws Exception {
      notify(listener);
    }
    /**
     * Subclasses override this method to send an event safely to a listener
     *
     * @param listener
     */
    protected abstract void notify(IRefreshSubscriberListener listener);
  }

  /** Monitor wrapper that will indicate that the job is canceled if the job is blocking another. */
  private class NonblockingProgressMonitor extends ProgressMonitorWrapper {
    private final RefreshParticipantJob job;
    private long blockTime;
    private static final int THRESHOLD = 250;
    private boolean wasBlocking = false;

    protected NonblockingProgressMonitor(IProgressMonitor monitor, RefreshParticipantJob job) {
      super(monitor);
      this.job = job;
    }

    @Override
    public boolean isCanceled() {
      if (super.isCanceled()) {
        return true;
      }
      if (job.shouldReschedule() && job.isBlocking()) {
        if (blockTime == 0) {
          blockTime = System.currentTimeMillis();
        } else if (System.currentTimeMillis() - blockTime > THRESHOLD) {
          // We've been blocking for too long
          wasBlocking = true;
          return true;
        }
      } else {
        blockTime = 0;
      }
      wasBlocking = false;
      return false;
    }

    public boolean wasBlocking() {
      return wasBlocking;
    }
  }

  public static interface IChangeDescription {
    int getChangeCount();
  }

  /**
   * Create a job to refresh the specified resources with the subscriber.
   *
   * @param participant the subscriber participant
   * @param jobName
   * @param taskName
   * @param listener
   */
  public RefreshParticipantJob(
      ISynchronizeParticipant participant,
      String jobName,
      String taskName,
      IRefreshSubscriberListener listener) {
    super(jobName);
    Assert.isNotNull(participant);
    this.participant = participant;
    this.taskName = taskName;
    setPriority(Job.DECORATE);
    setRefreshInterval(3600 /* 1 hour */);

    // Handle restarting of job if it is configured as a scheduled refresh job.
    addJobChangeListener(
        new JobChangeAdapter() {
          @Override
          public void done(IJobChangeEvent event) {
            if (shouldReschedule()) {
              IStatus result = event.getResult();
              if (result.getSeverity() == IStatus.CANCEL && !restartOnCancel) {
                return;
              }
              long delay = scheduleDelay;
              if (result == POSTPONED) {
                // Restart in 5 seconds
                delay = 5000;
              }
              RefreshParticipantJob.this.schedule(delay);
              restartOnCancel = true;
            }
          }
        });
    if (listener != null) initialize(listener);
  }

  @Override
  public boolean belongsTo(Object family) {
    if (family instanceof SubscriberParticipant) {
      return family == participant;
    } else {
      return (family == getFamily() || family == ISynchronizeManager.FAMILY_SYNCHRONIZE_OPERATION);
    }
  }

  public static Object getFamily() {
    return FAMILY_ID;
  }

  /**
   * This is run by the job scheduler. A list of subscribers will be refreshed, errors will not stop
   * the job and it will continue to refresh the other subscribers.
   */
  @Override
  public IStatus run(IProgressMonitor monitor) {
    // Perform a pre-check for auto-build or manual build jobs
    // when auto-refreshing
    if (shouldReschedule()
        && (isJobInFamilyRunning(ResourcesPlugin.FAMILY_AUTO_BUILD)
            || isJobInFamilyRunning(ResourcesPlugin.FAMILY_MANUAL_BUILD))) {
      return POSTPONED;
    }
    // Only allow one refresh job at a time
    // NOTE: It would be cleaner if this was done by a scheduling
    // rule but at the time of writing, it is not possible due to
    // the scheduling rule containment rules.
    // Acquiring lock to ensure only one refresh job is running at a particular time
    boolean acquired = false;
    try {
      while (!acquired) {
        try {
          acquired = lock.acquire(1000);
        } catch (InterruptedException e1) {
          acquired = false;
        }
        Policy.checkCanceled(monitor);
      }

      IChangeDescription changeDescription = createChangeDescription();
      RefreshEvent event =
          new RefreshEvent(
              reschedule ? IRefreshEvent.SCHEDULED_REFRESH : IRefreshEvent.USER_REFRESH,
              participant,
              changeDescription);
      IStatus status = null;
      NonblockingProgressMonitor wrappedMonitor = null;
      try {
        event.setStartTime(System.currentTimeMillis());
        if (monitor.isCanceled()) {
          return Status.CANCEL_STATUS;
        }
        // Pre-Notify
        notifyListeners(STARTED, event);
        // Perform the refresh
        monitor.setTaskName(getName());
        wrappedMonitor = new NonblockingProgressMonitor(monitor, this);
        doRefresh(changeDescription, wrappedMonitor);
        // Prepare the results
        setProperty(IProgressConstants.KEEPONE_PROPERTY, Boolean.valueOf(!isJobModal()));
      } catch (OperationCanceledException e2) {
        if (monitor.isCanceled()) {
          // The refresh was canceled by the user
          status = Status.CANCEL_STATUS;
        } else {
          // The refresh was canceled due to a blockage or a canceled authentication
          if (wrappedMonitor != null && wrappedMonitor.wasBlocking()) {
            status = POSTPONED;
          } else {
            status = Status.CANCEL_STATUS;
          }
        }
      } catch (CoreException e) {
        // Determine the status to be returned and the GOTO action
        status = e.getStatus();
        if (!isUser()) {
          // Use the GOTO action to show the error and return OK
          Object prop = getProperty(IProgressConstants.ACTION_PROPERTY);
          if (prop instanceof GotoActionWrapper) {
            GotoActionWrapper wrapper = (GotoActionWrapper) prop;
            wrapper.setStatus(e.getStatus());
            status =
                new Status(IStatus.OK, TeamUIPlugin.ID, IStatus.OK, e.getStatus().getMessage(), e);
          }
        }
        if (!isUser() && status.getSeverity() == IStatus.ERROR) {
          // Never prompt for errors on non-user jobs
          setProperty(IProgressConstants.NO_IMMEDIATE_ERROR_PROMPT_PROPERTY, Boolean.TRUE);
        }
      } finally {
        event.setStopTime(System.currentTimeMillis());
      }

      // Post-Notify
      if (status == null) {
        status = calculateStatus(event);
      }
      event.setStatus(status);
      notifyListeners(DONE, event);
      if (event.getChangeDescription().getChangeCount() > 0) {
        if (participant instanceof AbstractSynchronizeParticipant) {
          AbstractSynchronizeParticipant asp = (AbstractSynchronizeParticipant) participant;
          asp.firePropertyChange(
              participant, ISynchronizeParticipant.P_CONTENT, null, event.getChangeDescription());
        }
      }
      return event.getStatus();
    } finally {
      if (acquired) lock.release();
      monitor.done();
    }
  }

  protected abstract void doRefresh(IChangeDescription changeListener, IProgressMonitor monitor)
      throws CoreException;

  /**
   * Return the total number of changes covered by the resources of this job.
   *
   * @return the total number of changes covered by the resources of this job
   */
  protected abstract int getChangeCount();

  protected abstract int getIncomingChangeCount();

  protected abstract int getOutgoingChangeCount();

  private boolean isJobInFamilyRunning(Object family) {
    Job[] jobs = Job.getJobManager().find(family);
    if (jobs != null && jobs.length > 0) {
      for (int i = 0; i < jobs.length; i++) {
        Job job = jobs[i];
        if (job.getState() != Job.NONE) {
          return true;
        }
      }
    }
    return false;
  }

  private IStatus calculateStatus(IRefreshEvent event) {
    StringBuffer text = new StringBuffer();
    int code = IStatus.OK;
    int changeCount = event.getChangeDescription().getChangeCount();
    int numChanges = getChangeCount();
    if (numChanges > 0) {
      code = IRefreshEvent.STATUS_CHANGES;

      int incomingChanges = getIncomingChangeCount();
      String numIncomingChanges =
          incomingChanges == 0
              ? "" //$NON-NLS-1$
              : NLS.bind(
                  TeamUIMessages.RefreshCompleteDialog_incomingChanges,
                  Integer.toString(incomingChanges));

      int outgoingChanges = getOutgoingChangeCount();
      String numOutgoingChanges =
          outgoingChanges == 0
              ? "" //$NON-NLS-1$
              : NLS.bind(
                  TeamUIMessages.RefreshCompleteDialog_outgoingChanges,
                  Integer.toString(outgoingChanges));

      String sep =
          incomingChanges > 0 && outgoingChanges > 0 ? "; " : ""; // $NON-NLS-1$ //$NON-NLS-2$

      if (changeCount > 0) {
        // New changes found
        code = IRefreshEvent.STATUS_NEW_CHANGES;
        String numNewChanges = Integer.toString(changeCount);
        if (changeCount == 1) {
          text.append(
              NLS.bind(
                  TeamUIMessages.RefreshCompleteDialog_newChangesSingular,
                  (new Object[] {
                    getName(), numNewChanges, numIncomingChanges, sep, numOutgoingChanges
                  })));
        } else {
          text.append(
              NLS.bind(
                  TeamUIMessages.RefreshCompleteDialog_newChangesPlural,
                  (new Object[] {
                    getName(), numNewChanges, numIncomingChanges, sep, numOutgoingChanges
                  })));
        }
      } else {
        // Refreshed resources contain changes
        if (numChanges == 1) {
          text.append(
              NLS.bind(
                  TeamUIMessages.RefreshCompleteDialog_changesSingular,
                  (new Object[] {
                    getName(), new Integer(numChanges), numIncomingChanges, sep, numOutgoingChanges
                  })));
        } else {
          text.append(
              NLS.bind(
                  TeamUIMessages.RefreshCompleteDialog_changesPlural,
                  (new Object[] {
                    getName(), new Integer(numChanges), numIncomingChanges, sep, numOutgoingChanges
                  })));
        }
      }
    } else {
      // No changes found
      code = IRefreshEvent.STATUS_NO_CHANGES;
      text.append(NLS.bind(TeamUIMessages.RefreshCompleteDialog_6, new String[] {getName()}));
    }
    return new Status(IStatus.OK, TeamUIPlugin.ID, code, text.toString(), null);
  }

  private void initialize(final IRefreshSubscriberListener listener) {
    final GotoActionWrapper actionWrapper = new GotoActionWrapper();

    IProgressMonitor group = Job.getJobManager().createProgressGroup();
    group.beginTask(taskName, 100);
    setProgressGroup(group, 80);
    handleProgressGroupSet(group, 20);
    setProperty(IProgressConstants.ICON_PROPERTY, participant.getImageDescriptor());
    setProperty(IProgressConstants.ACTION_PROPERTY, actionWrapper);
    setProperty(IProgressConstants.KEEPONE_PROPERTY, Boolean.valueOf(!isJobModal()));
    // Listener delegate
    IRefreshSubscriberListener autoListener =
        new IRefreshSubscriberListener() {
          @Override
          public void refreshStarted(IRefreshEvent event) {
            if (listener != null) {
              listener.refreshStarted(event);
            }
          }

          @Override
          public ActionFactory.IWorkbenchAction refreshDone(IRefreshEvent event) {
            if (listener != null) {
              boolean isModal = isJobModal();
              event.setIsLink(!isModal);
              final ActionFactory.IWorkbenchAction runnable = listener.refreshDone(event);
              if (runnable != null) {
                // If the job is being run modally then simply prompt the user immediately
                if (isModal) {
                  if (runnable != null) {
                    Job update = new UIJob("") { // $NON-NLS-1$
                          @Override
                          public IStatus runInUIThread(IProgressMonitor monitor) {
                            runnable.run();
                            return Status.OK_STATUS;
                          }
                        };
                    update.setSystem(true);
                    update.schedule();
                  }
                } else {
                  // If the job is being run in the background, don't interrupt the user and simply
                  // update the goto action
                  // to perform the results.
                  actionWrapper.setGotoAction(runnable);
                }
              }
              RefreshParticipantJob.removeRefreshListener(this);
            }
            return null;
          }
        };

    if (listener != null) {
      RefreshParticipantJob.addRefreshListener(autoListener);
    }
  }

  /**
   * The progress group of this job has been set. Any subclasses should assign this group to any
   * additional jobs they use to collect changes from the refresh.
   *
   * @param group a progress group
   * @param ticks the ticks for the change collection job
   */
  protected abstract void handleProgressGroupSet(IProgressMonitor group, int ticks);

  protected abstract IChangeDescription createChangeDescription();

  public long getScheduleDelay() {
    return scheduleDelay;
  }

  protected void start() {
    if (getState() == Job.NONE) {
      if (shouldReschedule()) {
        schedule(getScheduleDelay());
      }
    }
  }

  /**
   * Specify the interval in seconds at which this job is scheduled.
   *
   * @param seconds delay specified in seconds
   */
  public void setRefreshInterval(long seconds) {
    boolean restart = false;
    if (getState() == Job.SLEEPING) {
      restart = true;
      cancel();
    }
    scheduleDelay = seconds * 1000;
    if (restart) {
      start();
    }
  }

  public void setRestartOnCancel(boolean restartOnCancel) {
    this.restartOnCancel = restartOnCancel;
  }

  public void setReschedule(boolean reschedule) {
    this.reschedule = reschedule;
  }

  public boolean shouldReschedule() {
    return reschedule;
  }

  public static void addRefreshListener(IRefreshSubscriberListener listener) {
    synchronized (listeners) {
      if (!listeners.contains(listener)) {
        listeners.add(listener);
      }
    }
  }

  public static void removeRefreshListener(IRefreshSubscriberListener listener) {
    synchronized (listeners) {
      listeners.remove(listener);
    }
  }

  protected void notifyListeners(final int state, final IRefreshEvent event) {
    // Get a snapshot of the listeners so the list doesn't change while we're firing
    IRefreshSubscriberListener[] listenerArray;
    synchronized (listeners) {
      listenerArray =
          (IRefreshSubscriberListener[])
              listeners.toArray(new IRefreshSubscriberListener[listeners.size()]);
    }
    // Notify each listener in a safe manner (i.e. so their exceptions don't kill us)
    for (int i = 0; i < listenerArray.length; i++) {
      IRefreshSubscriberListener listener = listenerArray[i];
      Notification notification =
          new Notification() {
            @Override
            protected void notify(IRefreshSubscriberListener listener) {
              switch (state) {
                case STARTED:
                  listener.refreshStarted(event);
                  break;
                case DONE:
                  listener.refreshDone(event);
                  break;
                default:
                  break;
              }
            }
          };
      notification.run(listener);
    }
  }

  private boolean isJobModal() {
    Boolean isModal = (Boolean) getProperty(IProgressConstants.PROPERTY_IN_DIALOG);
    if (isModal == null) return false;
    return isModal.booleanValue();
  }

  public ISynchronizeParticipant getParticipant() {
    return participant;
  }
}