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

@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, "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
@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;
}

@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;
}

@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;
}