PersistenceService.java

/*
 *  Jajuk
 *  Copyright (C) The Jajuk Team
 *  http://jajuk.info
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *  
 */
package org.jajuk.services.core;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.codec.digest.DigestUtils;
import org.jajuk.base.Collection;
import org.jajuk.base.DeviceManager;
import org.jajuk.services.bookmark.History;
import org.jajuk.services.players.QueueModel;
import org.jajuk.services.players.StackItem;
import org.jajuk.services.webradio.CustomRadiosPersistenceHelper;
import org.jajuk.services.webradio.PresetRadiosPersistenceHelper;
import org.jajuk.ui.perspectives.IPerspective;
import org.jajuk.util.log.Log;

/**
 * This thread is responsible for commiting configuration or collection files on events. 
 * This allows to save files during Jajuk running and not only when exiting the app as before. 
 * <p>
 * It is sometimes difficult to get clear events to check to so we also start a differential check 
 * on a regular basis through a thread
 * </p>
 * <p>
 * Singleton
 * <p>
 */
public final class PersistenceService extends Thread {
  public enum Urgency {
    HIGH, MEDIUM, LOW
  }

  private static PersistenceService self = new PersistenceService();
  private String lastCommitQueueCheckSum;
  private static final int HEART_BEAT_MS = 1000;
  private static final int MIN_DELAY_AFTER_PERSPECTIVE_CHANGE_MS = 5000;
  private static final int DELAY_HIGH_URGENCY_BEATS = 5;
  private static final int DELAY_MEDIUM_URGENCY_BEATS = 15;
  private static final int DELAY_LOW_URGENCY_BEATS = 600 * HEART_BEAT_MS;
  /** Collection change flag **/
  private volatile Map<Urgency, Boolean> collectionChanged = new HashMap<Urgency, Boolean>(3);
  private volatile boolean radiosChanged = false;
  private volatile boolean historyChanged = false;
  private volatile Map<IPerspective, Long> dateMinNextPerspectiveCommit = new HashMap<IPerspective, Long>(
      10);

  /**
   * Inform the persister service that the perspective should be commited
   * @param perspective the perspective that changed
   */
  public void setPerspectiveChanged(IPerspective perspective) {
    synchronized (dateMinNextPerspectiveCommit) {
      dateMinNextPerspectiveCommit.put(perspective,
          (System.currentTimeMillis() + MIN_DELAY_AFTER_PERSPECTIVE_CHANGE_MS));
    }
  }

  /**
   * Inform the persister service that the history should be commited
   */
  public void setHistoryChanged() {
    historyChanged = true;
  }

  /**
   * Inform the persister service that the collection should be commited with the given urgency
   * @param urgency the urgency for the collection to be commited
   */
  public void setCollectionChanged(Urgency urgency) {
    collectionChanged.put(urgency, true);
  }

  /**
   * Inform the persister service that the radios should be commited
   */
  public void setRadiosChanged() {
    radiosChanged = true;
  }

  /**
   * Instantiates a new rating manager.
   */
  private PersistenceService() {
    // set thread name
    super("Persistence Manager Thread");
  }

  /*
   * (non-Javadoc)
   * 
   * @see java.lang.Thread#run()
   */
  @Override
  public void run() {
    init();
    int comp = 1;
    while (!ExitService.isExiting()) {
      try {
        Thread.sleep(HEART_BEAT_MS);
        if (comp % DELAY_HIGH_URGENCY_BEATS == 0) {
          performHighUrgencyActions();
        }
        if (comp % DELAY_MEDIUM_URGENCY_BEATS == 0) {
          performMediumUrgencyActions();
        }
        if (comp % DELAY_LOW_URGENCY_BEATS == 0) {
          performLowUrgencyActions();
        }
        comp++;
      } catch (Exception e) {
        Log.error(e);
      }
    }
  }

  private void init() {
    this.lastCommitQueueCheckSum = getQueueModelChecksum();
    collectionChanged.put(Urgency.LOW, false);
    collectionChanged.put(Urgency.MEDIUM, false);
    collectionChanged.put(Urgency.HIGH, false);
    setPriority(Thread.MAX_PRIORITY);
  }

  private void performHighUrgencyActions() throws Exception {
    commitWebradiosIfRequired();
    if (collectionChanged.get(Urgency.HIGH) && !DeviceManager.getInstance().isAnyDeviceRefreshing()) {
      try {
        Collection.commit();
      } finally {
        collectionChanged.put(Urgency.HIGH, false);
      }
    }
  }

  private void performMediumUrgencyActions() throws Exception {
    // Queue
    commitQueueModelIfRequired();
    // Collection
    if (collectionChanged.get(Urgency.MEDIUM)
        && !DeviceManager.getInstance().isAnyDeviceRefreshing()) {
      try {
        Collection.commit();
      } finally {
        collectionChanged.put(Urgency.MEDIUM, false);
      }
    }
    // Perspectives
    handcommitPerspectivesIfRequired();
  }

  private void handcommitPerspectivesIfRequired() throws Exception {
    List<IPerspective> datesCopy = new ArrayList<IPerspective>(
        dateMinNextPerspectiveCommit.keySet());
    for (IPerspective perspective : datesCopy) {
      if (System.currentTimeMillis() - dateMinNextPerspectiveCommit.get(perspective) >= 0) {
        try {
          perspective.commit();
        } finally {
          synchronized (dateMinNextPerspectiveCommit) {
            dateMinNextPerspectiveCommit.remove(perspective);
          }
        }
      }
    }
  }

  private void performLowUrgencyActions() throws Exception {
    //History
    commitHistoryIfRequired();
    // Collection
    if (collectionChanged.get(Urgency.LOW) && !DeviceManager.getInstance().isAnyDeviceRefreshing()) {
      try {
        Collection.commit();
      } finally {
        collectionChanged.put(Urgency.LOW, false);
      }
    }
  }

  private void commitWebradiosIfRequired() throws IOException {
    try {
      if (radiosChanged) {
        // Commit webradios
        CustomRadiosPersistenceHelper.commit();
        PresetRadiosPersistenceHelper.commit();
      }
    } finally {
      radiosChanged = false;
    }
  }

  private void commitQueueModelIfRequired() throws IOException {
    String checksum = getQueueModelChecksum();
    if (!checksum.equals(this.lastCommitQueueCheckSum)) {
      try {
        QueueModel.commit();
      } finally {
        this.lastCommitQueueCheckSum = checksum;
      }
    }
  }

  private void commitHistoryIfRequired() throws IOException {
    if (historyChanged) {
      try {
        History.commit();
      } finally {
        historyChanged = false;
      }
    }
  }

  private String getQueueModelChecksum() {
    StringBuilder sb = new StringBuilder();
    for (StackItem item : QueueModel.getQueue()) {
      sb.append(item.getFile().getID());
    }
    // Do not use MD5Processor class here to avoid the intern() method that 
    // could create a permgen memory leak
    byte[] checksum = DigestUtils.md5(sb.toString());
    return new String(checksum);
  }

  public static PersistenceService getInstance() {
    return self;
  }
}