palemoon27/mobile/android/base/background/healthreport/HealthReportBroadcastService.java

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

package org.mozilla.goanna.background.healthreport;

import org.mozilla.goanna.background.BackgroundService;
import org.mozilla.goanna.background.common.GlobalConstants;
import org.mozilla.goanna.background.common.log.Logger;
import org.mozilla.goanna.background.healthreport.prune.HealthReportPruneService;
import org.mozilla.goanna.background.healthreport.upload.HealthReportUploadService;
import org.mozilla.goanna.background.healthreport.upload.ObsoleteDocumentTracker;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

/**
 * A service which listens to broadcast intents from the system and from the
 * browser, registering or unregistering the background health report services with the
 * {@link AlarmManager}.
 */
public class HealthReportBroadcastService extends BackgroundService {
  public static final String LOG_TAG = HealthReportBroadcastService.class.getSimpleName();
  public static final String WORKER_THREAD_NAME = LOG_TAG + "Worker";

  public HealthReportBroadcastService() {
    super(WORKER_THREAD_NAME);
  }

  protected SharedPreferences getSharedPreferences() {
    return this.getSharedPreferences(HealthReportConstants.PREFS_BRANCH, GlobalConstants.SHARED_PREFERENCES_MODE);
  }

  public long getSubmissionPollInterval() {
    return getSharedPreferences().getLong(HealthReportConstants.PREF_SUBMISSION_INTENT_INTERVAL_MSEC, HealthReportConstants.DEFAULT_SUBMISSION_INTENT_INTERVAL_MSEC);
  }

  public void setSubmissionPollInterval(final long interval) {
    getSharedPreferences().edit().putLong(HealthReportConstants.PREF_SUBMISSION_INTENT_INTERVAL_MSEC, interval).commit();
  }

  public long getPrunePollInterval() {
    return getSharedPreferences().getLong(HealthReportConstants.PREF_PRUNE_INTENT_INTERVAL_MSEC,
        HealthReportConstants.DEFAULT_PRUNE_INTENT_INTERVAL_MSEC);
  }

  public void setPrunePollInterval(final long interval) {
    getSharedPreferences().edit().putLong(HealthReportConstants.PREF_PRUNE_INTENT_INTERVAL_MSEC,
        interval).commit();
  }

  /**
   * Set or cancel an alarm to submit data for a profile.
   *
   * @param context
   *          Android context.
   * @param profileName
   *          to submit data for.
   * @param profilePath
   *          to submit data for.
   * @param enabled
   *          whether the user has enabled submitting health report data for
   *          this profile.
   * @param serviceEnabled
   *          whether submitting should be scheduled. If the user turns off
   *          submitting, <code>enabled</code> could be false but we could need
   *          to delete so <code>serviceEnabled</code> could be true.
   */
  protected void toggleSubmissionAlarm(final Context context, String profileName, String profilePath,
      boolean enabled, boolean serviceEnabled) {
    final Class<?> serviceClass = HealthReportUploadService.class;
    Logger.info(LOG_TAG, (serviceEnabled ? "R" : "Unr") + "egistering " +
        serviceClass.getSimpleName() + ".");

    // PendingIntents are compared without reference to their extras. Therefore
    // even though we pass the profile details to the action, different
    // profiles will share the *same* pending intent. In a multi-profile future,
    // this will need to be addressed.  See Bug 882182.
    final Intent service = new Intent(context, serviceClass);
    service.setAction("upload"); // PendingIntents "lose" their extras if no action is set.
    service.putExtra("uploadEnabled", enabled);
    service.putExtra("profileName", profileName);
    service.putExtra("profilePath", profilePath);
    final PendingIntent pending = PendingIntent.getService(context, 0, service, PendingIntent.FLAG_CANCEL_CURRENT);

    if (!serviceEnabled) {
      cancelAlarm(pending);
      return;
    }

    final long pollInterval = getSubmissionPollInterval();
    scheduleAlarm(pollInterval, pending);
  }

  @Override
  protected void onHandleIntent(Intent intent) {
    Logger.setThreadLogTag(HealthReportConstants.GLOBAL_LOG_TAG);

    // Intent can be null. Bug 1025937.
    if (intent == null) {
      Logger.debug(LOG_TAG, "Short-circuiting on null intent.");
      return;
    }

    // The same intent can be handled by multiple methods so do not short-circuit evaluate.
    boolean handled = attemptHandleIntentForUpload(intent);
    handled = attemptHandleIntentForPrune(intent) || handled;

    if (!handled) {
      Logger.warn(LOG_TAG, "Unhandled intent with action " + intent.getAction() + ".");
    }
  }

  /**
   * Attempts to handle the given intent for FHR document upload. If it cannot, false is returned.
   *
   * @param intent must be non-null.
   */
  private boolean attemptHandleIntentForUpload(final Intent intent) {
    if (HealthReportConstants.UPLOAD_FEATURE_DISABLED) {
      Logger.debug(LOG_TAG, "Health report upload feature is compile-time disabled; not handling intent.");
      return false;
    }

    final String action = intent.getAction();
    Logger.debug(LOG_TAG, "Health report upload feature is compile-time enabled; attempting to " +
        "handle intent with action " + action + ".");

    if (HealthReportConstants.ACTION_HEALTHREPORT_UPLOAD_PREF.equals(action)) {
      handleUploadPrefIntent(intent);
      return true;
    }

    if (Intent.ACTION_BOOT_COMPLETED.equals(action) ||
        Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) {
      BackgroundService.reflectContextToFennec(this,
          GlobalConstants.GECKO_PREFERENCES_CLASS,
          GlobalConstants.GECKO_BROADCAST_HEALTHREPORT_UPLOAD_PREF_METHOD);
      return true;
    }

    return false;
  }

  /**
   * Handle the intent sent by the browser when it wishes to notify us
   * of the value of the user preference. Look at the value and toggle the
   * alarm service accordingly.
   *
   * @param intent must be non-null.
   */
  private void handleUploadPrefIntent(Intent intent) {
    if (!intent.hasExtra("enabled")) {
      Logger.warn(LOG_TAG, "Got " + HealthReportConstants.ACTION_HEALTHREPORT_UPLOAD_PREF + " intent without enabled. Ignoring.");
      return;
    }

    final boolean enabled = intent.getBooleanExtra("enabled", true);
    Logger.debug(LOG_TAG, intent.getStringExtra("branch") + "/" +
                          intent.getStringExtra("pref")   + " = " +
                          (intent.hasExtra("enabled") ? enabled : ""));

    String profileName = intent.getStringExtra("profileName");
    String profilePath = intent.getStringExtra("profilePath");

    if (profileName == null || profilePath == null) {
      Logger.warn(LOG_TAG, "Got " + HealthReportConstants.ACTION_HEALTHREPORT_UPLOAD_PREF + " intent without profilePath or profileName. Ignoring.");
      return;
    }

    Logger.pii(LOG_TAG, "Updating health report upload alarm for profile " + profileName + " at " +
        profilePath + ".");

    final SharedPreferences sharedPrefs = getSharedPreferences();
    final ObsoleteDocumentTracker tracker = new ObsoleteDocumentTracker(sharedPrefs);
    final boolean hasObsoleteIds = tracker.hasObsoleteIds();

    if (!enabled) {
      final Editor editor = sharedPrefs.edit();
      editor.remove(HealthReportConstants.PREF_LAST_UPLOAD_DOCUMENT_ID);

      if (hasObsoleteIds) {
        Logger.debug(LOG_TAG, "Health report upload disabled; scheduling deletion of " + tracker.numberOfObsoleteIds() + " documents.");
        tracker.limitObsoleteIds();
      } else {
        // Primarily intended for debugging and testing.
        Logger.debug(LOG_TAG, "Health report upload disabled and no deletes to schedule: clearing prefs.");
        editor.remove(HealthReportConstants.PREF_FIRST_RUN);
        editor.remove(HealthReportConstants.PREF_NEXT_SUBMISSION);
      }

      editor.commit();
    }

    // The user can toggle us off or on, or we can have obsolete documents to
    // remove.
    final boolean serviceEnabled = hasObsoleteIds || enabled;
    toggleSubmissionAlarm(this, profileName, profilePath, enabled, serviceEnabled);
  }

  /**
   * Attempts to handle the given intent for FHR data pruning. If it cannot, false is returned.
   *
   * @param intent must be non-null.
   */
  private boolean attemptHandleIntentForPrune(final Intent intent) {
    final String action = intent.getAction();
    Logger.debug(LOG_TAG, "Prune: Attempting to handle intent with action, " + action + ".");

    if (HealthReportConstants.ACTION_HEALTHREPORT_PRUNE.equals(action)) {
      handlePruneIntent(intent);
      return true;
    }

    if (Intent.ACTION_BOOT_COMPLETED.equals(action) ||
        Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) {
      BackgroundService.reflectContextToFennec(this,
          GlobalConstants.GECKO_PREFERENCES_CLASS,
          GlobalConstants.GECKO_BROADCAST_HEALTHREPORT_PRUNE_METHOD);
      return true;
    }

    return false;
  }

  /**
   * @param intent must be non-null.
   */
  private void handlePruneIntent(final Intent intent) {
    final String profileName = intent.getStringExtra("profileName");
    final String profilePath = intent.getStringExtra("profilePath");

    if (profileName == null || profilePath == null) {
      Logger.warn(LOG_TAG, "Got " + HealthReportConstants.ACTION_HEALTHREPORT_PRUNE + " intent " +
          "without profilePath or profileName. Ignoring.");
      return;
    }

    final Class<?> serviceClass = HealthReportPruneService.class;
    final Intent service = new Intent(this, serviceClass);
    service.setAction("prune"); // Intents without actions have their extras removed.
    service.putExtra("profileName", profileName);
    service.putExtra("profilePath", profilePath);
    final PendingIntent pending = PendingIntent.getService(this, 0, service,
        PendingIntent.FLAG_CANCEL_CURRENT);

    // Set a regular alarm to start PruneService. Since the various actions that PruneService can
    // take occur on irregular intervals, we can be more efficient by only starting the Service
    // when one of these time limits runs out.  However, subsequent Service invocations must then
    // be registered by the PruneService itself, which would fail if the PruneService crashes.
    // Thus, we set this regular (and slightly inefficient) alarm.
    Logger.info(LOG_TAG, "Registering " + serviceClass.getSimpleName() + ".");
    final long pollInterval = getPrunePollInterval();
    scheduleAlarm(pollInterval, pending);
  }
}