Java GooglePlayDriver类代码示例

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
public void init (FirebaseApp firebaseApp) {
	mFirebaseApp = firebaseApp;
	String token = getFirebaseMessagingToken();

	dispatcher =
	new FirebaseJobDispatcher(new GooglePlayDriver(activity.getApplicationContext()));
	dispatcher.cancel("firebase-notify-in-time-UID");

	Utils.d("Firebase Cloud messaging token: " + token);

	// Perform task here..!
	if (KeyValueStorage.getValue("notification_complete_task") != "0") {
		try {
			JSONObject obj =
			new JSONObject(KeyValueStorage.getValue("notification_task_data"));

			Dictionary data = new Dictionary();
			Iterator<String> iterator = obj.keys();

			while (iterator.hasNext()) {
				String key = iterator.next();
				Object value = obj.opt(key);

				if (value != null) {
					data.put(key, value);
				}
			}

			Utils.callScriptCallback(
			KeyValueStorage.getValue("notification_complete_task"),
			"Notification", "TaskComplete", data);

		} catch (JSONException e) {

		}

		KeyValueStorage.setValue("notification_complete_task", "0");
	}
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
private void setupCinemaListUpdates() {
    long lastUpdated = getSharedPreferences("settings", MODE_PRIVATE).getLong("cinemasUpdated", -1);
    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(this));

    if(lastUpdated < (System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7))) {
        // It's been more than a week since the last update, so setup/reset job because it should have run by now
        Job updateJob = dispatcher.newJobBuilder()
                .setService(CinemaUpdateJob.class)
                .setTag("cinemasListUpdate")
                .setRecurring(true)
                .setLifetime(Lifetime.FOREVER)
                .setTrigger(Trigger.executionWindow(0, (int) TimeUnit.DAYS.toSeconds(7)))
                .setReplaceCurrent(true)
                .build();
        dispatcher.mustSchedule(updateJob);
    }

    // Also run immediately if the list has never been updated
    if(lastUpdated == -1) {
        dispatcher.mustSchedule(CinemaUpdateJob.getJobToUpdateImmediately(dispatcher));
    }
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
synchronized public static void syncImmediately(Context context, String tag) {
    Timber.d("Scheduling a immediate sync");

    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver
            (context));

    Bundle bundle = new Bundle();
    Job myJob = dispatcher.newJobBuilder()
            .setService(QuoteJobService.class)
            .setTag(tag)
            .setExtras(bundle)
            .setRecurring(false)
            .setTrigger(Trigger.executionWindow(0, 0))
            .setLifetime(Lifetime.UNTIL_NEXT_BOOT)
            .setConstraints(Constraint.ON_ANY_NETWORK)
            .setRetryStrategy(RetryStrategy.DEFAULT_EXPONENTIAL)
            .setReplaceCurrent(true)
            .build();

    dispatcher.mustSchedule(myJob);

}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
@SuppressLint("ApplySharedPref")
private void onSetupComplete() {
    //download whole leaderboards data asynchronously
    new FetchLeaderBoardDataAsync(this).execute();

    //schedule daily sync at 3:00 am local time
    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(this));

    DateTime now = new DateTime();
    DateTime tomorrow = now.plusDays(1).withTimeAtStartOfDay().plusHours(3);
    int windowStart = Hours.hoursBetween(now, tomorrow).getHours() * 60 * 60;
    Job synJob = dispatcher.newJobBuilder()
            .setService(SyncScheduler.class)
            .setTag(Constants.PERIODIC_SYNC_SCHEDULE_KEY)
            .setReplaceCurrent(true)
            .setTrigger(Trigger.executionWindow(windowStart, windowStart + 10))
            .setConstraints(Constraint.ON_ANY_NETWORK)
            .setRetryStrategy(RetryStrategy.DEFAULT_LINEAR)
            .build();
    dispatcher.mustSchedule(synJob);

    sharedPreferences.edit().putBoolean(Constants.PREF_FIREBASE_SETUP, true).commit();
    startActivity(new Intent(this, PreChecksActivity.class));
    finish();
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
@WorkerThread
public static boolean sendSyncObjects(Context context, LinkedHashSet<SyncParam> syncParams) {
    if(!NetworkUtil.isConnected(context)){
        scheduleJob(context, SEND_SYNC_TAG);
        return false;
    }

    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(context));
    dispatcher.cancel(SEND_SYNC_TAG);

    if(syncParams == null){
        Log.e("SyncService", "erro ao enviar syncParamns: null");
        return false;
    }

    boolean result = true;
    for(SyncParam syncParam : syncParams){
        boolean sent = sendSyncObj(syncParam);
        if(result) result = sent;
    }

    return result;
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
static void scheduleFirebaseJobDispatcherSync(@NonNull final Context context) {

        Driver driver = new GooglePlayDriver(context);
        FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(driver);

        /* Create the Job to periodically sync Sunshine */
        Job syncSunshineJob = dispatcher.newJobBuilder()
                .setService(NewsFirebaseJobService.class)
                .setTag(NEWS_SYNC_TAG)
                .setConstraints(Constraint.ON_ANY_NETWORK)
                .setLifetime(Lifetime.FOREVER)
                .setRecurring(true)
                .setTrigger(Trigger.executionWindow(
                        REMINDER_INTERVAL_SECONDS,
                        REMINDER_INTERVAL_SECONDS + SYNC_FLEXTIME_SECONDS))
                .setReplaceCurrent(true)
                .build();

        dispatcher.schedule(syncSunshineJob);
    }
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
public static void scheduleJob(Context context, Message message) {

        try {
            Bundle bundle = new Bundle();
            FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(context));
            bundle.putString(MobiComKitConstants.AL_MESSAGE_KEY, message.getKeyString());
            Class pushNotificationJobServiceClass = Class.forName("com.applozic.mobicomkit.uiwidgets.notification.PushNotificationJobService");
            Job myJob = dispatcher.newJobBuilder()
                    .setService(pushNotificationJobServiceClass) // the JobService that will be called
                    .setTag(MobiComKitConstants.PUSH_NOTIFICATION_DISPATCHER)  // uniquely identifies the job
                    .setRecurring(false)
                    .setTrigger(Trigger.executionWindow(0, 0))
                    .setReplaceCurrent(true)
                    .setRetryStrategy(RetryStrategy.DEFAULT_LINEAR)
                    .setConstraints(Constraint.ON_ANY_NETWORK)
                    .setExtras(bundle)
                    .build();
            dispatcher.mustSchedule(myJob);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
@Override
public boolean onStartJob(JobParameters params) {
    Log.inform("Sync Job request received");
    dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(getBaseContext()));
    switch (params.getTag()) {
        case RESET_ALL_JOBS:
            resetAllJobs();
            break;
        case SYNC_PREFERENCES:
            syncPreferences();
            break;
        case SYNC_ROUTE_DATA:
            syncRouteData();
            break;
        case SINGLE_ROUTE_SYNC:
            syncRouteData();
            break;
    }
    return false;
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
void startRest(final Context context) {

        new ResetRoutes(new OnFinish() {
            @Override
            public void finished() {
                resetDone.postValue(true);
                FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(context));
                Job myJob = dispatcher.newJobBuilder()
                        .setService(SyncJobs.class)
                        .setReplaceCurrent(true)
                        .setTrigger(Trigger.executionWindow(0, 1))
                        .setTag(SyncJobs.SINGLE_ROUTE_SYNC)
                        .build();
                dispatcher.mustSchedule(myJob);
            }

            @Override
            public void allRoutes(List<RouteData> routeDataList) {

            }
        }).execute(context);

    }
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
private static void setup(@NonNull final Context context, final int timeInSeconds) {
    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(context));

    Job myJob = dispatcher.newJobBuilder()
            // the JobService that will be called
            .setService(DailyReminderService.class)
            // uniquely identifies the job
            .setTag(DailyReminderService.TAG)
            // one-off job
            .setRecurring(false)
            // persist past a device reboot (requires boot receiver permission)
            .setLifetime(Lifetime.FOREVER)
            // start between 0 and 60 seconds from now
            .setTrigger(Trigger.executionWindow(timeInSeconds, timeInSeconds + 30))
            // overwrite an existing job with the same tag
            .setReplaceCurrent(true)
            // retry with exponential backoff
            .setRetryStrategy(RetryStrategy.DEFAULT_EXPONENTIAL)
            //.setExtras(myExtrasBundle)
            .build();

    dispatcher.mustSchedule(myJob);
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
public static void schedulePeriodic(Context context, String tag, int period) {
    Timber.d("Scheduling a periodic sync every " + period + " seconds");

    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(context));

    Job myJob = dispatcher.newJobBuilder()
            .setService(QuoteJobService.class)
            .setTag(tag)
            .setRecurring(true)
            .setTrigger(Trigger.executionWindow(period, period))
            .setLifetime(Lifetime.UNTIL_NEXT_BOOT)
            .setConstraints(Constraint.ON_ANY_NETWORK)
            .setRetryStrategy(RetryStrategy.DEFAULT_EXPONENTIAL)
            .setReplaceCurrent(true)
            .build();

    dispatcher.mustSchedule(myJob);
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
public static void startSignInSocial(Context context, Bundle bundle){
    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(context));

    Job myJob = dispatcher.newJobBuilder()
            // the JobService that will be called
            .setService(SessionJobService.class)
            // uniquely identifies the job
            .setTag(SIGN_IN_SOCIAL_ACTION)
            // one-off job
            .setRecurring(false)
            // start between 0 and 60 seconds from now
            .setTrigger(Trigger.executionWindow(0, 60))
            // don't overwrite an existing job with the same tag
            .setReplaceCurrent(false)
            // constraints that need to be satisfied for the job to run
            .setConstraints(
                    // only run on an unmetered network
                    Constraint.ON_UNMETERED_NETWORK
            )
            .setExtras(bundle)
            .build();

    dispatcher.mustSchedule(myJob);
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
@Override
public boolean onStartJob(JobParameters job) {

    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(this));

    /* Schedule the job once now*/
    Job oneTimeJob = dispatcher.newJobBuilder()
            .setService(WakatimeDataSyncJob.class)
            .setTag("OneTimeJob")
            .setTrigger(Trigger.executionWindow(0, 60))
            .setRetryStrategy(RetryStrategy.DEFAULT_LINEAR)
            .build();
    dispatcher.mustSchedule(oneTimeJob);

    /* Schedule a recurring job everyday */
    Job synJob = dispatcher.newJobBuilder()
            .setService(WakatimeDataSyncJob.class)
            .setTag(Constants.WAKATIME_DATA_SYNC_JOB_TAG)
            .setReplaceCurrent(true)
            .setRecurring(true)
            .setTrigger(Trigger.executionWindow(Constants.SYNC_PERIOD, Constants.SYNC_TOLERANCE))
            .setConstraints(Constraint.ON_ANY_NETWORK)
            .setRetryStrategy(RetryStrategy.DEFAULT_LINEAR)
            .build();
    dispatcher.mustSchedule(synJob);
    return false;
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
@OnClick(R.id.logout)
public void onClickLogOut() {
    AuthUI.getInstance()
            .signOut(getActivity())
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                public void onComplete(@NonNull Task<Void> task) {
                    startActivity(new Intent(getContext(), LoginActivity.class));
                    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(new GooglePlayDriver(getContext()));
                    dispatcher.cancelAll();
                    Uri uri = TaskItemsContract.TaskItemsColumns.CONTENT_URI;
                    getActivity().getContentResolver().delete(uri, null, null);
                    getActivity().finish();
                }
            });
}
 

import com.firebase.jobdispatcher.GooglePlayDriver; //导入依赖的package包/类
synchronized public static void scheduleUpdateProgressReminder(@NonNull final Context context) {
    if (sInitialized) {
        return;
    }
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeInMillis(System.currentTimeMillis());
    calendar.set(Calendar.HOUR_OF_DAY, 23);
    calendar.set(Calendar.MINUTE, 59);
    calendar.set(Calendar.SECOND, 59);
    calendar.add(Calendar.MINUTE, 3);
    //could have done add(Calender.Date,1). I have trust issues
    Intent intentAlarm = new Intent(context, UpdateDayAlarmReciever.class);
    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), AlarmManager.INTERVAL_DAY, PendingIntent.getBroadcast(context, 1, intentAlarm, PendingIntent.FLAG_CANCEL_CURRENT));

    Driver driver = new GooglePlayDriver(context);
    FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(driver);

    Job constraintReminderJob = dispatcher.newJobBuilder()
            .setService(UpdateProgressFirebaseJobService.class)
            .setTag(UPDATE_PROGRESS_JOB_TAG)
            .setLifetime(Lifetime.FOREVER)
            .setRecurring(true)
            .setTrigger(Trigger.executionWindow(
                    0,
                    UPDATE_INTERVAL_SECONDS))
            .setReplaceCurrent(true)
            .setConstraints(Constraint.ON_ANY_NETWORK)
            .build();
    /* Schedule the Job with the dispatcher */
    dispatcher.schedule(constraintReminderJob);
    /* The job has been initialized */
    sInitialized = true;
}