Android-Programmering

Presentasjon om: "Android-Programmering"— Utskrift av presentasjonen:

1 Android-Programmering
Våren 2016

2 Oversikt Long-running operasjoner Introduksjon til Android services
On-demand service Bruk av servicer på tvers av prosesser Vi skal se på long-running operasjoner, hva vil long-running operasjoner si. Hvordan påvirker dette applikasjonene våre, når noe kjører som dette? Vi skal se på Android servicer, hva de er, hva deres nytteverdi er, og hvordan jobbe med dem. On-demand service, en av de enkleste typen service vi kan implementere, og hvordan vi kan bruke den. Til slutt skal vi se på bruk av servicer på tvers av prosesser. Ha en service implementert i en prosess, og la komponenter i andre prosesser benytte denne servicen.

3 Long-running operasjoner
Hva mener vi med dette? Virker subjektivt? Har en spesifik betydning i Android En operasjon som tar lang nok tid til at en bruker kan ha byttet applikasjon Hva er en lon-running operasjon? Når vi hører et uttrykk som dette, høres det ganske subjektivt ut. Noe som er avhengig av omstendighetene. Men, når vi snakker om mobile enheter, og Android, har konseptet med long-running operasjoner en spesifik betydning. Det er ikke nødvendigvis noe som trenger å ta så veldig lang tid. Det er en operasjon, som mellom når den har startet og når den er ferdig, har gitt brukeren mulighet til å bytte mellom applikasjoner.

4 Android prosesshåndtering
Android har ansvaret for opprettholde et responsiv brukeropplevelse Begrensede ressurser Android må jevnlig terminere prosesser Prosessen brukeren benytter er prioritert Hvorfor det er viktig og tenke på når en bruker kan bytte applikasjon, har med måten Android håndterer prosesser på. Vi vet at Android operativsystemet, har ansvaret for og opprettholde et responsiv brukeropplevelse. Å gjøre dette er en utfordring. Mobile enheter kan ha begrensede ressurser, lite minne, lite cpu etc. Måten operativsystemet opprettholder en responsiv brukeropplevelse er ved å terminere prosesser jevnlig, for å frigjøre ressurser. Den må bruke en eller annen modell eller algoritme for å avgjøre hvilke prosesser som er de beste kandidatene for å termineres. Hovedsakelig ser den på, «hva gjør brukeren nå». Den prosessen brukeren benytter, vil være sett på som den viktigste prosessen. Det vil si at når en bruker benytter en Activity, har denne aktiviteten en prosess som blir sett på som viktig. Det er heller ikke uvanlig at denne aktiviteten igjen benytter andre prosesser. Hvis en bruker kjører igang en operasjon som tar lang tid. For så å bytte applikasjon. Vil denne kjøre i bakgrunnen, og ikke være prioritert lenger, og blir en kandidat for terminering. Utfordringen kan være at ting fungerer forskjellig fra gang til gang. Dette kan gå helt fint hvis det ikke er noe ressursspress på enheten, men hvis det en annen gang kjøres mange andre prosesser samtidig, som tar opp ressurser. Kan det hende prosessen blir terminert, og den blir ikke ferdig. Så noe som blir ferdig en gang, blir ikke nødvendigvis det neste.

5 Tråder og long-running operasjoner
Tråder alene kan ikke håndtere long-running operasjoner pålitelig Tråder i en Activity er bare viktig for aktiviteten En Activity prosess kan avsluttes hvis brukeren bytter Er ikke garantert at tråden blir ferdig Trenger en måte og prioritere oppgaver uten brukergrensenitt Det er grunnen til at tråder, eller tråder alene, ikke løser dette problemet for oss. Fordi når en tråd blir startet i en activity, kjører denne i samme prosess som aktiviteten. Så den er bare sett på som viktig, så lenge denne prosessen blir sett på som viktig. Igjen, hvis en bruker bytter over til en annen aktivitet, vil den tidligere aktiviteten og prosessen bli en kandidat for terminering. Vi trenger en måte og fortelle Android at vi har en oppgave som ikke bruker brukergrensesnittet, som er viktig for brukeren, selv om ikke brukeren benytter seg av denne akkurat nå.

6 Android Servicer Service er en component type i Android
Finnes for å utføre long-running operasjoner som ikke går på UI’et Høy prioritet Foran det meste annet enn prosessen brukeren benytter nå Mulig og elivere en service Det vi har for å si at en aktivitet eller operasjon er viktig, selv om brukeren ikke benytter seg av denne akkurat nå, er en Service. Service er en component type i Andorid. Dette vil si at det er en klasse vi implementerer, og definerer i Android Manifestet. Servicer eksisterer spesifikt for å si til Android operativsystemet at «jeg kjører en lang operasjon, jeg vet at den ikke bruker brukergrensesnittet nå, men det er fortsatt viktig for brukeren». Servicer blir generelt sett på som noe av det viktigste som kjører på en enhet, sett bortifra prosessen brukeren interagerer med akkurat nå. Det vil si at hvis en bruker kjører igang en prosess som kjører i en Service. Så starter en ny aktivitet, så bytter til en annen, så vil kanskje disse aktivitetne bli kandidater for terminering, men servicen selv er fortsatt viktig, og vil fortsette og kjøre. Det er også mulig og elivere viktigheten til en service til å være like viktig som hovedaktiviteten som brukeren benytter. A Service is not a separate process. The Service object itself does not imply it is running in its own process; unless otherwise specified, it runs in the same process as the application it is part of. A Service is not a thread. It is not a means itself to do work off of the main thread (to avoid Application Not Responding errors).

7 Service kategorier Finnes 2 generelle kategorier Started Servicer
Kontroll over sin egen livssyklus Begrenset interaktivitet med andre komponenter De fleste servicer er started servicer Bound Servicer Livssyklus direkte knyttet til komponenten som benytter den Har mye interaktivitet med komponenten som benytter den Servicer blir satt i 2 kategorier. Den vanligste er en Started Service, det vil si en komponent trenger noe utført i bakgrunnen, sender en forespørsel for å få dette gjort, og servicen blir startet. Servicen kontrollerer i stor grad sin egen livssyklus. Den kan bestemme når den skal avsluttes, kan kjøre i lengre perioder selv om det ikke er noe å gjøre. Å den har ganske begrenset interaktivitet med andre komponenter. Den er ofte sin egen uavhengige entiet. Den kan sende informasjon tilbake, med noen begrensninger. Men, den håndterer i stor grad seg selv. Den andre typen service er en Bound Service. Dette kan sees på litt mer som en slags klient server konsept. Hvor en komponent kjører i gang en service, knytter seg til denne og sender informasjon frem og tilbake. Den har mye interaktivitet med komponentene som benytter den, men den har lite kontroll over sin egen livssyklus. De startes når blir spurt om det, og avsluttet når den blir spurt om det. De aller fleste er started servicer.

8 Lage en enkel service Letteste on-demand started service IntentService
Starter når en forespørsel blir sendt Kjører så lenge forespørselen blir prosessert Avslutter når den er ferdig IntentService Hvordan lager vi en service. Det finnes mange måter og gjøre dette på, og de varierer stort i kompleksitet. Så, hva er de letteste måten og lage en service på? Denne kalles on-demand started service. Det vil si at hvis du har noe som skal utføres, sender du den litt arbeid, hvis den ikke kjører, startes den opp, den gjør det den har fått beskjed om, så gjør den seg ferdig og avslutter seg selv. Denne måten å gjøre det på er så nyttig i så mange tilfeller, at Android gir oss en klasse som heter IntentService som hjelper oss. Denne håndterer mye av arbeidet rundt konseptet med en on-demand service.

9 IntentService Håndterer mye av kompleksiteten til servicer
Gjemmer mange av funksjonene til servicer Håndterer køer av long-running operasjoner Lager en enkel tråd når startService blir kjørt Får den flere kall til startService blir dette arbeidet utført sekvensielt Når en alt er utført, avsluttes den Vi ønsker og lage en service basert på IntentService. Håndterer mye av kompleksiteten i det å opprette en service. Vi skal se mer på det senere. Den lar oss fokusere på oppgavene vi ønsker og utføre. Baksiden er at den også gjemmer mange av kapabilitetene til en servicer. Ved å gjemme kompleksiteten, gjemmer den også mange av funksjonene til en service. For noen servicer, fungerer IntentService veldig bra, i andre tilfeller fungerer det ikke like bra. Den gjør alt bakgrunnsarbeidet, som å starte opp, tar seg av køer av operasjoner som eventuelt kan komme. Så det fungerer veldig bra i lignende tilfeller hvor du ville brukt en enkelt tråd til å gjøre noe. Det den gjør er å lage en tråd. Når du sender en forespørsel, sendes denne videre til tråden. Så hvis du gir den flere ting å gjløre, gjør den det sekvensiellt, den gjør det i bakgrunnen, en etter en. Når det ikke finnes noe mer arbeid, avslutter den seg selv.

10 Lage en IntentService basert Service
Opprette klasse som arver fra IntentService Konstruktør som kaller IntentService til konstruktør Override IntentService.onHandleIntent Utfører arbeidet Registreres i manifestfilen Hvordan gjør vi så dette? Lage en service basert på IntentService klassen. Lager en klasse som arver fra IntentService klassen. Så må du implementere to metoder. Du må lage en konstruktør. Du sender inn en string verdig som brukes til å navngi servisen. Brukes hovedsakelig til debugging. Så overrider du onHandleIntent. Hver gang servicen får noe arbeid å utføre kalles onHandleIntent servicen. Som med mange ting i Android, så er måten arbeid blir sendt til servicen på, via intents. Når klassen er opprettet, må den registreres i manifestet.

11 Aksessere en on-demand Service
Lag en intent med en referanse til Service komponent klassen Hvis du ønsker så sende parametere, bruk Intent.putExtra Kall Context.startService med intenten Kan kjøre startService flere ganger Example 01

12 Servicer på tvers av prosesser
Servicer er en sentralisert måte å utføre long- running operasjoner Unngå å tenke på Servicer som tråder Er en Android component type Bruker en eller flere tråder til å utføre arbeidet Kjører i prosessen den blir opprettet i Kan bli kallt av andre komponenter i samme prosess Kan bli kallt av komponenter i en annen prosess Kan håndere flere forespørsler fra forskjellige prosesser samtidig

13 Gjøre Service tilgjengelig for andre prosesser
Sette opp ett intent filter Vil vanligvis bruke en Action test Er en definert string Bruker som oftest pakke navnet Filteret kan inneholde Category og/eller Data tester Kan inneholde flere intent filtere Android matcher en intent med intent filteret Starter service prosessen hvis nødvendig Hvis den kjører brukes instansen som finnes Intent sendes inn til servicen Example 02

14 Oppsumering Tråder alene kan ikke håndtere long-running operasjoner pålitelig Servicer er en pålitelig måte å kjøre long-running operasjoner Bruk IntentService til å implementere on-demand Started Servicer Started servicer aksesseres ved hjelp av startService og en Intent Intent til servicer i samme prosess trenger bare service klassen Kall til servicer på tvers av prosesser krever Intent Filter

15 Oversikt Service livssyklus Service og tråder
Ta kontroll over livssyklusen Det første vi skal se på er livssyklusen. Hva er livssyklusen til en service. Hva er de forskjellige aspektene, eller de forskjellige fasene til livssyklusen. Hvordan muligheter har vi til å påvirke denne prosessen? Når vi lager en service. Hva må vi tenke på når det gjelder tråder. Når vi så på on-demand started servicen vi implementerte tidligere, trengte vi egentlig ikke å håndtere tråder, siden alt ble tatt hånd om for oss. Vi ser at når vi ser litt nærmere på servicer, og alle egenskapene de har, er det noen viktige hensyn vi må ta, og er ansvarlig for, i forhold til tråder. Så skal vi se på hvordan vi kan ta direkte kontroll over service livssyklusen. Hvordan vi kan la servicen kjøre under våre forutsetninger, ikke bare hvordan servicen benyttes av hver enkelt bruker. Og til slutt har vi operativsystemet. Hvordan kan vi operativsystmet hint om hvordan vi vil at servicen skal fungere, slik at operativsystemet kan hjelpe oss. F.eks. Hvis servicen blir drept av en eller annen grunn, kan vi få den til å restarte den automatisk og lignende.

16 Service livssyklus Started service kan styre sin egen livssyklus
Ikke begrenset til enkle oppgaver Kan fortsette og kjøre for å respondere raskere Kan ha funksjoner som er mer brukerorientert Når vi snakker om service livssyklusen, går vi lenger enn det en on-demand service gir oss. Vi snakket om en enkel on-demand service. Den ble starten når den ble gitt arbeid, jobbet så lenge det var arbeid å gjøre, og når det ikke var mer arbeid avsluttet den. Vi kan gå langt forbi dette, vi kan gjøre ganske mye mer. Den trenger ikke være begrenset til å gjøre en enkel oppgave. En service kan gjøre mye forskjellig i bakgrunnen, selv når det ikke sendes noen forespørsel direkte til den. Den kan gjøre ofte bare kjøre i bakgrunnen uten å gjøre noe spesialt, bare for å kunne respondere raskere. Servicer kan også gi funksjoner som er mer brukerorientert. Slik som en musikkavspiller, denne kjører ofte i en service, og lar brukeren interagere med denne servicen gjennom aktiviteten.

17 Service klassen Arver fra Service klassen
IntentService inneholder en standardimplementasjon for de fleste metoder Service livssyklusen eksponeres gjennom 3 metoder onCreate Kalles når Android lager servicen Kalles bare en gang onStartCommand Kalles hver gang en annen component kaller Context.startService Kan kalles mange ganger onDestroy Kalles for å si at en service blir avsluttet Component kalles av Context.StopService eller service kaller stopSelf Kan også kalles av systemet for å frigi ressurser

18 Started service livssyklus
Component 1 kaller startService onCreate onStartCommand Component 2 kaller startService onStartCommand Component N kaller stopService onDestroy stopSelf

19 Implementering av started service livssyklusen
Arver fra Service klassen Override onCreate Initialiseringen av Service klassen Override onStartCommand Initialiser spesifik request behandling Vil vanligvis utføre arbeidet i en bakgrunnstråd Returner et flag som indikerer forventningene til systemet Override onDestroy Opprydding Override onBind Brukes ikke i started servicer Return null Legg til i Android manifest EXAMPLE 03

20 Servicer og tråder Kjører i hovedtråden
Den samme tråden som UI’et kjører på Du har ansvaret for å sette opp arbeidet i en annen tråd Kan lage tråder eksplisitt Kan benytte en av klassene som implementerer ExecutorService An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks. A Future represents the result of an asynchronous computation. Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package. This class supports the following kinds of methods:  newSingleThreadExecutor () Creates an Executor that uses a single worker thread operating off an unbounded queue. (Note however that if this single thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks.) Tasks are guaranteed to execute sequentially, and no more than one task will be active at any given time. Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.  ScheduledExecutorService newSingleThreadScheduledExecutor () Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically. (Note however that if this single thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks.) Tasks are guaranteed to execute sequentially, and no more than one task will be active at any given time. Unlike the otherwise equivalentnewScheduledThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads. EXAMPLE 04

21 Ta kontroll over livssyklusen
En service har 2 mekanismer for å håndtere sin egen livssyklus stopSelf En service kan gjøre eksplisitte, eller betingede stopp onStartCommand Returnerer verdi som indikerer hva systemet skal gjøre hvis prosessen blir drept

22 Stop-self Eksplisitt Betinget Service kaller stopSelf
Systemet kaller onDestroy med en gang og avslutter servicen Betinget Service kan indikere at den vil stoppe hvis den ikke har noe arbeid som venter Hvert kall til onStartCommand inkluderer en request id stopSelfResult tar request id Stopper bare hvis det ikke er noen request som venter  If someone calls Context.startService() then the system will retrieve the service (creating it and calling its onCreate() method if needed) and then call itsonStartCommand(Intent, int, int) method with the arguments supplied by the client. The service will at this point continue running until Context.stopService() or stopSelf() is called. EXAMPLE 05

23 Operativsystemets kontroll over livssyklusen
onStartCommand - Returnerer verdi som indikerer hva systemet skal gjøre hvis prosessen blir drept Kontrollerer automatisk restart av service Kan restarte når ressurser blir tilgjengelige igjen Kan vente til neste kall til startService Kontrollerer hva som sendes til onStartcommand når en restart blir gjort Kan f.eks. Sende siste intent på nytt

24 onStartCommand return verdier
Finnes 4 forskjellige START_NOT_STICKY Hvis servicen blir drept, ikke start igjen før startService blir kallt START_STICKY Hvis service blir drept, restart automatisk når ressurser er tilgjengelig Sender en null intent til onStartCommand START_REDILEVER_INTENT Sender siste intent som ble sendt før den ble drept START_STICKY_COMPATIBLITY Kompatabilitet med Android 1.6 og tidligere

25 Velge riktig onStartCommand return verdi
START_NOT_STICKY Mindre viktige servicer START_STICKY Hvis du ønsker at servicen skal forbli aktiv Gjør gjerne noe mer enn enkel request håndtering START_REDILEVER_INTENT Servicer som er «request-oriented» onStartCommand flag parameter indikerer om en intent sende inn på nytt START_FLAG_REDELIVERY Servicen returnerte fra onStartCommand, men kallte aldri stopSelfResult Pass på hvis det skaper problemer og håndtere samme intent flere ganger

26 Oppsumering Servicer kan håndtere sin egen livssyklus
Servicer kjører i utgangspunktet på hovedtråden Servicer er ansvarlig for å sende arbeid til bakgrunnstråder onStartCommand return verdi kontrollerer hva som skjer hvis servicen blir drept Eksempel 06