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); }
/** * 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); } }
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] }
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()); } }
/** * 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!"); }
@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); }
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; }
@VisibleForTesting static Task createTaskFromTaskInfo(@NonNull TaskInfo taskInfo) { Bundle taskExtras = new Bundle(); taskExtras.putString( BACKGROUND_TASK_CLASS_KEY, taskInfo.getBackgroundTaskClass().getName()); taskExtras.putBundle(BACKGROUND_TASK_EXTRAS_KEY, taskInfo.getExtras()); Task.Builder builder; if (taskInfo.isPeriodic()) { builder = getPeriodicTaskBuilder(taskInfo.getPeriodicInfo()); } else { builder = getOneOffTaskBuilder(taskInfo.getOneOffInfo()); } builder.setExtras(taskExtras) .setPersisted(taskInfo.isPersisted()) .setRequiredNetwork(getGcmNetworkManagerNetworkTypeFromTypeFromTaskNetworkType( taskInfo.getRequiredNetworkType())) .setRequiresCharging(taskInfo.requiresCharging()) .setService(BackgroundTaskGcmTaskService.class) .setTag(taskIdToTaskTag(taskInfo.getTaskId())) .setUpdateCurrent(taskInfo.shouldUpdateCurrent()); return builder.build(); }
@Override public boolean schedule(Context context, @NonNull TaskInfo taskInfo) { ThreadUtils.assertOnUiThread(); if (!BackgroundTaskScheduler.hasParameterlessPublicConstructor( taskInfo.getBackgroundTaskClass())) { Log.e(TAG, "BackgroundTask " + taskInfo.getBackgroundTaskClass() + " has no parameterless public constructor."); return false; } GcmNetworkManager gcmNetworkManager = getGcmNetworkManager(context); if (gcmNetworkManager == null) { Log.e(TAG, "GcmNetworkManager is not available."); return false; } Task task = createTaskFromTaskInfo(taskInfo); gcmNetworkManager.schedule(task); 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); }
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"); }
boolean scheduleTask(Context context, Task task) { if (!canScheduleTasks(context)) { return false; } try { GcmNetworkManager.getInstance(context).schedule(task); } catch (IllegalArgumentException e) { return false; } return true; }
@CalledByNative private boolean schedule(long periodWifiSeconds, long periodFallbackSeconds) { if (!mGCMEnabled) return false; Log.i(TAG, "Scheduling: " + periodWifiSeconds + " " + periodFallbackSeconds); boolean isScheduled = periodWifiSeconds != 0 || periodFallbackSeconds != 0; ContextUtils.getAppSharedPreferences() .edit() .putBoolean(PREF_IS_SCHEDULED, isScheduled) .apply(); // 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. try { mScheduler.cancelTask(OBSOLETE_TASK_TAG_WIFI_CHARGING, ChromeBackgroundService.class); scheduleOrCancelFetchTask( TASK_TAG_WIFI, periodWifiSeconds, Task.NETWORK_STATE_UNMETERED); scheduleOrCancelFetchTask( TASK_TAG_FALLBACK, periodFallbackSeconds, Task.NETWORK_STATE_CONNECTED); mScheduler.cancelTask(OBSOLETE_TASK_TAG_RESCHEDULE, ChromeBackgroundService.class); } catch (IllegalArgumentException e) { // Disable GCM for the remainder of this session. mGCMEnabled = false; ContextUtils.getAppSharedPreferences().edit().remove(PREF_IS_SCHEDULED).apply(); // Return false so that the failure will be logged. return false; } return true; }
public static void cancel(Context context, nuclei.task.Task<?> task, boolean forceGcm) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !forceGcm) { cancelL(context, task); } else { cancelPreL(context, task); } }
@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); }
private Task createPeriodicTask() { return new PeriodicTask.Builder() .setService(MyGcmTaskService.class) .setTag(MyGcmTaskService.MY_TASK) .setPeriod(5L) .build(); }
private Task createOnoffTask() { return new OneoffTask.Builder() .setService(MyGcmTaskService.class) .setTag(MyGcmTaskService.MY_TASK) .setExecutionWindow(0, 1000L) .build(); }
WindowTask(Class<? extends SchedulingService> service, TaskParams params){ setTag(params.getTag()); Bundle extras = params.getExtras(); //noinspection WrongConstant setRequiredNetwork(extras.getInt(KEY_REQUIRED_NETWORK, Task.NETWORK_STATE_CONNECTED)); setPersisted(extras.getBoolean(KEY_PERSISTED, false)); setRequiresCharging(extras.getBoolean(KEY_REQUIRES_CHARGING)); setStartTime(extras.getInt(KEY_START_HOUR, 0), extras.getInt(KEY_START_MINUTE, 0)); setWindowHours(extras.getInt(KEY_WINDOW_HOURS, 6)); setUpdateCurrent(extras.getBoolean(KEY_UPDATE_CURRENT, false)); setStrictMode(extras.getBoolean(KEY_STRICT, false)); setExtras(extras); setService(service); }
protected <T extends Task.Builder> T prepareBuilder(T builder, JobRequest request) { builder.setTag(createTag(request)) .setService(PlatformGcmService.class) .setUpdateCurrent(true) .setRequiredNetwork(convertNetworkType(request.requiredNetworkType())) .setPersisted(JobUtil.hasBootPermission(mContext)) .setRequiresCharging(request.requiresCharging()) .setExtras(request.getTransientExtras()); return builder; }
protected int convertNetworkType(@NonNull JobRequest.NetworkType networkType) { switch (networkType) { case ANY: return Task.NETWORK_STATE_ANY; case CONNECTED: return Task.NETWORK_STATE_CONNECTED; case UNMETERED: return Task.NETWORK_STATE_UNMETERED; case NOT_ROAMING: return Task.NETWORK_STATE_UNMETERED; // use as fallback, NOT_ROAMING not supported default: throw new IllegalStateException("not implemented"); } }
@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 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; }
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; }
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); }
public static void cancel(Context context, nuclei.task.Task<?> task) { cancel(context, task, false); }
private static void cancelPreL(Context context, nuclei.task.Task<?> task) { GcmNetworkManager.getInstance(context) .cancelTask(task.getTaskTag(), TaskGcmService.class); }
