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

private void scheduleDispatchLocationService() {

        if(endpoints == null) {
            return;
        }

        Bundle bundle = new Bundle();
        try {
            bundle.putString(Constants.ENDPOINTS_KEY, OpenLocate.Endpoint.toJson(endpoints));
        } catch (JSONException e) {
            e.printStackTrace();
        }

        PeriodicTask task = new PeriodicTask.Builder()
                .setExtras(bundle)
                .setService(DispatchLocationService.class)
                .setPeriod(transmissionIntervalInSecs)
                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
                .setRequiresCharging(false)
                .setPersisted(true)
                .setUpdateCurrent(true)
                .setTag(LOCATION_DISPATCH_TAG)
                .build();

        networkManager.schedule(task);
    }

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 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();
}

public static void scheduleAutoUpdate(Context context) {
    long periodSecs = 60 * 60 * 24;     // Auto-update should be performed no more than once per 24 hours

    PeriodicTask dailyUpdate = new PeriodicTask.Builder()
            .setService(DataUpdateService.class)
            .setPeriod(periodSecs)
            .setTag(AUTO_UPDATE_TASK_NAME)
            .setPersisted(true)
            .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
            .setRequiresCharging(false)
            .setUpdateCurrent(true)
            .build();

    GcmNetworkManager.getInstance(context).schedule(dailyUpdate);
    Timber.d("Scheduled auto-update");
}

/**
 * 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 static PeriodicTask create() {
    return new PeriodicTask.Builder()
            .setService(AccountUpdateService.class)
            .setTag("account_update")
            .setUpdateCurrent(true)
            .setPeriod(24 * 3600)
            .setPersisted(true)
            .build();
}

public static PeriodicTask create(long periodInSeconds) {
    return new PeriodicTask.Builder()
            .setService(TimelineUpdateService.class)
            .setPeriod(periodInSeconds)
            .setTag("timeline_update")
            .setUpdateCurrent(true)
            .setPersisted(true)
            .build();
}

@Override
public void onClick(View v) {
    GcmNetworkManager gcmNM = GcmNetworkManager.getInstance(AccountSettingsActivity.this);
    Log.i(TAG, "Registering Periodic BackupTask");
    PeriodicTask task = new PeriodicTask.Builder()
            .setService(MyBackupService.class)
            .setTag(TASK_PERIODIC_BACKUP)
            .setFlex(TimeUnit.HOURS.toSeconds(1))
            .setRequiredNetwork(Task.NETWORK_STATE_UNMETERED)
            .setRequiresCharging(true)
            .setPeriod(TimeUnit.HOURS.toSeconds(6))
            .setPersisted(true)
            .build();
    gcmNM.schedule(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]
}

private Task createPeriodicTask() {
    return new PeriodicTask.Builder()
            .setService(MyGcmTaskService.class)
            .setTag(MyGcmTaskService.MY_TASK)
            .setPeriod(5L)
            .build();
}

public void schedule(@NonNull GcmNetworkManager networkManager) throws IllegalStateException{
    if (tag == null) {
        throw new IllegalStateException("Tag cannot be null for WindowTask, it is used for rescheduling to the right time");
    }
    else if (windowHours == 0) {
        throw new IllegalStateException("Window hours not defined");
    }

    if (extras == null){
        extras = new Bundle();
    }
    extras.putBoolean(KEY_REQUIRES_CHARGING, requiresCharging);
    extras.putInt(KEY_REQUIRED_NETWORK, requiredNetworkState);
    extras.putInt(KEY_WINDOW_HOURS, windowHours);
    extras.putInt(KEY_START_MINUTE, startMinute);
    extras.putInt(KEY_START_HOUR, startHour);
    extras.putBoolean(KEY_PERSISTED, persisted);
    extras.putBoolean(KEY_UPDATE_CURRENT, updateCurrent);
    extras.putBoolean(KEY_STRICT, strict);

    networkManager.cancelTask(tag, service);
    PeriodicTask.Builder task = new PeriodicTask.Builder()
            .setService(service)
            .setPersisted(persisted)
            .setRequiresCharging(requiresCharging)
            .setRequiredNetwork(requiredNetworkState)
            .setTag(tag)
            .setUpdateCurrent(updateCurrent)
            .setExtras(extras)
            .setPeriod(getPeriod())
            .setFlex(windowHours * 60);
    networkManager.schedule(task.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);
}

/**
 * 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;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_stock_list);
    ButterKnife.bind(this);

    if (getSupportActionBar() != null) {
        getSupportActionBar().setDisplayShowTitleEnabled(true);
    }

    if (findViewById(R.id.stock_detail_container) != null) {
        mTwoPane = true;
    }

    if (savedInstanceState == null) {
        // The intent service is for executing immediate pulls from the Yahoo API
        // GCMTaskService can only schedule tasks, they cannot execute immediately
        Intent stackServiceIntent = new Intent(this, StockIntentService.class);
        // Run the initialize task service so that some stocks appear upon an empty database
        stackServiceIntent.putExtra(StockIntentService.EXTRA_TAG, StockIntentService.ACTION_INIT);
        if (isNetworkAvailable()) {
            startService(stackServiceIntent);
        } else {
            Snackbar.make(mCoordinatorLayout, getString(R.string.no_internet_connection),
                    Snackbar.LENGTH_LONG).show();
        }
    } else {
        mChangeUnits = savedInstanceState.getInt(EXTRA_CHANGE_UNITS);
        if (savedInstanceState.getBoolean(EXTRA_ADD_DIALOG_OPENED, false)) {
            showDialogForAddingStock();
        }
    }

    mRecyclerView.setLayoutManager(new LinearLayoutManager(this));
    mRecyclerView.addOnItemTouchListener(new RecyclerViewItemClickListener(this, this));

    mAdapter = new QuoteCursorAdapter(this, null, mChangeUnits);
    mRecyclerView.setAdapter(mAdapter);

    getLoaderManager().initLoader(CURSOR_LOADER_ID, null, this);

    ItemTouchHelper.Callback callback = new ItemTouchHelperCallback(mAdapter);
    ItemTouchHelper itemTouchHelper = new ItemTouchHelper(callback);
    itemTouchHelper.attachToRecyclerView(mRecyclerView);

    // Create a periodic task to pull stocks once every hour after the app has been opened.
    // This is so Widget data stays up to date.
    PeriodicTask periodicTask = new PeriodicTask.Builder()
            .setService(StockTaskService.class)
            .setPeriod(/* 1h */ 60 * 60)
            .setFlex(/* 10s */ 10)
            .setTag(StockTaskService.TAG_PERIODIC)
            .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
            .setRequiresCharging(false)
            .build();
    // Schedule task with tag "periodic." This ensure that only the stocks present in the DB
    // are updated.
    GcmNetworkManager.getInstance(this).schedule(periodicTask);

}

public static void schedule(Context context, PeriodicTask task, GregorianCalendar start, int windowHours){
    Intent intent = new Intent(context, ScheduleReceiver.class);

}