Java 类com.google.android.gms.gcm.OneoffTask 实例源码

/**
 * For the given Triggering conditions, start a new GCM Network Manager request allowed
 * to run after {@code delayStartSecs} seconds.
 */
private static void schedule(Context context, TriggerConditions triggerConditions,
        long delayStartSecs, boolean overwrite) {
    // Get the GCM Network Scheduler.
    GcmNetworkManager gcmNetworkManager = GcmNetworkManager.getInstance(context);

    Bundle taskExtras = new Bundle();
    TaskExtrasPacker.packTimeInBundle(taskExtras);
    TaskExtrasPacker.packTriggerConditionsInBundle(taskExtras, triggerConditions);

    Task task = new OneoffTask.Builder()
                        .setService(ChromeBackgroundService.class)
                        .setExecutionWindow(delayStartSecs, ONE_WEEK_IN_SECONDS)
                        .setTag(OfflinePageUtils.TASK_TAG)
                        .setUpdateCurrent(overwrite)
                        .setRequiredNetwork(triggerConditions.requireUnmeteredNetwork()
                                        ? Task.NETWORK_STATE_UNMETERED
                                        : Task.NETWORK_STATE_CONNECTED)
                        .setRequiresCharging(triggerConditions.requirePowerConnected())
                        .setExtras(taskExtras)
                        .build();

    gcmNetworkManager.schedule(task);
}

/**
 * Schedules a future task to start download resumption.
 * @param allowMeteredConnection Whether download resumption can start if connection is metered.
 */
public void schedule(boolean allowMeteredConnection) {
    GcmNetworkManager gcmNetworkManager = GcmNetworkManager.getInstance(mContext);
    int networkType = allowMeteredConnection
            ? Task.NETWORK_STATE_CONNECTED : Task.NETWORK_STATE_UNMETERED;
    OneoffTask task = new OneoffTask.Builder()
            .setService(ChromeBackgroundService.class)
            .setExecutionWindow(0, ONE_DAY_IN_SECONDS)
            .setTag(TASK_TAG)
            .setUpdateCurrent(true)
            .setRequiredNetwork(networkType)
            .setRequiresCharging(false)
            .build();
    try {
        gcmNetworkManager.schedule(task);
    } catch (IllegalArgumentException e) {
        Log.e(TAG, "unable to schedule resumption task.", e);
    }
}

/**
 * Schedules a one-off task to finish precaching the resources that were
 * still outstanding when the last task was interrupted. Interrupting such
 * a one-off task will result in scheduling a new one.
 * @param context The application context.
 */
private static void schedulePrecacheCompletionTask(Context context) {
    Log.v(TAG, "scheduling a precache completion task");
    OneoffTask task = new OneoffTask.Builder()
                              .setExecutionWindow(COMPLETION_TASK_MIN_DELAY_SECONDS,
                                      COMPLETION_TASK_MAX_DELAY_SECONDS)
                              .setPersisted(true)
                              .setRequiredNetwork(OneoffTask.NETWORK_STATE_UNMETERED)
                              .setRequiresCharging(ChromeVersionInfo.isStableBuild())
                              .setService(ChromeBackgroundService.class)
                              .setTag(CONTINUATION_TASK_TAG)
                              .setUpdateCurrent(true)
                              .build();
    if (sTaskScheduler.scheduleTask(context, task)) {
        PrecacheUMA.record(PrecacheUMA.Event.ONEOFF_TASK_SCHEDULE);
    } else {
        PrecacheUMA.record(PrecacheUMA.Event.ONEOFF_TASK_SCHEDULE_FAIL);
    }
}

private static boolean scheduleLaunchTask(
        Context context, GcmNetworkManager scheduler, long minDelayMs) {
    // Google Play Services may not be up to date, if the application was not installed through
    // the Play Store. In this case, scheduling the task will fail silently.
    final long minDelaySecs = minDelayMs / 1000;
    OneoffTask oneoff = new OneoffTask.Builder()
                                .setService(ChromeBackgroundService.class)
                                .setTag(TASK_TAG)
                                // We have to set a non-zero execution window here
                                .setExecutionWindow(minDelaySecs, minDelaySecs + 1)
                                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
                                .setPersisted(true)
                                .setUpdateCurrent(true)
                                .build();
    try {
        scheduler.schedule(oneoff);
    } catch (IllegalArgumentException e) {
        // Disable GCM for the remainder of this session.
        setGCMEnabled(false);
        // Return false so that the failure will be logged.
        return false;
    }
    return true;
}

@Override
public void onClick(View v) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(AccountSettingsActivity.this);
    sharedPreferences.edit().putString("firstName", firstName.getText().toString()).apply();
    sharedPreferences.edit().putString("lastName", lastName.getText().toString()).apply();
    sharedPreferences.edit().putString("age",age.getText().toString()).apply();

    GcmNetworkManager gcmNM = GcmNetworkManager.getInstance(AccountSettingsActivity.this);
    Log.i(TAG, "Registering the BackupTask");
    OneoffTask task = new OneoffTask.Builder()
            .setService(MyBackupService.class)
            .setTag(TASK_BACKUP)
            .setExecutionWindow(0L, ONE_HOUR)
            .setRequiredNetwork(Task.NETWORK_STATE_UNMETERED)
            .setRequiresCharging(true)
            .setUpdateCurrent(true)
            .build();

    gcmNM.schedule(task);
}

public void startWifiTask() {
    Log.d(TAG, "startWiFiTask");

    // Disable WiFi so the task does not start immediately
    WifiManager wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);
    wifi.setWifiEnabled(false);

    // [START start_one_off_task]
    OneoffTask task = new OneoffTask.Builder()
            .setService(MyTaskService.class)
            .setTag(TASK_TAG_WIFI)
            .setExecutionWindow(0L, 3600L)
            .setRequiredNetwork(Task.NETWORK_STATE_UNMETERED)
            .build();

    mGcmNetworkManager.schedule(task);
    // [END start_one_off_task]
}

/**
 * For the given Triggering conditions, start a new GCM Network Manager request allowed
 * to run after {@code delayStartSecs} seconds.
 */
private static void schedule(Context context, TriggerConditions triggerConditions,
        long delayStartSecs, boolean overwrite) {
    // Get the GCM Network Scheduler.
    GcmNetworkManager gcmNetworkManager = GcmNetworkManager.getInstance(context);

    Bundle taskExtras = new Bundle();
    TaskExtrasPacker.packTimeInBundle(taskExtras);
    TaskExtrasPacker.packTriggerConditionsInBundle(taskExtras, triggerConditions);

    Task task = new OneoffTask.Builder()
                        .setService(ChromeBackgroundService.class)
                        .setExecutionWindow(delayStartSecs, ONE_WEEK_IN_SECONDS)
                        .setTag(OfflinePageUtils.TASK_TAG)
                        .setUpdateCurrent(overwrite)
                        .setRequiredNetwork(triggerConditions.requireUnmeteredNetwork()
                                        ? Task.NETWORK_STATE_UNMETERED
                                        : Task.NETWORK_STATE_CONNECTED)
                        .setRequiresCharging(triggerConditions.requirePowerConnected())
                        .setExtras(taskExtras)
                        .build();

    gcmNetworkManager.schedule(task);
}

/**
 * Schedules a future task to start download resumption.
 * @param allowMeteredConnection Whether download resumption can start if connection is metered.
 */
public void schedule(boolean allowMeteredConnection) {
    GcmNetworkManager gcmNetworkManager = GcmNetworkManager.getInstance(mContext);
    int networkType = allowMeteredConnection
            ? Task.NETWORK_STATE_CONNECTED : Task.NETWORK_STATE_UNMETERED;
    OneoffTask task = new OneoffTask.Builder()
            .setService(ChromeBackgroundService.class)
            .setExecutionWindow(0, ONE_DAY_IN_SECONDS)
            .setTag(TASK_TAG)
            .setUpdateCurrent(true)
            .setRequiredNetwork(networkType)
            .setRequiresCharging(false)
            .build();
    try {
        gcmNetworkManager.schedule(task);
    } catch (IllegalArgumentException e) {
        Log.e(TAG, "unable to schedule resumption task.", e);
    }
}

/**
 * Schedules a one-off task to finish precaching the resources that were
 * still outstanding when the last task was interrupted. Interrupting such
 * a one-off task will result in scheduling a new one.
 * @param context The application context.
 */
private static void schedulePrecacheCompletionTask(Context context) {
    Log.v(TAG, "scheduling a precache completion task");
    OneoffTask task = new OneoffTask.Builder()
                              .setExecutionWindow(COMPLETION_TASK_MIN_DELAY_SECONDS,
                                      COMPLETION_TASK_MAX_DELAY_SECONDS)
                              .setPersisted(true)
                              .setRequiredNetwork(OneoffTask.NETWORK_STATE_UNMETERED)
                              .setRequiresCharging(ChromeVersionInfo.isStableBuild())
                              .setService(ChromeBackgroundService.class)
                              .setTag(CONTINUATION_TASK_TAG)
                              .setUpdateCurrent(true)
                              .build();
    if (sTaskScheduler.scheduleTask(context, task)) {
        PrecacheUMA.record(PrecacheUMA.Event.ONEOFF_TASK_SCHEDULE);
    } else {
        PrecacheUMA.record(PrecacheUMA.Event.ONEOFF_TASK_SCHEDULE_FAIL);
    }
}

private static boolean scheduleLaunchTask(
        Context context, GcmNetworkManager scheduler, long minDelayMs) {
    // Google Play Services may not be up to date, if the application was not installed through
    // the Play Store. In this case, scheduling the task will fail silently.
    final long minDelaySecs = minDelayMs / 1000;
    OneoffTask oneoff = new OneoffTask.Builder()
                                .setService(ChromeBackgroundService.class)
                                .setTag(TASK_TAG)
                                // We have to set a non-zero execution window here
                                .setExecutionWindow(minDelaySecs, minDelaySecs + 1)
                                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
                                .setPersisted(true)
                                .setUpdateCurrent(true)
                                .build();
    try {
        scheduler.schedule(oneoff);
    } catch (IllegalArgumentException e) {
        // Disable GCM for the remainder of this session.
        setGCMEnabled(false);
        // Return false so that the failure will be logged.
        return false;
    }
    return true;
}

/**
 * Schedule all sensor LOGS upload one time task
 *
 * @param context
 */
private void scheduleSensorLogsUploadTask(Context context) {

    Log.d(TAG, "Scheduling logs upload one time task...");

    OneoffTask oneTimeTask = new Builder()
            .setService(LogsUploadService.class)
            .setExecutionWindow(UPLOAD_ALL_TASKS_START_SECS,
                    UPLOAD_ALL_TASKS_END_SECS)
            .setTag("onetimetag | 2")
            .setPersisted(true)
            .setUpdateCurrent(true)
            .setRequiredNetwork(Task.NETWORK_STATE_ANY)
            .setRequiresCharging(false)
            .build();

    GcmNetworkManager.getInstance(context).schedule(oneTimeTask);

    Log.d(TAG, "Logs upload task was scheduled!");
}

/**
 * Schedules an periodic upload task
 */
public static void scheduleOneTimeTask(Context context, long startSecs, long endSecs, String tag) {

    Log.d(TAG, "Scheduling one time task...");

    Bundle bundle = new Bundle();
    bundle.putInt(UPLOAD_ALL_FLAG_NAME, UPLOAD_ALL_FLAG_VALUE);

    OneoffTask oneTimeTask = new Builder()
            .setService(SensorUploadService.class)
            .setExecutionWindow(startSecs, endSecs)
            .setTag(tag)
            .setPersisted(true)
            .setUpdateCurrent(true)
            .setRequiredNetwork(Task.NETWORK_STATE_ANY)
            .setRequiresCharging(false)
            .setExtras(bundle)
            .build();

    GcmNetworkManager.getInstance(context).schedule(oneTimeTask);

    Log.d(TAG, "One time task was scheduled!");
}

private void addOneOff(long winStartSecs, long winEndSecs, int connectivity, boolean charging) {
    if (winStartSecs > winEndSecs) {
        Toast.makeText(getActivity(),
                getString(R.string.scheduler_error_window),
                Toast.LENGTH_SHORT).show();
        return;
    }
    String tag = Long.toString(SystemClock.currentThreadTimeMillis());
    final long elapsedNowSeconds = SystemClock.elapsedRealtime() / 1000;
    final TaskTracker taskTracker = TaskTracker.createOneoff(tag,
            elapsedNowSeconds + winStartSecs, elapsedNowSeconds + winEndSecs);
    OneoffTask oneOff = new OneoffTask.Builder()
            .setService(TaskSchedulerService.class)
            .setTag(tag)
            .setExecutionWindow(winStartSecs, winEndSecs)
            .setRequiredNetwork(connectivity)
                    // Persistence not yet support for Oneoffs.
            .setRequiresCharging(charging)
            .build();
    mScheduler.schedule(oneOff);
    mTasks.updateTask(taskTracker);
}

@Override public void scheduleAction(ScheduledAction action) {

    AndroidBasicAction androidBasicAction = androidBasicActionMapper.modelToExternalClass(
        action.getBasicAction());

    Bundle bundle = new Bundle();
    bundle.putString(BUNDLE_TASK_PARAM_NAME, gson.toJson(androidBasicAction));

    OneoffTask task = new OneoffTask.Builder()
        .setService(OrchextraGcmTaskService.class)
        .setTag(action.getId())
        .setExecutionWindow(action.getScheduleTime()/ONE_SECOND, (action.getScheduleTime()/ONE_SECOND)+DEFAULT_DELAY_MAX)
        .setPersisted(true)
        .setRequiresCharging(false)
        .setRequiredNetwork(Task.NETWORK_STATE_ANY)
        .setExtras(bundle)
        .build();

    logShowTime(action);

    orchextraLogger.log("Scheduled action "+ action.getId());

    gcmNetworkManager.schedule(task);
  }

/**
 * Schedules a future task to start download resumption.
 * @param allowMeteredConnection Whether download resumption can start if connection is metered.
 */
public void schedule(boolean allowMeteredConnection) {
    GcmNetworkManager gcmNetworkManager = GcmNetworkManager.getInstance(mContext);
    int networkType = allowMeteredConnection
            ? Task.NETWORK_STATE_CONNECTED : Task.NETWORK_STATE_UNMETERED;
    OneoffTask task = new OneoffTask.Builder()
                              .setService(ChromeBackgroundService.class)
                              .setExecutionWindow(0, ONE_DAY_IN_SECONDS)
                              .setTag(TASK_TAG)
                              .setUpdateCurrent(true)
                              .setRequiredNetwork(networkType)
                              .setRequiresCharging(false)
                              .build();
    try {
        gcmNetworkManager.schedule(task);
    } catch (IllegalArgumentException e) {
        Log.e(TAG, "unable to schedule resumption task.", e);
    }
}

/**
 * Schedules a one-off task to finish precaching the resources that were
 * still outstanding when the last task was interrupted. Interrupting such
 * a one-off task will result in scheduling a new one.
 * @param context The application context.
 */
private static void schedulePrecacheCompletionTask(Context context) {
    Log.v(TAG, "scheduling a precache completion task");
    OneoffTask task = new OneoffTask.Builder()
                              .setExecutionWindow(COMPLETION_TASK_MIN_DELAY_SECONDS,
                                      COMPLETION_TASK_MAX_DELAY_SECONDS)
                              .setPersisted(true)
                              .setRequiredNetwork(OneoffTask.NETWORK_STATE_UNMETERED)
                              .setRequiresCharging(ChromeVersionInfo.isStableBuild())
                              .setService(ChromeBackgroundService.class)
                              .setTag(CONTINUATION_TASK_TAG)
                              .setUpdateCurrent(true)
                              .build();
    if (sTaskScheduler.scheduleTask(context, task)) {
        PrecacheUMA.record(PrecacheUMA.Event.ONEOFF_TASK_SCHEDULE);
    } else {
        PrecacheUMA.record(PrecacheUMA.Event.ONEOFF_TASK_SCHEDULE_FAIL);
    }
}

private static boolean scheduleLaunchTask(GcmNetworkManager scheduler, long minDelayMs) {
    // Google Play Services may not be up to date, if the application was not installed through
    // the Play Store. In this case, scheduling the task will fail silently.
    final long minDelaySecs = minDelayMs / 1000;
    OneoffTask oneoff = new OneoffTask.Builder()
                                .setService(ChromeBackgroundService.class)
                                .setTag(TASK_TAG)
                                // We have to set a non-zero execution window here
                                .setExecutionWindow(minDelaySecs, minDelaySecs + 1)
                                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
                                .setPersisted(true)
                                .setUpdateCurrent(true)
                                .build();
    try {
        scheduler.schedule(oneoff);
    } catch (IllegalArgumentException e) {
        // Disable GCM for the remainder of this session.
        setGCMEnabled(false);
        // Return false so that the failure will be logged.
        return false;
    }
    return true;
}

public static void scheduleOneOff(Context context, String what) {
        Bundle extras = new Bundle();
        extras.putString(EXTRA_KEY, what);
        OneoffTask task = new OneoffTask.Builder()
                .setService(NetworkGCMTaskService.class)
                .setTag(TASK_NETWORK_TAG)
                .setExtras(extras)
//                Execution window: The time period in which the task will execute.
//                First param is the lower bound and the second is the upper bound (both are in seconds).
                .setExecutionWindow(0L, 30L)
                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
                .setUpdateCurrent(true)
                .build();

        GcmNetworkManager.getInstance(context).schedule(task);
    }

private void shutdownAndScheduleStartup(int when) {

        Log.i(TAG, "overnight shutdown, seconds to startup: " + when);
        com.google.android.gms.gcm.Task task = new OneoffTask.Builder()
                .setService(TrackerTaskService.class)
                .setExecutionWindow(when, when + 60)
                .setUpdateCurrent(true)
                .setTag(TrackerTaskService.TAG)
                .setRequiredNetwork(com.google.android.gms.gcm.Task.NETWORK_STATE_ANY)
                .setRequiresCharging(false)
                .build();
        GcmNetworkManager.getInstance(this).schedule(task);
        stopSelf();
    }

public void startChargingTask() {
    Log.d(TAG, "startChargingTask");

    OneoffTask task = new OneoffTask.Builder()
            .setService(MyTaskService.class)
            .setTag(TASK_TAG_CHARGING)
            .setExecutionWindow(0L, 3600L)
            .setRequiresCharging(true)
            .build();

    mGcmNetworkManager.schedule(task);
}

private Task createOnoffTask() {
    return new OneoffTask.Builder()
            .setService(MyGcmTaskService.class)
            .setTag(MyGcmTaskService.MY_TASK)
            .setExecutionWindow(0, 1000L)
            .build();
}

@Override
protected void scheduleImpl(TriggerConditions triggerConditions, long delayStartSeconds,
        long executionDeadlineSeconds, boolean overwrite) {
    GcmNetworkManager gcmNetworkManager = getGcmNetworkManager();
    if (gcmNetworkManager == null) return;

    Bundle taskExtras = new Bundle();
    TaskExtrasPacker.packTimeInBundle(taskExtras);
    TaskExtrasPacker.packHoldWakelock(taskExtras);
    TaskExtrasPacker.packTriggerConditionsInBundle(taskExtras, triggerConditions);

    Task task = new OneoffTask.Builder()
                        .setService(ChromeBackgroundService.class)
                        .setExecutionWindow(delayStartSeconds, executionDeadlineSeconds)
                        .setTag(OfflinePageUtils.TASK_TAG)
                        .setUpdateCurrent(overwrite)
                        .setRequiredNetwork(triggerConditions.requireUnmeteredNetwork()
                                        ? Task.NETWORK_STATE_UNMETERED
                                        : Task.NETWORK_STATE_CONNECTED)
                        .setRequiresCharging(triggerConditions.requirePowerConnected())
                        .setPersisted(true)
                        .setExtras(taskExtras)
                        .build();

    // Schedule a task using GCM network manager.
    gcmNetworkManager.schedule(task);
}

private static Task.Builder getOneOffTaskBuilder(TaskInfo.OneOffInfo oneOffInfo) {
    OneoffTask.Builder builder = new OneoffTask.Builder();
    long windowStartSeconds = oneOffInfo.hasWindowStartTimeConstraint()
            ? TimeUnit.MILLISECONDS.toSeconds(oneOffInfo.getWindowStartTimeMs())
            : 0;
    builder.setExecutionWindow(windowStartSeconds,
            TimeUnit.MILLISECONDS.toSeconds(oneOffInfo.getWindowEndTimeMs()));
    return builder;
}

/**
 * Clears the current registration token and schedules a {@link OneoffTask} to start the
 * GcmRegistrationTaskService if Google Play Services is available.
 *
 * <p>Declared public to be used by the client to update the token if they define an
 * implementation of InstanceIDListenerService.
 */
public void fetchToken() {
  // Clear the current token. If the call to InstanceID#getToken fails a new token will be fetched
  // on the next call to {@code initializeGcm}.
  AndroidChannelPreferences.setRegistrationToken(context, "");

  // The GMS client library requires the corresponding version of Google Play Services APK to be
  // installed on the device.
  if (CommonUtils.getPackageVersion(context, GOOGLE_PLAY_SERVICES_PACKAGE)
      < QUESO_PLAY_SERVICES_VERSION) {
    logger.warning("Google Play Services unavailable. Initialization failed.");
    return;
  }

  OneoffTask registrationTask =
      new OneoffTask.Builder()
          .setExecutionWindow(0, 1)
          .setTag(AndroidChannelConstants.GCM_REGISTRATION_TASK_SERVICE_TAG)
          .setService(GcmRegistrationTaskService.class)
          .build();

  try {
    gcmNetworkManager.schedule(registrationTask);
  } catch (IllegalArgumentException exception) {
    // Scheduling the service can throw an exception due to a framework error on Android when
    // the the look up for the GCMTaskService being scheduled to be run fails.
    // See crbug/548314.
    logger.warning("Failed to schedule GCM registration task. Exception: %s", exception);
  }
}

@Override
protected void onPostExecute(TaskItem taskItem) {
    mTaskAdapter.addTaskItem(taskItem);
    mRecyclerView.scrollToPosition(0);

    if (taskItem.getType().equals(TaskItem.ONEOFF_TASK)) {
        Bundle bundle = new Bundle();
        bundle.putString(CodelabUtil.TASK_ID, taskItem.getId());

        // Schedule oneoff task.
        OneoffTask oneoffTask = new OneoffTask.Builder()
                .setService(BestTimeService.class)
                .setTag(taskItem.getId())
                .setRequiredNetwork(OneoffTask.NETWORK_STATE_CONNECTED)
                // Use an execution window of 30 seconds or more. Less than 30 seconds would not allow
                // GcmNetworkManager enough time to optimize the next best time to execute your task.
                .setExecutionWindow(0, 30)
                .setExtras(bundle)
                .build();
        mGcmNetworkManager.schedule(oneoffTask);
    } else {
        // Immediately make network call.
        Intent nowIntent = new Intent(mContext, NowIntentService.class);
        nowIntent.putExtra(CodelabUtil.TASK_ID, taskItem.getId());
        mContext.startService(nowIntent);
    }
}

public void scheduleSmartlistSync() {

        GcmNetworkManager gcm = GcmNetworkManager.getInstance(m_context);

        OneoffTask syncTask = new OneoffTask.Builder()
                .setService(ManualSyncService.class)
                .setExecutionWindow(5, 30)
                .setTag("sync-smartlist")
                .setUpdateCurrent(true)
                .setRequiredNetwork(Task.NETWORK_STATE_ANY)
                .build();

        gcm.schedule(syncTask);
    }

public void schedule(long time) {
    OneoffTask task = new OneoffTask.Builder()
            .setService(CastGcmTaskService.class)
            .setTag(CAST_SERVICE_TAG)
            .setExecutionWindow(time - 1, time)
            .setRequiredNetwork(Task.NETWORK_STATE_UNMETERED)
            .build();
    mGcmNetworkManager.schedule(task);
}