@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 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; }
@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; }
@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; } }
/** * Retrieves the {@link TaskParameters} from the {@link TaskParams}, which are passed as * one of the keys. Only values valid for {@link android.os.BaseBundle} are supported, and other * values are stripped at the time when the task is scheduled. * * @param taskParams the {@link TaskParams} to extract the {@link TaskParameters} from. * @return the {@link TaskParameters} for the current job. */ static TaskParameters getTaskParametersFromTaskParams(@NonNull TaskParams taskParams) { int taskId; try { taskId = Integer.parseInt(taskParams.getTag()); } catch (NumberFormatException e) { Log.e(TAG, "Cound not parse task ID from task tag: " + taskParams.getTag()); return null; } TaskParameters.Builder builder = TaskParameters.create(taskId); Bundle extras = taskParams.getExtras(); Bundle taskExtras = extras.getBundle(BACKGROUND_TASK_EXTRAS_KEY); builder.addExtras(taskExtras); return builder.build(); }
@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; }
@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; }
@Override public int onRunTask(TaskParams taskParams) { Log.i(TAG, "onRunTask"); Intent start = new Intent(this, TrackerActivity.class); start.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); startActivity(start); return GcmNetworkManager.RESULT_SUCCESS; }
@Override public int onRunTask(TaskParams taskParams) { try { final AccountModel accountModel = new AccountModel(); final List<Account> accounts = accountModel.accounts().toBlocking().first(); for (Account account : accounts) { final UserModel userModel = new UserModel(account, account.screenName()); final User user = userModel.user().toBlocking().first(); final Account updatedAccount = account.withMeta( user.getName(), user.getScreenName(), user.getOriginalProfileImageURL(), user.getProfileBannerMobileRetinaURL() ); accountModel.update(updatedAccount).toBlocking().first(); new ContactModel(account).update().toBlocking().first(); } return GcmNetworkManager.RESULT_SUCCESS; } catch (Throwable t) { Timber.i(t, ""); } return GcmNetworkManager.RESULT_FAILURE; }
@Override public int onRunTask(TaskParams taskParams) { try { final PrefsModel prefsModel = new PrefsModel(); for (final Account account : new AccountModel().accounts().toBlocking().first()) { new TimelineModel(account, TimelineModel.HOME_ID).update().toBlocking().first(); new TimelineModel(account, TimelineModel.RETWEETS_ID).update().toBlocking().first(); new TimelineModel(account, TimelineModel.FAVORITES_ID).update().toBlocking().first(); new UserListsModel(account).update().toBlocking().first(); new DirectsModel(account).update().toBlocking().first(); List<UserList> userLists = new UserListsModel(account).lists().toBlocking().first(); for (UserList userList : userLists) new TimelineModel(account, userList.listId()).update().toBlocking().first(); new TimelineModel(account, TimelineModel.MENTIONS_ID) .update() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new DefaultObserver<Integer>() { @Override public void onNext(Integer newMentionCount) { super.onNext(newMentionCount); if (prefsModel.isNotificationsEnabled() && newMentionCount > 0) { notifyMentions(account, newMentionCount); } } }); } return GcmNetworkManager.RESULT_SUCCESS; } catch (Throwable t) { Timber.i(t, ""); } return GcmNetworkManager.RESULT_FAILURE; }
@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 (MainActivity.TASK_TAG_WIFI.equals(tag)) { result = doWifiTask(); } else if (MainActivity.TASK_TAG_CHARGING.equals(tag)) { result = doChargingTask(); } else if (MainActivity.TASK_TAG_PERIODIC.equals(tag)) { result = doPeriodicTask(); } // Create Intent to broadcast the task information. Intent intent = new Intent(); intent.setAction(ACTION_DONE); intent.putExtra(EXTRA_TAG, tag); intent.putExtra(EXTRA_RESULT, result); // Send local broadcast, running Activities will be notified about the task. LocalBroadcastManager manager = LocalBroadcastManager.getInstance(this); manager.sendBroadcast(intent); // Return one of RESULT_SUCCESS, RESULT_FAILURE, or RESULT_RESCHEDULE return result; }
@Override protected void onHandleIntent(Intent intent) { Log.d(StockIntentService.class.getSimpleName(), "Stock Intent Service"); StockTaskService stockTaskService = new StockTaskService(this); Bundle args = new Bundle(); if (intent.getStringExtra("tag").equals("add")){ args.putString("symbol", intent.getStringExtra("symbol")); } // We can call OnRunTask from the intent service to force it to run immediately instead of // scheduling a task. stockTaskService.onRunTask(new TaskParams(intent.getStringExtra("tag"), args)); }
@Override public int onRunTask(TaskParams taskParams) { switch (taskParams.getTag()) { case MY_TASK: //task code... return GcmNetworkManager.RESULT_SUCCESS; } return GcmNetworkManager.RESULT_SUCCESS; }
@Override public int onRunTask(TaskParams taskParams) { /** * Call reschedule only if Task is success (or fail), and no exponential backoff needs to take * place */ reschedule(SyncService.class, taskParams); return GcmNetworkManager.RESULT_SUCCESS; }
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); }
private String buildUrl(TaskParams params) throws UnsupportedEncodingException { ContentResolver resolver = mContext.getContentResolver(); if (params.getTag().equals(StockIntentService.ACTION_INIT) || params.getTag().equals(TAG_PERIODIC)) { mIsUpdate = true; Cursor cursor = resolver.query(QuoteProvider.Quotes.CONTENT_URI, new String[]{"Distinct " + QuoteColumns.SYMBOL}, null, null, null); if (cursor != null && cursor.getCount() == 0 || cursor == null) { // Init task. Populates DB with quotes for the symbols seen below return INIT_QUOTES; } else { DatabaseUtils.dumpCursor(cursor); cursor.moveToFirst(); for (int i = 0; i < cursor.getCount(); i++) { mStoredSymbols.append("\""); mStoredSymbols.append(cursor.getString( cursor.getColumnIndex(QuoteColumns.SYMBOL))); mStoredSymbols.append("\","); cursor.moveToNext(); } mStoredSymbols.replace(mStoredSymbols.length() - 1, mStoredSymbols.length(), ""); return mStoredSymbols.toString(); } } else if (params.getTag().equals(StockIntentService.ACTION_ADD)) { mIsUpdate = false; // Get symbol from params.getExtra and build query String stockInput = params.getExtras().getString(StockIntentService.EXTRA_SYMBOL); return "\"" + stockInput + "\""; } else { throw new IllegalStateException("Action not specified in TaskParams."); } }
@Override protected void onHandleIntent(Intent intent) { Bundle args = new Bundle(); if (intent.getStringExtra(EXTRA_TAG).equals(ACTION_ADD)) { args.putString(EXTRA_SYMBOL, intent.getStringExtra(EXTRA_SYMBOL)); } // We can call OnRunTask from the intent service to force it to run immediately instead of // scheduling a task. StockTaskService stockTaskService = new StockTaskService(this); stockTaskService.onRunTask(new TaskParams(intent.getStringExtra(EXTRA_TAG), args)); }
@Override public int onRunTask(TaskParams taskParams) { String taskId = taskParams.getExtras().getString(CodelabUtil.TASK_ID); boolean completed = CodelabUtil.makeNetworkCall(); Log.d(TAG, "Oneoff scheduled call executed. Task ID: " + taskId); // Prepare Intent to send with broadcast. Intent taskUpdateIntent = new Intent(CodelabUtil.TASK_UPDATE_FILTER); taskUpdateIntent.putExtra(CodelabUtil.TASK_ID, taskId); TaskItem taskItem = CodelabUtil.getTaskItemFromFile(this, taskId); if (taskItem == null) { return GcmNetworkManager.RESULT_FAILURE; } if (completed) { taskItem.setStatus(TaskItem.EXECUTED_STATUS); } else { taskItem.setStatus(TaskItem.FAILED_STATUS); } taskUpdateIntent.putExtra(CodelabUtil.TASK_STATUS, taskItem.getStatus()); CodelabUtil.saveTaskItemToFile(this, taskItem); // Notify listeners (MainActivity) that task was completed successfully. LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this); localBroadcastManager.sendBroadcast(taskUpdateIntent); return GcmNetworkManager.RESULT_SUCCESS; }
@Override @VisibleForTesting public int onRunTask(final TaskParams params) { final String taskTag = params.getTag(); Log.i(TAG, "[" + taskTag + "] Woken up at " + new java.util.Date().toString()); final ChromeBackgroundServiceWaiter waiter = getWaiterIfNeeded(params.getExtras()); final Context context = this; ThreadUtils.runOnUiThread(new Runnable() { @Override public void run() { switch (taskTag) { case BackgroundSyncLauncher.TASK_TAG: handleBackgroundSyncEvent(context, taskTag); break; case OfflinePageUtils.TASK_TAG: handleOfflinePageBackgroundLoad( context, params.getExtras(), waiter, taskTag); break; case SnippetsLauncher.TASK_TAG_WIFI: case SnippetsLauncher.TASK_TAG_FALLBACK: handleFetchSnippets(context, taskTag); break; case PrecacheController.PERIODIC_TASK_TAG: case PrecacheController.CONTINUATION_TASK_TAG: handlePrecache(context, taskTag); break; case DownloadResumptionScheduler.TASK_TAG: DownloadResumptionScheduler.getDownloadResumptionScheduler( context.getApplicationContext()).handleDownloadResumption(); break; default: Log.i(TAG, "Unknown task tag " + taskTag); break; } } }); // If needed, block the GcmNetworkManager thread until the UI thread has finished its work. waitForTaskIfNeeded(waiter); return GcmNetworkManager.RESULT_SUCCESS; }
public void reschedule(Class<? extends SchedulingService> service, TaskParams params) { GcmNetworkManager networkManager = GcmNetworkManager.getInstance(this); WindowTask windowTask = new WindowTask(service, params); windowTask.schedule(networkManager); }
@Override public int onRunTask(TaskParams taskParams) { SmartScheduler smartScheduler = SmartScheduler.getInstance(getApplicationContext()); smartScheduler.onPeriodicTaskJobScheduled(taskParams.getTag(), taskParams.getExtras()); return GcmNetworkManager.RESULT_SUCCESS; }
@Override public int onRunTask(TaskParams params) { final BackgroundTask backgroundTask = BackgroundTaskSchedulerGcmNetworkManager.getBackgroundTaskFromTaskParams(params); if (backgroundTask == null) { Log.w(TAG, "Failed to start task. Could not instantiate class."); return GcmNetworkManager.RESULT_FAILURE; } final TaskParameters taskParams = BackgroundTaskSchedulerGcmNetworkManager.getTaskParametersFromTaskParams(params); final Waiter waiter = new Waiter(Waiter.MAX_TIMEOUT_SECONDS); final AtomicBoolean taskNeedsBackgroundProcessing = new AtomicBoolean(); ThreadUtils.runOnUiThreadBlocking(new Runnable() { @Override public void run() { taskNeedsBackgroundProcessing.set( backgroundTask.onStartTask(ContextUtils.getApplicationContext(), taskParams, new TaskFinishedCallbackGcmTaskService(waiter))); } }); if (!taskNeedsBackgroundProcessing.get()) return GcmNetworkManager.RESULT_SUCCESS; waiter.startWaiting(); if (waiter.isRescheduleNeeded()) return GcmNetworkManager.RESULT_RESCHEDULE; if (!waiter.hasTaskTimedOut()) return GcmNetworkManager.RESULT_SUCCESS; final AtomicBoolean taskNeedsRescheduling = new AtomicBoolean(); ThreadUtils.runOnUiThreadBlocking(new Runnable() { @Override public void run() { taskNeedsRescheduling.set(backgroundTask.onStopTask( ContextUtils.getApplicationContext(), taskParams)); } }); if (taskNeedsRescheduling.get()) return GcmNetworkManager.RESULT_RESCHEDULE; return GcmNetworkManager.RESULT_SUCCESS; }
static BackgroundTask getBackgroundTaskFromTaskParams(@NonNull TaskParams taskParams) { String backgroundTaskClassName = getBackgroundTaskClassFromTaskParams(taskParams); return BackgroundTaskScheduler.getBackgroundTaskFromClassName(backgroundTaskClassName); }
private static String getBackgroundTaskClassFromTaskParams(@NonNull TaskParams taskParams) { Bundle extras = taskParams.getExtras(); if (extras == null) return null; return extras.getString(BACKGROUND_TASK_CLASS_KEY); }
@Override public int onRunTask(TaskParams taskParams) { QBLoginChatCompositeCommand.start(this); return GcmNetworkManager.RESULT_SUCCESS; }