import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
    }
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;

}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
    }
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
    }
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
/**
 * 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();
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
    }
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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));
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@Override
public int onRunTask(TaskParams taskParams) {
    switch (taskParams.getTag()) {
        case MY_TASK:
            //task code...
            return GcmNetworkManager.RESULT_SUCCESS;
    }
    return GcmNetworkManager.RESULT_SUCCESS;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
@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;
}
 

import com.google.android.gms.gcm.TaskParams; //导入依赖的package包/类
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);
}