private void sendRegistrationToServer(String token) {
    try {
        Log.d(TAG, "Scheduling tasks");
        PeriodicTask task = new PeriodicTask.Builder()
                .setService(TaskService.class)
                .setTag(GcmActivity.TASK_TAG_UNMETERED)
                .setRequiredNetwork(Task.NETWORK_STATE_UNMETERED)
                .setPeriod(7200L)
                .build();

        GcmNetworkManager.getInstance(this).cancelAllTasks(TaskService.class);
        GcmNetworkManager.getInstance(this).schedule(task);
        PlusSyncService.startSyncService(getApplicationContext(), "RegistrationToServer");
        GcmActivity.queueCheckOld(getApplicationContext());
    } catch (Exception e) {
        Log.e(TAG, "Exception in sendRegistration: " + e.toString());
    }
}
 

private void sendRegistrationToServer(String token) {
    try {
        Log.d(TAG, "Scheduling tasks");
        PeriodicTask task = new PeriodicTask.Builder()
                .setService(TaskService.class)
                .setTag(GcmActivity.TASK_TAG_UNMETERED)
                .setRequiredNetwork(Task.NETWORK_STATE_UNMETERED)
                .setPeriod(7200L)
                .build();

        GcmNetworkManager.getInstance(this).cancelAllTasks(TaskService.class);
        GcmNetworkManager.getInstance(this).schedule(task);
        PlusSyncService.startSyncService(getApplicationContext(), "RegistrationToServer");
        GcmActivity.queueCheckOld(getApplicationContext());
    } catch (Exception e) {
        Log.e(TAG, "Exception in sendRegistration: " + e.toString());
    }
}
 

private static PeriodicTask buildFetchTask(
        String tag, long periodSeconds, int requiredNetwork) {
    // Add a bit of "flex" around the target period. This achieves the following:
    // - It makes sure the task doesn't run (significantly) before its initial period has
    //   elapsed. In practice, the scheduler seems to behave like that anyway, but it doesn't
    //   guarantee that, so we shouldn't rely on it.
    // - It gives the scheduler a bit of room to optimize for battery life.
    long effectivePeriodSeconds = (long) (periodSeconds * (1.0 + FLEX_FACTOR));
    long flexSeconds = (long) (periodSeconds * (2.0 * FLEX_FACTOR));
    return new PeriodicTask.Builder()
            .setService(ChromeBackgroundService.class)
            .setTag(tag)
            .setPeriod(effectivePeriodSeconds)
            .setFlex(flexSeconds)
            .setRequiredNetwork(requiredNetwork)
            .setPersisted(true)
            .setUpdateCurrent(true)
            .build();
}
 

private void addPeriodic(long periodSecs, long flexSecs, int connectivity,
                         boolean charging, boolean persistence) {
    if (flexSecs > periodSecs) {
        Toast.makeText(getActivity(),
                getString(R.string.scheduler_error_flex),
                Toast.LENGTH_SHORT).show();
        return;
    }
    String tag = Long.toString(SystemClock.currentThreadTimeMillis());
    final TaskTracker taskTracker = TaskTracker.createPeriodic(tag, periodSecs, flexSecs);
    PeriodicTask periodic = new PeriodicTask.Builder()
            .setService(TaskSchedulerService.class)
            .setPeriod(periodSecs)
            .setFlex(flexSecs)
            .setTag(tag)
            .setRequiredNetwork(connectivity)
            .setRequiresCharging(charging)
            .setPersisted(persistence)
            .build();
    mScheduler.schedule(periodic);
    mTasks.updateTask(taskTracker);
}
 

private static PeriodicTask buildFetchTask(
        String tag, long periodSeconds, int requiredNetwork) {
    // Add a bit of "flex" around the target period. This achieves the following:
    // - It makes sure the task doesn't run (significantly) before its initial period has
    //   elapsed. In practice, the scheduler seems to behave like that anyway, but it doesn't
    //   guarantee that, so we shouldn't rely on it.
    // - It gives the scheduler a bit of room to optimize for battery life.
    long effectivePeriodSeconds = (long) (periodSeconds * (1.0 + FLEX_FACTOR));
    long flexSeconds = (long) (periodSeconds * (2.0 * FLEX_FACTOR));
    return new PeriodicTask.Builder()
            .setService(ChromeBackgroundService.class)
            .setTag(tag)
            .setPeriod(effectivePeriodSeconds)
            .setFlex(flexSeconds)
            .setRequiredNetwork(requiredNetwork)
            .setPersisted(true)
            .setUpdateCurrent(true)
            .build();
}
 

/**
 * Schedules a periodic task to precache resources.
 * @param context The application context.
 * @return false if the task cannot be scheduled.
 */
private static boolean schedulePeriodicPrecacheTask(Context context) {
    PeriodicTask task = new PeriodicTask.Builder()
            .setPeriod(WAIT_UNTIL_NEXT_PRECACHE_SECONDS)
            .setPersisted(true)
            .setRequiredNetwork(PeriodicTask.NETWORK_STATE_UNMETERED)
            .setRequiresCharging(true)
            .setService(ChromeBackgroundService.class)
            .setTag(PERIODIC_TASK_TAG)
            .build();
    return sTaskScheduler.scheduleTask(context, task);
}
 

private static PeriodicTask buildFetchTask(
        String tag, long periodSeconds, int requiredNetwork, boolean requiresCharging) {
    return new PeriodicTask.Builder()
            .setService(ChromeBackgroundService.class)
            .setTag(tag)
            .setPeriod(periodSeconds)
            .setRequiredNetwork(requiredNetwork)
            .setRequiresCharging(requiresCharging)
            .setPersisted(true)
            .setUpdateCurrent(true)
            .build();
}
 

/**
 * Schedules a periodic task to precache resources.
 * @param context The application context.
 * @return false if the task cannot be scheduled.
 */
private static boolean schedulePeriodicPrecacheTask(Context context) {
    PeriodicTask task = new PeriodicTask.Builder()
                                .setPeriod(WAIT_UNTIL_NEXT_PRECACHE_SECONDS)
                                .setPersisted(true)
                                .setRequiredNetwork(PeriodicTask.NETWORK_STATE_UNMETERED)
                                .setRequiresCharging(ChromeVersionInfo.isStableBuild())
                                .setService(ChromeBackgroundService.class)
                                .setTag(PERIODIC_TASK_TAG)
                                .build();
    return sTaskScheduler.scheduleTask(context, task);
}
 

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

    // [START start_periodic_task]
    PeriodicTask task = new PeriodicTask.Builder()
            .setService(MyTaskService.class)
            .setTag(TASK_TAG_PERIODIC)
            .setPeriod(30L)
            .build();

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

/**
 * Schedules a periodic task to precache resources.
 * @param context The application context.
 * @return false if the task cannot be scheduled.
 */
private static boolean schedulePeriodicPrecacheTask(Context context) {
    PeriodicTask task = new PeriodicTask.Builder()
                                .setPeriod(WAIT_UNTIL_NEXT_PRECACHE_SECONDS)
                                .setPersisted(true)
                                .setRequiredNetwork(PeriodicTask.NETWORK_STATE_UNMETERED)
                                .setRequiresCharging(ChromeVersionInfo.isStableBuild())
                                .setService(ChromeBackgroundService.class)
                                .setTag(PERIODIC_TASK_TAG)
                                .build();
    return sTaskScheduler.scheduleTask(context, task);
}
 

private static Task.Builder getPeriodicTaskBuilder(TaskInfo.PeriodicInfo periodicInfo) {
    PeriodicTask.Builder builder = new PeriodicTask.Builder();
    builder.setPeriod(TimeUnit.MILLISECONDS.toSeconds(periodicInfo.getIntervalMs()));
    if (periodicInfo.hasFlex()) {
        builder.setFlex(TimeUnit.MILLISECONDS.toSeconds(periodicInfo.getFlexMs()));
    }
    return builder;
}