/** * 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; }
private static boolean removeScheduledTasks(GcmNetworkManager scheduler) { // Third-party code causes broadcast to touch disk. http://crbug.com/614679 StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads(); try { scheduler.cancelTask(TASK_TAG, ChromeBackgroundService.class); } catch (IllegalArgumentException e) { // This occurs when BackgroundSyncLauncherService is not found in the application // manifest. This should not happen in code that reaches here, but has been seen in // the past. See https://crbug.com/548314 // Disable GCM for the remainder of this session. setGCMEnabled(false); // Return false so that the failure will be logged. return false; } finally { StrictMode.setThreadPolicy(oldPolicy); } return true; }
/** * Reschedule any required background sync tasks, if they have been removed due to an * application upgrade. * * This method checks the saved preferences, and reschedules the sync tasks as appropriate * to match the preferences. * This method is static so that it can be run without actually instantiating a * BackgroundSyncLauncher. */ protected static void rescheduleTasksOnUpgrade(final Context context) { final GcmNetworkManager scheduler = GcmNetworkManager.getInstance(context); BackgroundSyncLauncher.ShouldLaunchCallback callback = new BackgroundSyncLauncher.ShouldLaunchCallback() { @Override public void run(Boolean shouldLaunch) { if (shouldLaunch) { // It's unclear what time the sync event was supposed to fire, so fire // without delay and let the browser reschedule if necessary. // TODO(iclelland): If this fails, report the failure via UMA (not now, // since the browser is not running, but on next startup.) scheduleLaunchTask(context, scheduler, 0); } } }; BackgroundSyncLauncher.shouldLaunchBrowserIfStopped(context, callback); }
@Override public boolean onPreferenceChange(Preference preference, Object o) { // UI or Streaming preference changed if (preference == mThemePreference || preference == mHighlightTimelineLinksPreference || preference == mShowClientNameInTimelinePreference || preference == mTimelineFontSizePreference || preference == mHideMediaPreference || preference == mHideAvatarsPreference || preference == mShowAbsoluteTimePreference || preference == mCompactTimelinePreference || preference == mShowMediaPreviewPreference || preference == mStreamingPreference || mStreamingOnWifiPreference == preference) { Snackbar.make(getActivity().findViewById(R.id.coordinator), R.string.need_app_restart, Snackbar.LENGTH_INDEFINITE).show(); } if (preference == mTimelineFontSizePreference) { preference.setSummary((String) o); } else if (preference == mBackgroundUpdatePreference || preference == mBackgroundUpdateIntervalPreference) { GcmNetworkManager.getInstance(getActivity()) .schedule(TimelineUpdateService.create(mPrefsModel.backgroundUpdateInterval() / 1000)); } return true; }
@Override public int onRunTask(TaskParams taskParams) { try { Bundle bundle = taskParams.getExtras(); String taskName = bundle.getString(TaskScheduler.TASK_NAME); Task task = (Task) Class.forName(taskName).newInstance(); ArrayMap<String, Object> map = new ArrayMap<>(bundle.size()); for (String key : bundle.keySet()) { map.put(key, bundle.get(key)); } task.deserialize(map); if (task.isRunning()) return GcmNetworkManager.RESULT_RESCHEDULE; task.attach(null, ContextHandle.getApplicationHandle()); task.run(); task.deliverResult(this); return GcmNetworkManager.RESULT_SUCCESS; } catch (Exception err) { LOG.e("Error running task", err); return GcmNetworkManager.RESULT_FAILURE; } }
@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); }
@Override public int onRunTask(TaskParams taskParams) { Log.i(TAG, "Backing up the account settings"); final SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this); Bundle data = new Bundle(); data.putString(FIRST_NAME, sharedPreferences.getString(FIRST_NAME,"")); data.putString(LAST_NAME, sharedPreferences.getString(LAST_NAME,"")); data.putString(AGE, sharedPreferences.getString(AGE,"")); data.putString("resource", RESOURCE); data.putString("operation", sharedPreferences.getString(OPERATION,"")); String id = Integer.toString(new Random().nextInt()); GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(MyBackupService.this); try { gcm.send(getString(R.string.gcm_SenderId) + "@gcm.googleapis.com", id, data); } catch (IOException e) { Log.e(TAG, "Failed to backup account"); return GcmNetworkManager.RESULT_RESCHEDULE; } return GcmNetworkManager.RESULT_SUCCESS; }
private int fetchUrl(OkHttpClient client, String url) { Request request = new Request.Builder() .url(url) .build(); try { Response response = client.newCall(request).execute(); Log.d(TAG, "fetchUrl:response:" + response.body().string()); if (response.code() != 200) { return GcmNetworkManager.RESULT_FAILURE; } } catch (IOException e) { Log.e(TAG, "fetchUrl:error" + e.toString()); return GcmNetworkManager.RESULT_FAILURE; } return GcmNetworkManager.RESULT_SUCCESS; }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Calendar now = Calendar.getInstance(); now.setLenient(true); new WindowTask() .setService(SyncService.class) .setPersisted(true) .setUpdateCurrent(true) .setTag(SyncService.TAG) .setStartTime(now.get(Calendar.HOUR_OF_DAY), now.get(Calendar.MINUTE) + 2) .setWindowHours(1) .schedule(GcmNetworkManager.getInstance(this)); }
@Override public int onRunTask(TaskParams taskParams) { Log.d(TAG, "onRunTask: " + taskParams.getTag()); String tag = taskParams.getTag(); // Default result is success. int result = GcmNetworkManager.RESULT_SUCCESS; // Choose method based on the tag. if (GcmActivity.TASK_TAG_UNMETERED.equals(tag)) { result = doUnmeteredTask(); } else if (GcmActivity.TASK_TAG_CHARGING.equals(tag)) { result = doChargingTask(); } // Return one of RESULT_SUCCESS, RESULT_FAILURE, or RESULT_RESCHEDULE return result; }
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 int onRunTask(TaskParams taskParams) { Log.d(TAG, "Task uploader has started"); // check Airplane Mode enabled if (ConnectionUtils.isAirplaneModeEnabled(this)) { Log.d(TAG, "Airplane Mode enabled. Upload request ignored"); return GcmNetworkManager.RESULT_FAILURE; } // device is not online if (!ConnectionUtils.isOnline(this)) { Log.d(TAG, "Device is not online. Upload request ignored"); return GcmNetworkManager.RESULT_FAILURE; } if (daoProvider == null) { daoProvider = DaoProvider.getInstance(getApplicationContext()); } Handler handler = new Handler(getMainLooper()); handler.post(this::prepareData); return GcmNetworkManager.RESULT_SUCCESS; }
@Override public int onRunTask(TaskParams taskParams) { Log.d(TAG, "PlanB task has been executed!"); String userToken = PreferenceProvider .getInstance(getApplicationContext()) .getUserToken(); // only when user is logged in if (userToken != null && !userToken.isEmpty()) { HarvesterServiceProvider serviceProvider = HarvesterServiceProvider.getInstance(getApplicationContext()); if (!serviceProvider.isServiceRunning()) { serviceProvider.startSensingService(); } if (!serviceProvider.isAccessibilityServiceRunning()) { serviceProvider.startAccessibilityService(); } } return GcmNetworkManager.RESULT_SUCCESS; }
@Override public int onRunTask(TaskParams params) { String tag = params.getTag(); TaskCollection tasks = TaskCollection.getInstance(this); TaskTracker task = tasks.getTask(tag); if (task != null) { task.execute(mLogger); tasks.updateTask(task); } else { mLogger.log(Log.ERROR, "Could not find task with tag " + tag); task = TaskTracker.emptyTaskWithTag(tag); task.execute(mLogger); tasks.updateTask(task); } return GcmNetworkManager.RESULT_SUCCESS; }
@Override public int onRunTask(TaskParams taskParams) { if (actionRecovery != null && gson != null && orchextraLogger != null) { orchextraLogger.log("Executing Scheduled action " + taskParams.getTag()); try { Bundle extras = taskParams.getExtras(); String stringAndroidBasicAction = extras.getString(ActionsSchedulerGcmImpl.BUNDLE_TASK_PARAM_NAME); AndroidBasicAction androidBasicAction = gson.fromJson(stringAndroidBasicAction, AndroidBasicAction.class); actionRecovery.recoverAction(androidBasicAction); orchextraLogger.log("Scheduled action Executed and deleted " + taskParams.getTag()); return GcmNetworkManager.RESULT_SUCCESS; } catch (Exception e) { orchextraLogger.log("Error retrieving Scheduled action", OrchextraSDKLogLevel.ERROR); return GcmNetworkManager.RESULT_FAILURE; } } else { return GcmNetworkManager.RESULT_FAILURE; } }
@Override public int onRunTask(TaskParams taskParams) { int jobId = Integer.parseInt(taskParams.getTag()); JobProxy.Common common = new JobProxy.Common(this, CAT, jobId); JobRequest request = common.getPendingRequest(true, true); if (request == null) { return GcmNetworkManager.RESULT_FAILURE; } Job.Result result = common.executeJobRequest(request, taskParams.getExtras()); if (Job.Result.SUCCESS.equals(result)) { return GcmNetworkManager.RESULT_SUCCESS; } else { return GcmNetworkManager.RESULT_FAILURE; } }
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; }
/** * Reschedule any required background sync tasks, if they have been removed due to an * application upgrade. * * This method checks the saved preferences, and reschedules the sync tasks as appropriate * to match the preferences. * This method is static so that it can be run without actually instantiating a * BackgroundSyncLauncher. */ protected static void rescheduleTasksOnUpgrade(final Context context) { final GcmNetworkManager scheduler = GcmNetworkManager.getInstance(context); BackgroundSyncLauncher.ShouldLaunchCallback callback = new BackgroundSyncLauncher.ShouldLaunchCallback() { @Override public void run(Boolean shouldLaunch) { if (shouldLaunch) { // It's unclear what time the sync event was supposed to fire, so fire // without delay and let the browser reschedule if necessary. // TODO(iclelland): If this fails, report the failure via UMA (not now, // since the browser is not running, but on next startup.) scheduleLaunchTask(scheduler, 0); } } }; BackgroundSyncLauncher.shouldLaunchBrowserIfStopped(callback); }
@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; }
@Override public int onRunTask(TaskParams taskParams) { Injector.inject(this); Ln.v("Syncing Data"); m_accountUtils.refreshAuthToken(new AccountUtils.TokenRefreshListener() { @Override public void onTokenRefreshed() { hasToken = true; m_smartListService.synchronizeSmartLists(); } @Override public void onTokenError() { hasToken = false; } }); return GcmNetworkManager.RESULT_SUCCESS; }
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"); }
@Override public int onRunTask(TaskParams taskParams) { try { if (taskParams.getTag().equals(AUTO_UPDATE_TASK_NAME)) { Timber.d("GCM invoked update task"); IBurnService service = new IBurnService(getApplicationContext()); boolean success = service.updateData().blockingGet(); Timber.d("GCM invoked task finished with success %b", success); return success ? GcmNetworkManager.RESULT_SUCCESS : GcmNetworkManager.RESULT_RESCHEDULE; } Timber.w("Unknown task (%s) invoked", taskParams.getTag()); return GcmNetworkManager.RESULT_FAILURE; } catch (Exception e) { ExceptionHandler.saveException(e, null); Timber.e(e, "GCM task failed: %s", e.getClass().getSimpleName()); return GcmNetworkManager.RESULT_RESCHEDULE; } }
@Override public int onRunTask(TaskParams taskParams) { Intent i = new Intent(); i.setPackage(getPackageName()); i.setAction(CastServiceConstants.ACTION_MEDIA_COMMAND); i.putExtra(CastServiceConstants.EXTRA_COMMAND, CastServiceConstants.COMMAND_NEXT); // This should work since GcmTaskService should be in foreground, and it service // should be previously created startService(i); // Hold a bit the job, to ensure the picture was sent over the network try { synchronized (mNetworkLock) { mNetworkLock.wait(MAX_NETWORK_WAIT); } } catch (InterruptedException ex) { // Ignore } return GcmNetworkManager.RESULT_SUCCESS; }
void onCreate() { SQLiteOpenHelper helper = new DatabaseHelper(context); locations = new LocationDatabase(helper); networkManager = GcmNetworkManager.getInstance(context); alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); registerForLocalBroadcastEvents(); setServiceStatusOnStart(); Log.d(TAG, "Inside onCreate of Location service Helper"); }
boolean scheduleTask(Context context, Task task) { if (!canScheduleTasks(context)) { return false; } try { GcmNetworkManager.getInstance(context).schedule(task); } catch (IllegalArgumentException e) { return false; } return true; }
boolean cancelTask(Context context, String tag) { if (!canScheduleTasks(context)) { return false; } try { GcmNetworkManager.getInstance(context).cancelTask(tag, ChromeBackgroundService.class); } catch (IllegalArgumentException e) { return false; } return true; }
