Sdílet prostřednictvím

Dispečer úloh Firebase

  • Článek

Tento průvodce popisuje, jak naplánovat práci na pozadí pomocí knihovny Dispečer úloh Firebase od Googlu.

Přehled

Jedním z nejlepších způsobů, jak zajistit, aby aplikace pro Android reagovala na uživatele, je zajistit, aby se složitá nebo dlouhotrvající práce prováděla na pozadí. Je však důležité, aby práce na pozadí nezáporně ovlivnila zkušenosti uživatele se zařízením.

Úloha na pozadí se například může dotazovat na web každých tři nebo čtyři minuty a dotazovat se na změny konkrétní datové sady. Zdá se to neškodné, ale mělo by katastrofální dopad na životnost baterie. Aplikace bude zařízení opakovaně probudit, zvýšit výkon procesoru na vyšší stav napájení, zapnout rádia, nastavovat síťové požadavky a pak zpracovávat výsledky. Je to horší, protože zařízení nebude okamžitě vypnout a vrátit se do stavu nečinnosti s nízkým výkonem. Špatně naplánovaná práce na pozadí může neúmyslně udržovat zařízení ve stavu s zbytečnými a nadměrnými požadavky na napájení. Tato zdánlivě nevinná aktivita (dotazování webu) vykreslí zařízení nepoužitelné v relativně krátkém časovém období.

Android poskytuje následující rozhraní API, která pomáhají s prováděním práce na pozadí, ale samy o sobě nejsou dostatečné pro inteligentní plánování úloh.

  • Služby záměru – Služby záměru jsou skvělé pro provádění práce, ale neposkytují žádný způsob plánování práce.
  • AlarmManager – Tato rozhraní API umožňují plánovat pouze práci, ale neposkytují žádný způsob, jak tuto práci skutečně provést. AlarmManager také umožňuje omezení založená na čase, což znamená vyvolání alarmu v určitém čase nebo po uplynutí určitého časového období.
  • JobScheduler – JobSchedule je skvělé rozhraní API, které pracuje s operačním systémem pro plánování úloh. Je však k dispozici pouze pro aplikace pro Android, které cílí na úroveň rozhraní API 21 nebo vyšší.
  • Přijímače všesměrového vysílání – Aplikace pro Android může nastavit přijímače vysílání tak, aby fungovaly v reakci na systémové události nebo záměry. Přijímače všesměrového vysílání ale neposkytují žádnou kontrolu nad tím, kdy se má úloha spustit. Změny v operačním systému Android budou také omezeny, když budou příjemci vysílání fungovat, nebo druhy práce, na které můžou reagovat.

Existují dvě klíčové funkce pro efektivní provádění práce na pozadí (někdy označované jako úloha na pozadí nebo úloha):

  1. Inteligentní plánování práce – Je důležité, aby když aplikace pracuje na pozadí, že to dělá jako dobrý občan. V ideálním případě by aplikace neměla požadovat spuštění úlohy. Místo toho by aplikace měla zadat podmínky, které musí být splněny pro dobu, kdy může úloha běžet, a pak naplánovat, aby se tato práce spustila, když jsou splněny podmínky. Díky tomu může Android inteligentně provádět práci. Například síťové požadavky se můžou dávkově spouštět najednou, aby se maximálně využily režijní náklady spojené se sítěmi.
  2. Zapouzdření práce – kód pro provedení práce na pozadí by měl být zapouzdřen v samostatné komponentě, která může být spuštěna nezávisle na uživatelském rozhraní a bude relativně snadné přeplánovat, pokud se práce z nějakého důvodu nedokončí.

Dispečer úloh Firebase je knihovna od Googlu, která poskytuje plynulé rozhraní API pro zjednodušení plánování práce na pozadí. Jejím účelem je nahradit Google Cloud Manager. Dispečer úloh Firebase se skládá z následujících rozhraní API:

  • A Firebase.JobDispatcher.JobService je abstraktní třída, která se musí rozšířit pomocí logiky, která se spustí v úloze na pozadí.
  • Deklaruje Firebase.JobDispatcher.JobTrigger , kdy má být úloha spuštěna. Obvykle se vyjadřuje jako časové období, například počkejte alespoň 30 sekund před spuštěním úlohy, ale spusťte úlohu do 5 minut.
  • Obsahuje Firebase.JobDispatcher.RetryStrategy informace o tom, co se má udělat, když se úloha nespustí správně. Strategie opakování určuje, jak dlouho se má čekat, než se pokusíte úlohu spustit znovu.
  • Jedná Firebase.JobDispatcher.Constraint se o volitelnou hodnotu, která popisuje podmínku, která musí být splněna před spuštěním úlohy, jako je například zařízení v neměřené síti nebo nabíjení.
  • Jedná se Firebase.JobDispatcher.Job o rozhraní API, které sjednocuje předchozí rozhraní API s jednotkou práce, kterou může naplánovat JobDispatcher. Třída Job.Builder se používá k vytvoření instance Job.
  • Pomocí Firebase.JobDispatcher.JobDispatcher předchozích tří rozhraní API naplánujete práci s operačním systémem a v případě potřeby zajistíte způsob zrušení úloh.

Chcete-li naplánovat práci s dispečerem úloh Firebase, musí aplikace Xamarin.Android zapouzdřit kód v typu, který rozšiřuje JobService třídu. JobService má tři metody životního cyklu, které lze volat během životnosti úlohy:

  • bool OnStartJob(IJobParameters parameters) – Tato metoda je místo, kde dojde k práci a měla by být vždy implementována. Běží na hlavním vlákně. Tato metoda se vrátí true , pokud zbývá práce nebo false pokud je práce dokončena.
  • bool OnStopJob(IJobParameters parameters) – Volá se, když je úloha zastavena z nějakého důvodu. Měla by se vrátit true , pokud by se úloha měla později přeplánovat.
  • JobFinished(IJobParameters parameters, bool needsReschedule) – Tato metoda je volána po JobService dokončení jakékoli asynchronní práce.

Pokud chcete naplánovat úlohu, aplikace vytvoří instanci objektu JobDispatcher . Job.Builder Pak se použije k vytvoření objektuJob, který se poskytneJobDispatcher, který se pokusí spustit úlohu.

Tento průvodce popisuje, jak přidat dispečer úloh Firebase do aplikace Xamarin.Android a použít ho k naplánování práce na pozadí.

Požadavky

Dispečer úloh Firebase vyžaduje rozhraní API androidu úrovně 9 nebo vyšší. Knihovna dispečerů úloh Firebase spoléhá na některé komponenty poskytované službami Google Play; zařízení musí mít nainstalované služby Google Play.

Použití knihovny Dispečer úloh Firebase v Xamarin.Androidu

Pokud chcete začít s dispečerem úloh Firebase, nejprve do projektu Xamarin.Android přidejte balíček NuGet Xamarin.Firebase.JobDispatcher. Vyhledejte v Správce balíčků NuGet balíček Xamarin.Firebase.JobDispatcher (který je stále v předběžné verzi).

Po přidání knihovny Dispečer úloh Firebase vytvořte JobService třídu a pak ji naplánujte tak, aby se spustila s instancí objektu FirebaseJobDispatcher.

Vytvoření služby JobService

Veškerá práce prováděná knihovnou Dispečer úloh Firebase musí být provedena v typu, který rozšiřuje Firebase.JobDispatcher.JobService abstraktní třídu. JobService Vytvoření architektury pro Android je velmi podobné vytvoření Service architektury pro Android:

  1. JobService Rozšíření třídy
  2. Ozdobte podtřídu pomocí ServiceAttribute. I když to není nezbytně nutné, doporučuje se explicitně nastavit Name parametr, který vám pomůže s laděním JobService.
  3. Přidejte k IntentFilter deklaraci objektu JobServicev AndroidManifest.xml. To také pomůže knihovně Dispečer úloh Firebase najít a vyvolat JobService.

Následující kód je příkladem nejjednodušší JobService aplikace pomocí TPL k asynchronnímu provádění některých úloh:

[Service(Name = "com.xamarin.fjdtestapp.DemoJob")]
[IntentFilter(new[] {FirebaseJobServiceIntent.Action})]
public class DemoJob : JobService
{
    static readonly string TAG = "X:DemoService";

    public override bool OnStartJob(IJobParameters jobParameters)
    {
        Task.Run(() =>
        {
            // Work is happening asynchronously (code omitted)
                       
        });

        // Return true because of the asynchronous work
        return true;  
    }

    public override bool OnStopJob(IJobParameters jobParameters)
    {
        Log.Debug(TAG, "DemoJob::OnStartJob");
        // nothing to do.
        return false;
    }
}

Vytvoření FirebaseJobDispatcher

Před naplánování jakékoli práce je nutné vytvořit Firebase.JobDispatcher.FirebaseJobDispatcher objekt. Je FirebaseJobDispatcher zodpovědný za plánování JobService. Následující fragment kódu je jedním ze způsobů, jak vytvořit instanci FirebaseJobDispatcher:

// This is the "Java" way to create a FirebaseJobDispatcher object
IDriver driver = new GooglePlayDriver(context);
FirebaseJobDispatcher dispatcher = new FirebaseJobDispatcher(driver);

V předchozím fragmentu GooglePlayDriver kódu je třída, která pomáhá FirebaseJobDispatcher interakci s některými rozhraními API pro plánování ve službách Google Play na zařízení. context Parametr je jakýkoli Android Context, například aktivita. V současné době je IDriver jedinou GooglePlayDriver implementací v knihovně Dispečer úloh Firebase.

Vazba Xamarin.Android pro dispečer úlohy Firebase poskytuje rozšiřující metodu pro FirebaseJobDispatcher vytvoření z Context:

FirebaseJobDispatcher dispatcher = context.CreateJobDispatcher();

FirebaseJobDispatcher Po vytvoření instance je možné vytvořit Job a spustit kód ve JobService třídě. Objekt Job je vytvořen objektem Job.Builder a bude popsán v další části.

Vytvoření Firebase.JobDispatcher.Job pomocí Job.Builderu

Třída Firebase.JobDispatcher.Job je zodpovědná za zapouzdření JobServicemeta-dat potřebných ke spuštění . ObsahujeJob informace, jako je jakékoli omezení, které musí být splněno před spuštěním úlohy, pokud Job je opakovaná, nebo jakékoli aktivační události, které způsobí spuštění úlohy. Jako minimum Job musí mít značku (jedinečný řetězec identifikující úlohu FirebaseJobDispatcher) a typ JobService spuštění. Dispečer úlohy Firebase vytvoří instanci JobService instance, kdy je čas spustit úlohu. A Job je vytvořen pomocí instance Firebase.JobDispatcher.Job.JobBuilder třídy.

Následující fragment kódu je nejjednodušším příkladem vytvoření Job vazby Xamarin.Android:

Job myJob = dispatcher.NewJobBuilder()
                      .SetService<DemoJob>("demo-job-tag")
                      .Build();

Provede Job.Builder několik základních kontrol ověření vstupních hodnot pro úlohu. Výjimka bude vyvolán, pokud není možné Job.Builder vytvořit Job. Vytvoří Job.Builder se Job s následujícími výchozími nastaveními:

  • JobŽivotnost zařízení (jak dlouho bude naplánováno spuštění) je pouze do restartování zařízení – jakmile se zařízení restartujeJob.
  • A Job se neopakuje – spustí se jenom jednou.
  • Naplánuje Job se spuštění co nejdříve.
  • Výchozí strategií opakování pro a je použití exponenciálního zpožování (podrobněji popsáno níže v části Nastavení opakování).Job

Plánování úlohy

Po vytvoření Jobmusí být naplánováno s před spuštěním FirebaseJobDispatcher . Existují dvě metody plánování Job:

// This will throw an exception if there was a problem scheduling the job
dispatcher.MustSchedule(myJob);

// This method will not throw an exception; an integer result value is returned
int scheduleResult = dispatcher.Schedule(myJob);

Vrácená FirebaseJobDispatcher.Schedule hodnota bude jednou z následujících celočíselné hodnoty:

  • FirebaseJobDispatcher.ScheduleResultSuccess – Bylo Job úspěšně naplánováno.
  • FirebaseJobDispatcher.ScheduleResultUnknownError – Došlo k nějakému neznámému problému, který zabránil naplánování Job .
  • FirebaseJobDispatcher.ScheduleResultNoDriverAvailable – Byla použita neplatná IDriver nebo IDriver byla nějak nedostupná.
  • FirebaseJobDispatcher.ScheduleResultUnsupportedTrigger – Nepodporováno Trigger .
  • FirebaseJobDispatcher.ScheduleResultBadService – Služba není správně nakonfigurovaná nebo není k dispozici.

Konfigurace úlohy

Úlohu je možné přizpůsobit. Mezi příklady přizpůsobení úlohy patří:

Každé z těchto témat bude popsáno více v následujících částech.

Předání parametrů úloze

Parametry se předávají úloze vytvořením předávaného Bundle společně s metodou Job.Builder.SetExtras :

Bundle jobParameters = new Bundle();
jobParameters.PutInt(FibonacciCalculatorJob.FibonacciPositionKey, 25);

Job myJob = dispatcher.NewJobBuilder()
                      .SetService<DemoJob>("demo-job-tag")
                      .SetExtras(jobParameters)
                      .Build();

K Bundle této metodě se přistupuje z IJobParameters.Extras vlastnosti OnStartJob :

public override bool OnStartJob(IJobParameters jobParameters)
{
    int position = jobParameters.Extras.GetInt(FibonacciPositionKey, DEFAULT_VALUE);
    
    // rest of code omitted
}

Nastavení omezení

Omezení můžou pomoct snížit náklady nebo vyprázdnit baterie na zařízení. Třída Firebase.JobDispatcher.Constraint definuje tato omezení jako celočíselné hodnoty:

  • Constraint.OnUnmeteredNetwork – Spusťte úlohu pouze v době, kdy je zařízení připojené k neměřené síti. To je užitečné, pokud chcete zabránit uživateli v účtování poplatků za data.
  • Constraint.OnAnyNetwork – Spusťte úlohu v libovolné síti, ke které je zařízení připojené. Pokud je tato hodnota zadaná společně Constraint.OnUnmeteredNetworks touto hodnotou, bude mít prioritu.
  • Constraint.DeviceCharging – Spusťte úlohu pouze v době, kdy se zařízení účtuje.

Omezení jsou nastavena metodou Job.Builder.SetConstraint :

Job myJob = dispatcher.NewJobBuilder()
                      .SetService<DemoJob>("demo-job-tag")
                      .SetConstraint(Constraint.DeviceCharging)
                      .Build();

Poskytuje JobTrigger pokyny k operačnímu systému o tom, kdy se má úloha spustit. Má JobTrigger spuštěné okno , které definuje naplánovaný čas, kdy se Job má spustit. V okně spuštění je hodnota úvodního okna a hodnota koncového okna . Počáteční okno je počet sekund, po které má zařízení čekat před spuštěním úlohy a hodnota koncového okna je maximální počet sekund čekání před spuštěním Job.

Pomocí metody lze vytvořit Firebase.Jobdispatcher.Trigger.ExecutionWindow AJobTrigger. Například Trigger.ExecutionWindow(15,60) to znamená, že úloha by měla běžet od 15 do 60 sekund od naplánovaného plánu. Metoda Job.Builder.SetTrigger se používá k

JobTrigger myTrigger = Trigger.ExecutionWindow(15,60);
Job myJob = dispatcher.NewJobBuilder()
                      .SetService<DemoJob>("demo-job-tag")
                      .SetTrigger(myTrigger)
                      .Build();

Výchozí hodnota JobTrigger pro úlohu je reprezentována hodnotou Trigger.Now, která určuje, že se úloha spustí co nejdříve po naplánování..

Nastavení opakováníStrategy

Slouží Firebase.JobDispatcher.RetryStrategy k určení, kolik zpoždění má zařízení použít před pokusem o opětovné spuštění neúspěšné úlohy. A RetryStrategy má zásadu, která definuje, jaký algoritmus časového základu se použije k opětovnému naplánování neúspěšné úlohy, a spouštěcí okno určující okno, ve kterém má být úloha naplánována. Toto okno pro přeplánování je definováno dvěma hodnotami. První hodnota je počet sekund, který se má počkat před opětovným naplánování úlohy ( počáteční hodnota zpětného ukončení ) a druhým číslem je maximální počet sekund před spuštěním úlohy ( maximální hodnota backoffu ).

Tyto hodnoty int identifikují dva typy zásad opakování:

  • RetryStrategy.RetryPolicyExponential – Exponenciální zásada zpětného odsunutí zvýší počáteční hodnotu backoff exponenciálně po každé chybě. Při prvním selhání úlohy bude knihovna čekat _initial interval zadaný před opětovným naplánování úlohy – například 30 sekund. Při druhém selhání úlohy knihovna počká aspoň 60 sekund před pokusem o spuštění úlohy. Po třetím neúspěšném pokusu bude knihovna čekat 120 sekund atd. Výchozí hodnota RetryStrategy pro knihovnu Dispečer úloh Firebase je reprezentována objektem RetryStrategy.DefaultExponential . Má počáteční zásadu 30 sekund a maximální omezení 3600 sekund.
  • RetryStrategy.RetryPolicyLinear – Tato strategie představuje lineární zásadu , že by se úloha měla přeplánovat tak, aby běžela v nastavených intervalech (dokud nebude úspěšná). Lineární backoff je nejvhodnější pro práci, která musí být dokončena co nejdříve nebo pro problémy, které se rychle vyřeší. Knihovna Dispečer úloh Firebase definuje RetryStrategy.DefaultLinear plánovací okno nejméně 30 sekund a až 3600 sekund.

Pomocí metody je možné definovat vlastní RetryStrategyFirebaseJobDispatcher.NewRetryStrategy . Přebírá tři parametry:

  1. int policy– Zásada je jednou z předchozích RetryStrategy hodnot, RetryStrategy.RetryPolicyLinearnebo RetryStrategy.RetryPolicyExponential.
  2. int initialBackoffSeconds – Počáteční zpomalování je zpoždění v sekundách, které se vyžaduje před opětovným pokusem o spuštění úlohy. Výchozí hodnota je 30 sekund.
  3. int maximumBackoffSeconds – Maximální hodnota zpětného odpočtu deklaruje maximální počet sekund ke zpoždění před opětovným pokusem o spuštění úlohy. Výchozí hodnota je 3600 sekund.
RetryStrategy retry = dispatcher.NewRetryStrategy(RetryStrategy.RetryPolicyLinear, initialBackoffSeconds, maximumBackoffSet);

// Create a Job and set the RetryStrategy via the Job.Builder
Job myJob = dispatcher.NewJobBuilder()
                      .SetService<DemoJob>("demo-job-tag")
                      .SetRetryStrategy(retry)
                      .Build();

Zrušení úlohy

Pomocí metody nebo FirebaseJobDispatcher.Cancel(string) metody je možné zrušit všechny naplánované úlohy nebo jenom jednu úlohuFirebaseJobDispatcher.CancelAll():

int cancelResult = dispatcher.CancelAll(); 

// to cancel a single job:

int cancelResult = dispatcher.Cancel("unique-tag-for-job");

Obě metody vrátí celočíselnou hodnotu:

  • FirebaseJobDispatcher.CancelResultSuccess – Úloha byla úspěšně zrušena.
  • FirebaseJobDispatcher.CancelResultUnknownError – Chyba znemožňovala zrušení úlohy.
  • FirebaseJobDispatcher.CancelResult.NoDriverAvailable– Úloha FirebaseJobDispatcher se nedá zrušit, protože není k dispozici.IDriver

Shrnutí

Tato příručka popisuje, jak pomocí dispečeru úloh Firebase inteligentně provádět práci na pozadí. Popisuje, jak zapouzdřit práci, která má být provedena jako a JobService jak použít FirebaseJobDispatcher k naplánování této práce, určení kritérií a JobTrigger způsob zpracování selhání pomocí RetryStrategy.