PerspectiveTracker.java

/*
 * Copyright 2010 The Rabbit Eclipse Plug-in Project
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package rabbit.tracking.internal.trackers;

import rabbit.data.handler.DataHandler;
import rabbit.data.store.IStorer;
import rabbit.data.store.model.PerspectiveEvent;
import rabbit.tracking.internal.IdleDetector;
import rabbit.tracking.internal.TrackingPlugin;
import rabbit.tracking.internal.util.Recorder;
import rabbit.tracking.internal.util.WorkbenchUtil;

import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveListener;
import org.eclipse.ui.IWindowListener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PerspectiveAdapter;
import org.eclipse.ui.PlatformUI;
import org.joda.time.Interval;

import java.util.Observable;
import java.util.Observer;

import javax.annotation.Nullable;

/**
 * Tracker for tracking on perspective usage.
 */
public class PerspectiveTracker extends AbstractTracker<PerspectiveEvent> {

  /**
   * A recorder for recording the time.
   */
  private final Recorder<IPerspectiveDescriptor> recorder = new Recorder<IPerspectiveDescriptor>();

  /**
   * An observer observing on the {@link #recorder} and user activeness.
   */
  private final Observer observer = new Observer() {

    @Override
    public void update(Observable o, Object arg) {
      if (!isEnabled()) {
        return;
      }

      if (o == TrackingPlugin.getDefault().getIdleDetector()) {
        if (((IdleDetector) o).isUserActive()) {
          checkStart();
        } else {
          recorder.stop();
        }

      } else if (o == recorder) {
        long start = recorder.getLastRecord().getStartTimeMillis();
        long end = recorder.getLastRecord().getEndTimeMillis();
        IPerspectiveDescriptor p = recorder.getLastRecord().getUserData();
        addData(new PerspectiveEvent(new Interval(start, end), p));
      }
    }
  };

  /**
   * A perspective listener for tracking time spent on perspectives.
   */
  private final IPerspectiveListener persplistener = new PerspectiveAdapter() {

    @Override
    public void perspectiveActivated(IWorkbenchPage page,
        IPerspectiveDescriptor perspective) {
      recorder.start(perspective);
    }

    @Override
    public void perspectiveDeactivated(IWorkbenchPage page,
        IPerspectiveDescriptor perspective) {
      recorder.stop();
    }
  };

  private final IWindowListener winlistener = new IWindowListener() {

    @Override
    public void windowActivated(IWorkbenchWindow win) {
      recorder.start(WorkbenchUtil.getPerspective(win));
    }

    @Override
    public void windowClosed(IWorkbenchWindow win) {
      win.removePerspectiveListener(persplistener);
      recorder.stop();
    }

    @Override
    public void windowDeactivated(IWorkbenchWindow win) {
      recorder.stop();
    }

    @Override
    public void windowOpened(IWorkbenchWindow win) {
      win.addPerspectiveListener(persplistener);
      if (WorkbenchUtil.isActiveShell(win)) {
        checkStart(win);
      }
    }
  };

  /**
   * Constructor.
   */
  public PerspectiveTracker() {
    recorder.addObserver(observer);
  }

  @Override
  protected IStorer<PerspectiveEvent> createDataStorer() {
    return DataHandler.getStorer(PerspectiveEvent.class);
  }

  @Override
  protected void doDisable() {
    recorder.stop();
    for (IWorkbenchWindow win : getWorkbenchWindows()) {
      win.removePerspectiveListener(persplistener);
    }
    TrackingPlugin.getDefault().getIdleDetector().deleteObserver(observer);
    PlatformUI.getWorkbench().removeWindowListener(winlistener);
  }

  @Override
  protected void doEnable() {
    checkStart();
    for (IWorkbenchWindow win : getWorkbenchWindows()) {
      win.addPerspectiveListener(persplistener);
    }
    TrackingPlugin.getDefault().getIdleDetector().addObserver(observer);
    PlatformUI.getWorkbench().addWindowListener(winlistener);
  }

  /**
   * Checks the conditions and starts recording if OK.
   */
  private void checkStart() {
    IWorkbenchWindow win = WorkbenchUtil.getActiveWindow();
    if (WorkbenchUtil.isActiveShell(win)) {
      checkStart(win);
    }
  }

  /**
   * Checks the conditions and starts recording if OK.
   * 
   * @param activeWin The current active window.
   */
  private void checkStart(@Nullable IWorkbenchWindow activeWin) {
    IPerspectiveDescriptor p = WorkbenchUtil.getPerspective(activeWin);
    if (p != null) {
      recorder.start(p);
    }
  }

  /**
   * @return All workbench windows.
   */
  private IWorkbenchWindow[] getWorkbenchWindows() {
    return PlatformUI.getWorkbench().getWorkbenchWindows();
  }

}