Example #1
0
        private void RefreshJobs()
        {
            StopJobs();

            if (settings != null && settings.EnableAndroidNotification)
            {
                CreateAutoJobNotificationChannel();

                var jobServ = (JobScheduler)GetSystemService(JobSchedulerService);

                if (settings.AutoStopWifi.Count > 0 || settings.AutoStartCellur)
                {
                    JobInfo.Builder jobBuilder = new JobInfo.Builder(
                        TrojanPlusAutoJobService.JobId,
                        new ComponentName(this, Class.FromType(typeof(TrojanPlusAutoJobService)).Name));

                    jobBuilder.SetRequiredNetworkType(NetworkType.Any);
                    jobBuilder.SetBackoffCriteria(AutoJobServiceBackoffCriteria, BackoffPolicy.Linear);
                    jobBuilder.SetMinimumLatency(AutoJobServiceMinimumLatency);
                    jobBuilder.SetOverrideDeadline(AutoJobServiceMaxLatency);
                    jobBuilder.SetPersisted(true);

                    PersistableBundle bundle = new PersistableBundle();
                    bundle.PutString("settings", JsonConvert.SerializeObject(settings));

                    jobBuilder.SetExtras(bundle);
                    var succ = jobServ.Schedule(jobBuilder.Build());

                    Log.Debug(TAG, "RefreshJobs  TrojanPlusAutoJobService " + succ);
                }
            }
        }
Example #2
0
        private void ShowLater(NotificationRequest notificationRequest)
        {
            if (notificationRequest.NotifyTime.HasValue == false)
            {
                return;
            }

            var triggerTime = NotifyTimeInMilliseconds(notificationRequest.NotifyTime.Value);

            notificationRequest.NotifyTime = null;

            var serializedNotification = ObjectSerializer <NotificationRequest> .SerializeObject(notificationRequest);

            var javaClass = Java.Lang.Class.FromType(typeof(ScheduledNotificationJobService));
            var component = new ComponentName(Application.Context, javaClass);

            // Bundle up parameters
            var extras = new PersistableBundle();

            extras.PutString(NotificationCenter.ExtraReturnNotification, serializedNotification);

            triggerTime -= NotifyTimeInMilliseconds(DateTime.Now);

            var builder = new JobInfo.Builder(notificationRequest.NotificationId, component);

            builder.SetMinimumLatency(triggerTime);          // Fire at TriggerTime
            builder.SetOverrideDeadline(triggerTime + 5000); // Or at least 5 Seconds Later
            builder.SetExtras(extras);
            builder.SetPersisted(CheckBootPermission());     //Job will be recreated after Reboot if Permissions are granted

            var jobInfo = builder.Build();

            _jobScheduler.Schedule(jobInfo);
        }
Example #3
0
        public override void OnUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds)
        {
            System.Diagnostics.Debug.WriteLine("Widget OnUpdate");
            var me = new ComponentName(context, Java.Lang.Class.FromType(typeof(AppWidget)).Name);

            appWidgetManager.UpdateAppWidget(me, BuildRemoteViews(context, appWidgetIds));

            var scheduler = context.GetSystemService(Context.JobSchedulerService) as JobScheduler;

            var jobName = new ComponentName(context, Java.Lang.Class.FromType(typeof(WidgetJobService)).Name);
            var jobInfo = new JobInfo.Builder(1, jobName);

            jobInfo.SetBackoffCriteria(5000, BackoffPolicy.Linear);
            jobInfo.SetPersisted(true);
            jobInfo.SetPeriodic(900000);
            jobInfo.SetRequiredNetworkType(NetworkType.Any);
            jobInfo.SetRequiresCharging(false);

            var bundle = new PersistableBundle();

            bundle.PutIntArray(WIDGET_BUNDLE, appWidgetIds);

            jobInfo.SetExtras(bundle);

            var job = jobInfo.Build();

            scheduler.Schedule(job);
        }
Example #4
0
        public static void StartJob(Context context)
        {
            try
            {
                int jobId = 8;
                Log.Error(TAG, "startJob");

                JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(Context.JobSchedulerService);

                var componentName = new ComponentName(context, Java.Lang.Class.FromType(typeof(WorkJobService)));

                var builder = new JobInfo.Builder(jobId, componentName).SetPersisted(true);

                // 小于7.0
                if (Build.VERSION.SdkInt < BuildVersionCodes.N)
                {
                    Log.Error(TAG, "每隔 1s 执行一次 job");
                    builder.SetPeriodic(1000);
                }
                else
                {
                    // 延迟执行任务
                    builder.SetMinimumLatency(1000);
                }

                int resultCode = jobScheduler.Schedule(builder.Build());
            }
            catch (Exception ex)
            {
                Log.Error(TAG, ex.Message);
            }
        }
Example #5
0
            public static void Enqueue(
                Context context,
                JobSetting jobSetting
                )
            {
                JobInfo.Builder jobInfoBuilder = new JobInfo.Builder(
                    JOB_ID,
                    new ComponentName(context, Java.Lang.Class.FromType(typeof(ExposureNotDetectedJob))))
                                                 .SetOverrideDeadline(0);

                if (jobSetting != null)
                {
                    jobSetting.Apply(jobInfoBuilder);
                }

                JobInfo jobInfo = jobInfoBuilder.Build();

                JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(JobSchedulerService);
                int          result       = jobScheduler.Schedule(jobInfo);

                if (result == JobScheduler.ResultSuccess)
                {
                    Logger.D("ExposureNotDetectedJob scheduled");
                }
                else if (result == JobScheduler.ResultFailure)
                {
                    Logger.D("ExposureNotDetectedJob schedule failed");
                }
            }
        private void RunDuringNextWindowIfNotAlreadyScheduled(Context context, Intent intent)
        {
            JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(Context.JobSchedulerService);

            // don't queue another job if there's already one in the pending job queue
            if (jobScheduler.AllPendingJobs.Any(x => x.Id == RUN_DURING_NEXT_WINDOW))
            {
                Log.Info(TAG, "Another device location update job will not be scheduled because an existing job was found in the queue.");

                return;
            }

            var job = new JobInfo.Builder(RUN_DURING_NEXT_WINDOW, new ComponentName(context, Java.Lang.Class.FromType(typeof(UpdateDeviceLocationJobService))));

            var oneMinute   = 1 * 60 * 1000;
            var twoMinutes  = 2 * 60 * 1000;
            var fiveMinutes = 5 * 60 * 1000;

            job.SetMinimumLatency(oneMinute);            // Specify that this job should be delayed by the provided amount of time (in milliseconds)
            job.SetTriggerContentMaxDelay(twoMinutes);   // Set the maximum total delay (in milliseconds) that is allowed
            //job.SetPeriodic(fiveMinutes);              // Specify that this job should recur with the provided interval, not more than once per period.
            //job.SetPersisted(true);

            var result = jobScheduler.Schedule(job.Build());

            LogScheduleResult(result);
        }
        public override void OnMessageReceived(RemoteMessage message)
        {
            var dependencyContainer = AndroidDependencyContainer.Instance;
            var userIsLoggedIn      = dependencyContainer.UserAccessManager.CheckIfLoggedIn();

            if (!userIsLoggedIn)
            {
                return;
            }

            var keyValueStorage = dependencyContainer.KeyValueStorage;

            if (!shouldScheduleSyncJob(keyValueStorage))
            {
                return;
            }

            var jobClass       = Java.Lang.Class.FromType(typeof(SyncJobService));
            var jobScheduler   = (JobScheduler)GetSystemService(JobSchedulerService);
            var serviceName    = new ComponentName(this, jobClass);
            var jobInfoBuilder = new JobInfo.Builder(SyncJobServiceJobId, serviceName)
                                 .SetRequiredNetworkType(NetworkType.Any);

            if (PieApis.AreAvailable)
            {
                jobInfoBuilder = jobInfoBuilder.SetImportantWhileForeground(true);
            }

            jobScheduler.Schedule(jobInfoBuilder.Build());
            keyValueStorage.SetBool(HasPendingSyncJobServiceScheduledKey, true);
            keyValueStorage.SetDateTimeOffset(LastSyncJobScheduledAtKey, DateTimeOffset.Now);
        }
        private void ScheduleSyncJob(long accountId)
        {
            // JobScheduler was added in API 21
            if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop)
            {
                return;
            }

            var extras = new PersistableBundle();

            extras.PutLong("AccountId", accountId);

            var builder = new JobInfo.Builder(unchecked ((int)accountId), new ComponentName(this, Java.Lang.Class.FromType(typeof(MySyncService))))
                          .SetRequiredNetworkType(NetworkType.Any)
                          .SetExtras(extras);

            if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
            {
                builder.SetRequiresBatteryNotLow(true);
            }

            var jobScheduler = (JobScheduler)this.GetSystemService(Context.JobSchedulerService);

            jobScheduler.Schedule(builder.Build());
        }
        public void StartPeriodicBackgroundWorkUsingJobScheduler()
        {
            Java.Lang.Class javaClass = Java.Lang.Class.FromType(typeof(GetBitcoinPriceJob));
            ComponentName   component = new ComponentName(Application.Context, javaClass);

            int jobId = 2300;

            JobInfo.Builder builder = new JobInfo.Builder(jobId, component)
                                      .SetPeriodic(1000 * 10)                   // start after every 10 seconds
                                      .SetPersisted(true)                       // job will work after device reboot
                                      .SetRequiredNetworkType(NetworkType.Any); // and require internet connection of any type
            JobInfo jobInfo = builder.Build();

            JobScheduler jobScheduler = (JobScheduler)Application.Context.GetSystemService(Context.JobSchedulerService);
            int          result       = jobScheduler.Schedule(jobInfo);

            using (var handler = new Handler(Looper.MainLooper))
            {
                if (result == JobScheduler.ResultSuccess)
                {
                    Toast.MakeText(Application.Context, "job succesfully scheduled", ToastLength.Short);
                    // The job was scheduled.
                }
                else
                {
                    Toast.MakeText(Application.Context, "job failed to schedule", ToastLength.Short);
                }
            }
        }
Example #10
0
        /// <summary>
        ///     Schedules the task for execution.
        /// </summary>
        public void ScheduleTask(int interval)
        {
            if (!Mvx.IoCProvider.CanResolve <ISettingsManager>())
            {
                return;
            }

            if (!Mvx.IoCProvider.Resolve <ISettingsManager>().IsBackupAutouploadEnabled)
            {
                return;
            }

            var builder = new JobInfo.Builder(SYNC_BACK_JOB_ID,
                                              new ComponentName(
                                                  this, Java.Lang.Class.FromType(typeof(SyncBackupJob))));

            // convert hours into millisecond
            builder.SetPeriodic(60 * 60 * 1000 * interval);
            builder.SetPersisted(true);
            builder.SetRequiredNetworkType(NetworkType.NotRoaming);
            builder.SetRequiresDeviceIdle(false);
            builder.SetRequiresCharging(false);

            var tm     = (JobSchedulerType)GetSystemService(JobSchedulerService);
            var status = tm.Schedule(builder.Build());
        }
Example #11
0
        public void ScheduleJob(View v)
        {
            JobInfo.Builder builder = new JobInfo.Builder(102, new ComponentName(this, Java.Lang.Class.FromType(typeof(JobScedulerSample))));
            builder.SetPersisted(true);
            builder.SetPeriodic(5000);
            builder.SetRequiredNetworkType(NetworkType.Unmetered);
            builder.SetRequiresCharging(false);
            builder.SetRequiresDeviceIdle(false);

            try
            {
                int test = Job_s.Schedule(builder.Build());
                if (test == JobScheduler.ResultSuccess)
                {
                    Console.WriteLine("Job is working");
                }
                else
                {
                    Console.WriteLine("Job is not working");
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
Example #12
0
            public static void Enqueue(
                Context context, string token,
                JobSetting jobSetting
                )
            {
                PersistableBundle bundle = new PersistableBundle();

                bundle.PutString(EXTRA_TOKEN, token);

                JobInfo.Builder jobInfoBuilder = new JobInfo.Builder(
                    JOB_ID,
                    new ComponentName(context, Java.Lang.Class.FromType(typeof(ExposureDetectedV1Job))))
                                                 .SetExtras(bundle)
                                                 .SetOverrideDeadline(0);

                if (jobSetting != null)
                {
                    jobSetting.Apply(jobInfoBuilder);
                }

                JobInfo jobInfo = jobInfoBuilder.Build();

                JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(JobSchedulerService);
                int          result       = jobScheduler.Schedule(jobInfo);

                if (result == JobScheduler.ResultSuccess)
                {
                    Logger.D("ExposureDetectedV1Job scheduled");
                }
                else if (result == JobScheduler.ResultFailure)
                {
                    Logger.D("ExposureDetectedV1Job schedule failed");
                }
            }
Example #13
0
        public override void OnReceive(Context context, Intent intent)
        {
            if (intent.Action.Equals(Telephony.Sms.Intents.SmsReceivedAction))
            {
                SmsMessage[]          messages    = Telephony.Sms.Intents.GetMessagesFromIntent(intent);
                IEnumerable <SmsData> smsDataList = ExtractMessages(messages);

                Intent mailIntent = new Intent(context, typeof(MailPushService));
                string json       = JsonConvert.SerializeObject(smsDataList);

                mailIntent.PutExtra("object", json);
                context.StartService(mailIntent);

                JobInfo.Builder builder = new JobInfo.Builder(TextPersistenceService.GetNewJobId(),
                                                              new ComponentName(context, Java.Lang.Class.FromType(typeof(TextPersistenceService))));
                PersistableBundle bundle = new PersistableBundle();

                bundle.PutString("object", json);

                builder.SetExtras(bundle);
                builder.SetMinimumLatency(500);
                builder.SetOverrideDeadline(1000);

                JobInfo jobInfo = builder.Build();

                JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(Context.JobSchedulerService);
                jobScheduler.Schedule(jobInfo);
            }
        }
        private void ShowLater(LocalNotification localNotification)
        {
            if (localNotification.NotifyTime.HasValue == false)
            {
                return;
            }

            var triggerTime = NotifyTimeInMilliseconds(localNotification.NotifyTime.Value);

            localNotification.NotifyTime = null;

            var serializedNotification = ObjectSerializer <LocalNotification> .SerializeObject(localNotification);

            var scheduled = false;

            if (Build.VERSION.SdkInt >= BuildVersionCodes.Lollipop)
            {
                var javaClass = Java.Lang.Class.FromType(typeof(ScheduledNotificationJobService));
                var component = new ComponentName(Application.Context, javaClass);

                // Bundle up parameters
                var extras = new PersistableBundle();
                extras.PutString(ExtraReturnNotification, serializedNotification);

                triggerTime -= NotifyTimeInMilliseconds(DateTime.Now);

                var builder = new JobInfo.Builder(localNotification.NotificationId, component);
                builder.SetMinimumLatency(triggerTime);          // Fire at TriggerTime
                builder.SetOverrideDeadline(triggerTime + 5000); // Or at least 5 Seconds Later
                builder.SetExtras(extras);
                builder.SetPersisted(CheckBootPermission());     //Job will be recreated after Reboot if Permissions are granted

                var jobInfo = builder.Build();
                var result  = _jobScheduler.Schedule(jobInfo);
                scheduled = result == JobScheduler.ResultSuccess;
            }

            if (scheduled)
            {
                return;
            }
            // The job was not scheduled. So use the old implementation
            var notificationIntent = new Intent(Application.Context, typeof(ScheduledNotificationReceiver));

            notificationIntent.SetAction("LocalNotifierIntent" + localNotification.NotificationId);
            notificationIntent.PutExtra(ExtraReturnNotification, serializedNotification);

            var pendingIntent = PendingIntent.GetBroadcast(Application.Context, 0, notificationIntent,
                                                           PendingIntentFlags.CancelCurrent);

            _alarmManager.Set(AlarmType.RtcWakeup, triggerTime, pendingIntent);
        }
Example #15
0
        public static JobInfo CreateBackgroundSyncJobInfo(this Context context, long periodicity)
        {
            var javaClass = JavaUtils.ToClass <BackgroundSyncJobSchedulerService>();
            var component = new ComponentName(context, javaClass);

            var builder = new JobInfo.Builder(JobServicesConstants.BackgroundSyncJobServiceJobId, component)
                          .SetRequiredNetworkType(NetworkType.Any)
                          .SetPeriodic(periodicity)
                          .SetPersisted(true);

            var jobInfo = builder.Build();

            return(jobInfo);
        }
        public static JobInfo CreateBackgroundSyncJobInfo(this Context context, long periodicity)
        {
            var javaClass = Java.Lang.Class.FromType(typeof(BackgroundSyncJobSchedulerService));
            var component = new ComponentName(context, javaClass);

            var builder = new JobInfo.Builder(BackgroundSyncJobSchedulerService.JobId, component)
                          .SetRequiredNetworkType(NetworkType.Any)
                          .SetPeriodic(periodicity)
                          .SetPersisted(true);

            var jobInfo = builder.Build();

            return(jobInfo);
        }
Example #17
0
        /// <summary>
        ///     Schedules the task for execution.
        /// </summary>
        public void ScheduleTask()
        {
            var builder = new JobInfo.Builder(CLEAR_PAYMENT_JOB_ID,
                                              new ComponentName(
                                                  this, Java.Lang.Class.FromType(typeof(ClearPaymentsJob))));
            // Execute all 60 Minutes
            builder.SetPeriodic(60 * 60 * 1000);
            builder.SetPersisted(true);
            builder.SetRequiredNetworkType(NetworkType.None);
            builder.SetRequiresDeviceIdle(false);
            builder.SetRequiresCharging(false);

            var tm = (JobSchedulerType)GetSystemService(JobSchedulerService);
            tm.Schedule(builder.Build());
        }
        public void SchedulePeriodicWork()
        {
            JobScheduler jobScheduler = (JobScheduler)Xamarin.Forms.Forms.Context.GetSystemService(Context.JobSchedulerService);
            var          jobBuilder   = new JobInfo.Builder(JobId, new ComponentName(Xamarin.Forms.Forms.Context, Java.Lang.Class.FromType(typeof(ExampleJobService))));

            jobBuilder.SetPeriodic(TimeSpan.FromMinutes(3).Milliseconds);
            jobBuilder.SetOverrideDeadline(TimeSpan.FromMinutes(1).Milliseconds);
            jobBuilder.SetMinimumLatency(TimeSpan.FromMinutes(1).Milliseconds);
            jobBuilder.SetTriggerContentMaxDelay(TimeSpan.FromMinutes(1).Milliseconds);

            var job    = jobBuilder.Build();
            var result = jobScheduler.Schedule(job);

            MessagingCenter.Send <XamarinBGServ.App, string>(Xamarin.Forms.Application.Current as XamarinBGServ.App,
                                                             Messages.ConsoleMessage, result == JobScheduler.ResultSuccess ? "Job scheduled" : "Job scheduling failed");
        }
Example #19
0
        /* UI onclick listener to schedule a job.What this job is is defined in
         * TestJobService#scheduleJob().
         */

        public void ScheduleJob()
        {
            var builder = new JobInfo.Builder(kJobId++, serviceComponent);


            //builder.SetMinimumLatency(periodInMins * 60 * 1000);
            builder.SetPeriodic((long)periodInMins * 60 * 1000);
            //builder.SetPersisted(true);
            //The service can wait up to an aditional 30 seconds before it must execute


            builder.SetRequiresDeviceIdle(false);
            builder.SetRequiresCharging(false);
            notificationService = new LocalNotificationJobService(mainContext);
            notificationService.ScheduleJob(builder.Build());
        }
        public void ScheduleTask()
        {
            var builder = new JobInfo.Builder(RECURRING_PAYMENT_JOB_ID,
                                              new ComponentName(
                                                  this, Java.Lang.Class.FromType(typeof(SyncBackupJob))));

            // Execute all 30 Minutes
            builder.SetPeriodic(30 * 60 * 1000);
            builder.SetPersisted(true);
            builder.SetRequiredNetworkType(NetworkType.None);
            builder.SetRequiresDeviceIdle(false);
            builder.SetRequiresCharging(false);

            var tm     = (JobSchedulerType)GetSystemService(Context.JobSchedulerService);
            var status = tm.Schedule(builder.Build());
        }
Example #21
0
        public void ScheduleJob()
        {
            try{
                Intent intent      = new Intent();
                String packageName = Application.Context.PackageName;

                PowerManager pm = (PowerManager)Application.Context.GetSystemService(Context.PowerService);
                if (pm.IsIgnoringBatteryOptimizations(packageName))
                {
                    intent.SetAction(Android.Provider.Settings.ActionIgnoreBatteryOptimizationSettings);
                }
                else
                {
                    intent.SetAction(Android.Provider.Settings.ActionRequestIgnoreBatteryOptimizations);
                    intent.SetData(Android.Net.Uri.Parse("package:" + packageName));
                }

                intent.AddFlags(ActivityFlags.NewTask);

                Application.Context.StartActivity(intent);
            }
            catch (Exception ex) {
                Console.WriteLine(ex);
            }

            var tm   = (JobSchedulerType)GetSystemService(Context.JobSchedulerService);
            var jobs = tm.AllPendingJobs;

            tm.CancelAll();

            JobInfo.Builder builder = this.CreateJobInfoBuilder()
                                      .SetPersisted(true)
                                      .SetRequiresDeviceIdle(false)
                                      .SetPeriodic(Config.UpdateTimeInterval * 60000)
                                      .SetRequiredNetworkType(NetworkType.Any);

            int result = jobScheduler.Schedule(builder.Build());

            if (result == JobScheduler.ResultSuccess)
            {
                Log.Debug(TAG, "Job started!");
            }
            else
            {
                Log.Warn(TAG, "Problem starting the job " + result);
            }
        }
        // todo p238-239 schedule location job service
        public void StartTracking()
        {
            var javaClass     = Java.Lang.Class.FromType(typeof(LocationJobService));
            var componentName = new ComponentName(Application.Context, javaClass);
            var jobBuilder    = new JobInfo.Builder(1, componentName);

            jobBuilder.SetOverrideDeadline(1000);
            jobBuilder.SetPersisted(true);
            jobBuilder.SetRequiresDeviceIdle(false);
            jobBuilder.SetRequiresBatteryNotLow(true);

            var jobInfo = jobBuilder.Build();

            var jobScheduler = (JobScheduler)Application.Context.GetSystemService(Context.JobSchedulerService);

            jobScheduler.Schedule(jobInfo);
        }
Example #23
0
        /// <summary>
        ///     Schedules the task for execution.
        /// </summary>
        public void ScheduleTask()
        {
            var builder = new JobInfo.Builder(RECURRING_PAYMENT_JOB_ID,
                                              new ComponentName(
                                                  this, Class.FromType(typeof(RecurringPaymentJob))));

            // Execute all 60 Minutes
            builder.SetPeriodic(JOB_INTERVAL);
            builder.SetPersisted(true);
            builder.SetRequiredNetworkType(NetworkType.None);
            builder.SetRequiresDeviceIdle(false);
            builder.SetRequiresCharging(false);

            var tm = (JobSchedulerType)GetSystemService(JobSchedulerService);

            tm.Schedule(builder.Build());
        }
Example #24
0
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
            SetContentView(Resource.Layout.Main);
            Button b = FindViewById <Button>(Resource.Id.button);

            b.Click += delegate
            {
                ComponentName   cn      = new ComponentName(this, Class.FromType(typeof(MyJobService)));
                JobInfo.Builder builder = new JobInfo.Builder(123, cn);

                long millis = 5 * 60 * 1000;
                builder.SetPeriodic(millis);

                JobScheduler js = (JobScheduler)GetSystemService(Context.JobSchedulerService);
                js.Schedule(builder.Build());
            };
        }
        public void StartJob()
        {
            try
            {
                //Supports After APi level 21 only
                if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop)
                {
                    return;
                }

                ComponentName serviceComponent = new ComponentName(ActivtyContext, Java.Lang.Class.FromType(typeof(DataLoaderJobService)));

                if (Build.VERSION.SdkInt >= BuildVersionCodes.N)
                {
                    Jobbuilder = new JobInfo.Builder(Jobid, serviceComponent);
                    Jobbuilder.SetMinimumLatency(4000);
                    Jobbuilder.SetRequiredNetworkType(NetworkType.Any);
                    Jobbuilder.SetRequiresCharging(false);
                    Jobbuilder.SetOverrideDeadline(4000);
                    Jobbuilder.SetBackoffCriteria(3000, BackoffPolicy.Linear);
                    Jobbuilder.SetPersisted(true);
                }
                else
                {
                    Jobbuilder = new JobInfo.Builder(Jobid, serviceComponent);
                    Jobbuilder.SetPeriodic(2000);
                    Jobbuilder.SetPersisted(true);
                    Jobbuilder.SetRequiredNetworkType(NetworkType.Any);
                    Jobbuilder.SetRequiresCharging(false);
                }

                Jobscheduler = (JobScheduler)ActivtyContext.GetSystemService(Context.JobSchedulerService);
                int result = Jobscheduler.Schedule(Jobbuilder.Build());
                if (result == JobScheduler.ResultSuccess)
                {
                }
            }
            catch (Exception e)
            {
                Crashes.TrackError(e);
            }
        }
        private void StartService()
        {
            if (mJobScheduler != null)
            {
                // Thread.CurrentThread.CurrentCulture = new CultureInfo("bg-BG");
                CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("bg-BG");

                mJobScheduler = (JobScheduler)GetSystemService(Context.JobSchedulerService);
                JobScheduler  = new ComponentName(this, Java.Lang.Class.FromType(typeof(MyJobService)));

                JobInfo.Builder builder = new JobInfo.Builder(kJobId++, JobScheduler);

                builder.SetRequiredNetworkType(NetworkType.Any);
                builder.SetPeriodic(3600000); // 2400000  40 min, 7200000,  ////////////3600000
                // builder.SetPeriodic(900000); // 2400000  40 min,                  // 1500    20 000 - 2s  // 25 min
                builder.SetPersisted(true);

                mJobScheduler.Schedule(builder.Build());
            }
        }
        private void Weatherupdatefrequency_ItemSelected(object sender, AdapterView.ItemSelectedEventArgs e)
        {
            long interval_minutes = int.Parse(Resources.GetStringArray(Resource.Array.listvaluesweatherupdatefrequency)[e.Position]);

            JobInfo.Builder jobBuilder = new JobInfo.Builder(56114281, new ComponentName(Application.Context, Java.Lang.Class.FromType(typeof(GrabWeatherJob))));
            jobBuilder.SetPersisted(true);
            jobBuilder.SetPeriodic(1000 * 60 * interval_minutes);
            jobBuilder.SetRequiredNetworkType(Android.App.Job.NetworkType.Unmetered);
            JobScheduler jobScheduler = (JobScheduler)Application.Context.GetSystemService(Context.JobSchedulerService);
            int          result       = jobScheduler.Schedule(jobBuilder.Build());

            if (result == JobScheduler.ResultSuccess)
            {
                Log.Info("LiveDisplay", "Job Result Sucess");
            }
            else
            {
                Log.Info("LiveDisplay", "Job Result Not Sucess");
            }
        }
Example #28
0
        public static void StartJob(Context context)
        {
            Log.Error(TAG, "startJob");
            JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(Context.JobSchedulerService);

            JobInfo.Builder builder = new JobInfo.Builder(8, new ComponentName(context.PackageName,
                                                                               typeof(WorkJobService).Name)).SetPersisted(true);

            // 小于7.0
            if (Build.VERSION.SdkInt < BuildVersionCodes.N)
            {
                builder.SetPeriodic(1000);
            }
            else
            {
                builder.SetMinimumLatency(1000);
            }

            jobScheduler.Schedule(builder.Build());
        }
Example #29
0
        public static void ScheduleJob(Context context)
        {
            ComponentName serviceComponent = new ComponentName(context, Java.Lang.Class.FromType(typeof(WorkerService)));

            JobInfo.Builder builder = new JobInfo.Builder(0, serviceComponent)
                                      .SetPersisted(true)
                                      .SetPeriodic(AlarmManager.IntervalDay);                      //A day. //Configurable?
            JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(Context.JobSchedulerService);
            JobInfo      jobInfo      = builder.Build();
            int          result       = jobScheduler.Schedule(jobInfo);

            if (result == JobScheduler.ResultSuccess)
            {
                Log.Info("Astropix", "Job Result Sucess");
            }
            else
            {
                Log.Info("Astropix", "Job Result Not Sucess");
            }
        }
        private void RunImmediately(Context context, Intent intent)
        {
            JobScheduler jobScheduler = (JobScheduler)context.GetSystemService(Context.JobSchedulerService);

            // don't queue another job if there's already one in the pending pjob queue
            if (jobScheduler.AllPendingJobs.Any(x => x.Id == RUN_IMMEDIATELY))
            {
                Log.Info(TAG, "Another device location update job will not run because an existing job was found in the queue.");

                return;
            }

            var job = new JobInfo.Builder(RUN_IMMEDIATELY, new ComponentName(context, Java.Lang.Class.FromType(typeof(UpdateDeviceLocationJobService))));

            job.SetMinimumLatency(100);
            job.SetTriggerContentMaxDelay(1000);

            var result = jobScheduler.Schedule(job.Build());

            LogScheduleResult(result);
        }
Example #31
0
		public void ScheduleJob (View v)
		{
			if (!EnsureTestService ()) {
				return;
			}
			var builder = new JobInfo.Builder (kJobId++, serviceComponent);

			var delay = delayEditText.Text;
			if (delay != null && !TextUtils.IsEmpty (delay)) {
				builder.SetMinimumLatency (long.Parse (delay) * 1000);
			}
			var deadline = deadlineEditText.Text;
			if (deadline != null && !TextUtils.IsEmpty (deadline)) {
				builder.SetOverrideDeadline (long.Parse (deadline) * 1000);
			}
			bool requiresUnmetered = wiFiConnectivityRadioButton.Checked;
			bool requiresAnyConnectivity = anyConnectivityRadioButton.Checked;
			if (requiresUnmetered) {
				builder.SetRequiredNetworkCapabilities (NetworkTypeValue.Unmetered);
			} else if (requiresAnyConnectivity) {
				builder.SetRequiredNetworkCapabilities (NetworkTypeValue.Any);
			}
			builder.SetRequiresDeviceIdle (requiresIdleCheckbox.Checked);
			builder.SetRequiresCharging (requiresChargingCheckBox.Checked);

			testService.ScheduleJob (builder.Build ());
		}