anv2i24, 1:90 PM Servigo [DesenvoWedores Android
‘Adicionado na API nivel1 (/guide/topics/manifestluses-sdk-element#ApiLevels)
Servi¢co
Kotlin (/reference/kotlin/android/app/Service) - Brasil | Java
public abstract class Service
extends ContextWrapper (/reference/androidicontent/ContextWrapper) implements
ComponentCal1backs2 (/reference/androidicontent/ComponentCallbacks2)
java lang.Objeto (/reference/javalang/Object)
indroid. content. Contexto (/reference/androidicontent/Context)
|, android. content. ContextWrapper (/reference/android/content/ContextWrapper)
android.app.Servico
Subclasses diretas conhecidas
AbstractinputMethodService (/reference/android/nputmethodservice/AbstractinputMethodService), A
(ireference/androidservice/autofillAutofillService), CallRedirectionService (/reference/android/telecon
CameraPrewarmService (/reference/androidservice/media/CameraPrewarmService), CarrierMessagin
CarrierMessagingService (/reference/androidsservicelearrier/CarrierMessagingService), CarrierService
(ireferencefandroidiservice/chooser/ChooserTargetService), CompanionDeviceService (/reference/an
(ireferencesandroid/servicemnotification/ConditionProviderService), ConnectionService (/reference/anc
(Ireferencefandroid/service/controls/ControlsProviderService), CredentialProviderService (/referenceh
AbstractinputMethodService AbstractinputMethodServic
(ireference/androidinputmethodservice/AbstractInputMethodService)
AccessibilityService Accessibility services shou
(ireference/android/accessibilityservice/AccessibilityService)
AutofilService (/referencefandroidiservice/autofillAutofillService) Anis a service used to aut:
read Autofill Framework (/p
CallRedirectionService This service can be implem
(ireference/android/telecom/CallRedirectionService) redirection/cancellation pul
CallScreeningService (/reference/android/telecom/CallScreeningService) This service can be implem
shown to a user. Telecom!
(ireferencefandroiditeleco
CameraPrewarmService Extend this class to implerr
(ieference/androidsservice/media/CameraPrewarmService)
CarrierMessagingClientService If the default SMS app has
(ireferencefandroidservice/carrier/CarrierMessagingClientService) which allows the app to ha
hitosvldeveloperandroll.comireferencelandoldlappiService smi03 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
CarrierMessagingService A service that receives call
(ireference/androidservice/carrier/CarrierMessagingService)
CarrierService (reference/androidiservicelearrier/CarrierService) A service that exposes car
ChooserTargetService This class was deprecated
(ireferencefandroidservice/chooseriChooserTargetService) https:/ideveloper. android.cc
‘CompanionDeviceService A service that receives call
(ireference/android/companion/CompanionDeviceService)
nditionProviderServi This class was deprecated
(ireference/androidiservice/notification/ConditionProviderService) NotificationManager.s¢
(ireferencefandroid/app/Nc
to tell the system about the
configuration activity that /
(ireferencefandroid/app/Nc
(ireferencefandroidfapp/Au
(/referencefandroid/app/Au
ConnectionService (/reference/androiditelecom/ConnectionService) An abstract service that sh
1. Can make phone calls (
ControlsProviderService Service implementation alc
(reference/androidiservice/controls/ControlsProviderService)
CredentialProviderService Service to be extended by
(referencefandroidfservice/credentials/CredentialProviderService)
DeviceAdminService (/reference/android/app/admin/DeviceAdminService) Base class for a service thi
DreamService (/reference/android’service/dreams/DreamService) Extend this class to implerr
HostApduService (/reference/androidinfc/cardemulation/HostApduService) HostApduService is a conv:
Service (/reference/andro
HostNfcFService (/referencefandroidinfc/cardemulation/HostNfcFService) HostNfcFService is a convi
Service (/reference/andro
InGallservice (/reference/android/telecom/nCallservice) This service is implementec
IntentService (/reference/android/app/intentService) This class was deprecated
(fabout/versions/oreo/back
(https:/ideveloper.android..
IsolatedService Base class for services tha
(ireferenceandroid/adservicesiondevicepersonalization/IsolatedService) _(https:/ideveloper.android.
OnDevicePersonalizatic
OutcomeReceiver)
JobService (/reference/androidappijobUobService) Entry point for the callback
hitosvldeveloperandroll.comireferencelandoldlappiService anos anv2i24, 1:90 PM Servigo [DesenvoWedores Android
MediaBrowserService Base class for media brows
(Wreference/android/service’media/MediaBrowserService)
MediaRoute2ProviderService Base class for media route
(ireferencefandroidimedia/MediaRoute2ProviderService)
MediaSession2Service (/reference/androidimedia/MediaSession2Service) This API is not generally int
MidiDeviceService (/teference/androidimediaimidi/MidiDeviceService) A service that implements
MidimpDeviceService A service that implements
(ireference/androidimediamidi/MidiUmpDeviceService)
NotificationListenerService A service that receives call
(ireference/androidservicemotification/NotificationListenerService)
OfftiostApduService OffHostApduService is a cc
(ireference/androidinfc/cardemulation/OffHostApduService) host, for example on an err
PrintService (ireference/android/printservice/PrintService) This is the base class for in
QuickAccessWalletService A provides a list of s showr
(ireference/androidiservice/quickaccesswallet/QuickAccessWalletService)
RecognitionService (/reference/androidspeech/RecognitionService) This class provides a base
RemoteViewsService (/reference/android/widget/RemoteViewsService) The service to be connect«
SettinglnjectorService (/reference/androidlocation/SettingInjectorService) Dynamically specifies the s
the system settings app
For use only by apps that ¢
‘SpellCheckerService SpellCheckerService provic
(ireference/androidiservice/textservice/SpellCheckerService)
TextToSpeechService Abstract base class for TTS
(ireferencefandroidspeech/tts/TextToSpeechService)
TileService (/reference/androidiservice/quicksettings/TileService) ATileService provides the «
‘TunputService (/reference/androidimedia/twTvinputService) The TuinputService class re
broadcast TV programs.
‘TunteractiveAppService ATV interactive applicatior
(ireference/androidimedia/twinteractive/TvinteractiveAppService)
VisualVoicemailService This service is implementec
(ireference/android/telephony/VisualVoicemailService)
VoicelnteractionService Top-level service of the cul
(ireference/androidservice/voice/VoiceinteractionService) VoiceInteractor (/refere
WoiceinteractionSessionService ‘An active voice interaction
(ireference/androidiservice/voice/VoiceinteractionSessionService) (referencesandroidiservice
hitosvldeveloperandroll.comireferencelandoldlappiService
st03 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
VpnService (/reference/androidmetVpnService) VpnService is a base class
VilistenerService (/reference/androidiservice//VrListenerService) A service that is bound fro
WallpaperService (/reference/android/service/walipaper/WallpaperService) A wallpaper service is resp:
Subclasses indiretas conhecidas
InputMethodService (/reference/androidinputmethodservice/InputMethodService)
InputMethodService InputMethodService provides a
(ireference/androidinputmethodservice/InputMethodService) standard implementation of an
InputMethod, which final
implementations can derive from and
customize.
Um Servigo & um componente de aplicativo que representa o desejo de um aplicativo para
executar uma operagiio de execugao mais longa enquanto nao interage com o usuario ou
para fornecer funcionalidade para outros aplicativos usarem. Cada servico classe deve ter
uma declaragio correspondente em seu pacote . Servigos pode ser iniciado come.
(/reference/android/R.styleable#AndroidManifestService)
AndroidManifest . xml Context .startService()
(/reference/androidicontent/Context#startService(android.content. Intent)) Context. bindService()
(/reference/androidicontent/Context#bindService(android.content.|ntent,%20android.content.Context. Bi
ndServiceFlags, %20java.util.concurrent.Executor, %20android.content.ServiceConnection))
Observe que os servigos, como outros objetos de aplicativo, s4o executados na principal
thread de seu processo de hospedagem. Isso significa que, se 0 seu servigo esta indo para
fazer qualquer CPU intensiva (como reprodugao de MP3) ou bloqueio (como networking),
ele deve gerar seu préprio fio condutor para fazer isso trabalho. Mais informagées sobre
isso podem ser encontradas em Processos e Topicos:
(fguide/topics/fundamentals/processes-and-threads). A aula esta disponivel como uma
implementagao padrao do Servico que tem seu préprio thread onde agenda seu trabalho
para ser feito. JobIntentService
(https:/ideveloper. android. com/reference/androidx/core/appUobintentService.html)
Tépicos abordados aqui
hitosvldeveloperandroll.comireferencelandoldlappiService 4n03 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
1, O.que é um Servigo? (#WhatisAService)
2. Ciclo de vida do servico (#ServiceLifecycle)
3. Permissées (#Permissions)
clo de vida do processo (#ProcessLifecycle)
5. Exemplo de servi¢o local (#LocalServiceSample)
6. Exemplo de servico de mensageiro remoto (#RemoteMessengerServiceSample)
Guias do desenvolvedor
Para obter uma discussao detalhada sobre como criar servigos, leia 0 Guia do desenvolvedor de
servigos (/guide/topics/fundamentalsservices)
O que é um Servico?
A maior parte da confusao sobre a classe Service realmente gira em torno do que no é:
+ Um Servico nao é um processo separado. O préprio objeto Service nao implica que
esteja a correr no seu proprio processo; salvo disposigao em contrario, ele é
executado no mesmo processo que o aplicativo do qual faz parte.
+ Um Servico no é um thread. Nao é um meio em si para fazer trabalho fora do thread
principal (para evitar erros de aplicativo nao respondendo).
Assim, um Servigo emi é realmente muito simples, fornecendo duas caracteristicas
principais:
+ Uma facilidade para 0 aplicativo informar ao sistema sobre algo que ele quer estar
fazendo em segundo plano (mesmo quando o usuario nao esta interagindo
diretamente com 0 aplicativo). Isso corresponde a chamadas para , que solicitar a0
sistema que agende o trabalho para o servico, a ser executado até o servico ou
alguém o pare explicitamente. Context. startService()
(/reference/android/content/Context#startService(android.content.Intent))
+ Um recurso para um aplicativo expor algumas de suas funcionalidades a outras
aplicagées. Isso corresponde a chamadas para , que permite que uma conexao de
hitosvldeveloperandroll.comireferencelandoldlappiService 51103 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
longa data seja feita com o servigo, a fim de interagir com ele. Context. bindService()
(ireference/android/content/Context#tbindService(android.content intent, %20android.content.Con
text.BindServiceFlags, %20java.util. concurrent. Executor, %20android.content.ServiceConnection))
Quando um componente de servigo é realmente criado, por um desses motivos, tudo o que
o sistema realmente faz é instanciar o componente e chame seu e quaisquer outros
retornos de chamada apropriados no fio condutor. Cabe ao Servigo implementa-los com as
devidas providéncias comportamento, como criar um thread secundario no qual ele faz seu
trabalho oncreate() (/reference/androidiapp/ServicestonCreate())
Observe que, como 0 Servico em si é to simples, vocé pode fazer o seu interacao com ele
to simples ou complicado quanto vocé quer: de tratd-lo como um objeto Java local no qual
vocé faz chamadas diretas de método (conforme ilustrado por Amostra de Servico Local
(#LocalServiceSample)), para fornecer uma interface totalmente remota usando AIDL.
Ciclo de vida do servico
Ha duas razées pelas quais um servigo pode ser executado pelo sistema. Se alguém chama
entao o sistema iré recuperar o servigo (criando-o e chamando seu método se necessario)
e, em seguida, chame seu método com o argumentos fornecidos pelo cliente. O servigo
continuara neste momento executando até ou é chamado. Observe que varias chamadas
para Context.startService() nao aninham (embora resultem em varios correspondentes
chama para onStartCommand()), portanto, nao importa quantas vezes seja iniciado um
servigo sera interrompido quando Context.stopService() ou stopSelf() for chamado;
contudo Os servigos podem usar seu método para garantir que 0 servigo seja nao
interrompido até que as intengdes iniciadas tenham sido processadas.
Context. startService() (/reference/androidicontent/Context#startService(android.content.intent))
onCreate( ) (/reference/android/app/Service#onCreate()) onStartCommand(Intent,_int,_int)
(Wreferencefandroid/app/Service#onStartCommand(android.content.Intent,%20int,%20int))
Context. stopService() (ireference/android/content/ContextitstopService(android.content.intent))
stopSelf() (/reference/android/app/Service#stopSelf()) stopSelf (int)
(Wreference/android/app/Service##stopSelf(int))
Para servigos iniciados, ha dois modos principais adicionais de operagao eles podem
decidir correr, dependendo do valor que retornam onStartCommand(): é usado para
servigos que s&o explicitamente iniciado e interrompido conforme necessério, enquanto ou
so usados para servigos que devem apenas permanecem em execucao enquanto
processam quaisquer comandos enviados a eles. Veja o link documentagao para mais
detalhes sobre a semantica. START_STICKY (/reference/android/app/Service##START_STICKY)
hitosvldeveloperandroll.comireferencelandoldlappiService anos anv2i24, 1:90 PM Servigo [DesenvoWedores Android
‘START_NOT_STICKY (/reference/android/app/Service#START_NOT_STICKY) START_REDELIVER_INTENT
(Wreferencefandroid/app/ServicettSTART_REDELIVER_INTENT)
Os clientes também podem usar para Obter uma conexdo persistente com um servico. Isso
também cria 0 se ainda nao estiver em execugao (chamando enquanto fazendo isso), mas
no chama onStartCommand(). O cliente receberd 0 objeto que o servico retorna de seu
método, permitindo que o cliente faga chamadas de volta ao servico. O servico
permanecera em execugdo enquanto durar a conexao é estabelecido (quer o cliente
mantenha ou nao uma referéncia sobre o IBinder do servigo). Normalmente o IBinder
devolvido é para um complexo interface que foi escrita em aidl ({quide/components/aid)).
Context. bindService()
(referencefandroidicontent/Context#bindService(android.content. Intent, %20android.content.Context.Bi
ndServiceFlags, %20java.util.concurrent.Executor, %20android, content ServiceConnection))
onCreate() (reference/android/app/ServicetonCreate()) IBinder (/reference/android/os/IBinder)
‘onBind (Intent) (/reference/android/app/Service#onBind(android.content. Intent))
Um servigo pode ser iniciado e ter conexGes vinculadas a ele. Em tal um caso, o sistema
mantera 0 servigo em execugo enquanto ele for iniciado ou hd uma ou mais conexées com
ele com o sinalizador. Uma vez que nenhum dos dois dessas situagdes se mantém, 0
método do servigo é chamado de e o servigo é efetivamente encerrado. Toda a limpeza
(parando threads, descadastrar receptores) deve ser concluido ao retornar de
onDestroy(). Context .BIND_AUTO_CREATE (/reference/android/content/Context#BIND_AUTO_CREATE)
onDestroy() (/reference/android/app/ServicettonDestroy())
Permissées
Oacesso global a um servigo pode ser imposto quando ele é declarado em seu Tag do
manifesto. Ao fazer isso, outros aplicativos precisarao declarar um elemento
correspondente em seu préprio manifesto para poder iniciar, parar ou vincular a o servigo.
(/reference/android/R.styleable# AndroidManifestService)
(/reference/android/R.styleable# AndroidManifestUsesPermission)
As of , when using,, you can also set and/or on the Intent. This will grant the Service
temporary access to the specific URIs in the Intent. Access will remain until the Service has.
called for that start command or a later one, or until the Service has been completely
stopped. This works for granting access to the other apps that have not requested the
permission protecting the Service, or even when the Service is not exported at all.
Build. VERSION CODES. GINGERBREAD (/reference/android/os/Build.VERSION_CODES#GINGERBREAD)
Context. startService(Intent)
hitosvldeveloperandroll.comireferencelandoldlappiService mos anv2i24, 1:90 PM Servigo [DesenvoWedores Android
(Wreferencefandroidicontent/Context#startService(android.content.ntent))
Intent.FLAG_GRANT_READ_URT_PERMISSION
(referencefandroidicontent/intent#FLAG_GRANT_READ_URI_PERMISSION)
Intent .FLAG_GRANT_WRITE_URT_PERNISSION
Ureference/androidicontentiintent#FLAG_GRANT_WRITE_URI_PERMISSION) stopSelf (int)
(Wreferencefandroid/app/ServicettstopSelt{int))
In addition, a service can protect individual IPC calls into it with permissions, by calling the
method before executing the implementation of that call.
ContextWrapper_.checkCallingPermission(String)
(/referencefandroidicontent/ContextWrapperttcheckCallingPermission (java.lang.String))
See the Security and Permissions (/guide/topicssecuritysecurity) document for more
information on permissions and security in general
Process Lifecycle
The Android system will attempt to keep the process hosting a service around as long as.
the service has been started or has clients bound to it. When running low on memory and
needing to kill existing processes, the priority of a process hosting the service will be the
higher of the following possibilities:
+ If the service is currently executing code in its , , or methods, then the hosting process
will be a foreground process to ensure this code can execute without being killed.
onCreate() (/reference/android/app/Service#onCreate()) onStartCommand( )
(ireference/android/app/Service# onStartCommand(android.content.Intent, %2¢
%20int))
onDestroy() (/reference/android/app/Service#onDestroy())
* If the service has been started, then its hosting process is considered to be less
important than any processes that are currently visible to the user on-screen, but
more important than any process not visible. Because only a few processes are
generally visible to the user, this means that the service should not be killed except in
low memory conditions. However, since the user is not directly aware of a background
service, in that state it is considered a valid candidate to kill, and you should be
prepared for this to happen. In particular, long-running services will be increasingly
likely to kill and are guaranteed to be killed (and restarted if appropriate) if they
remain started long enough.
hitosvldeveloperandroll.comireferencelandoldlappiService anos Servigo [DesenvoWedores Android
* If there are clients bound to the service, then the service's hosting process is never
less important than the most important client. That is, if one of its clients is visible to
the user, then the service itself is considered to be visible. The way a client's
importance impacts the service's importance can be adjusted through, ,,, and.
Context#BIND_ABOVE CLIENT (/reference/android/content/Context#BIND_ABOVE CLIENT)
Context#BIND_ALLOW_OOM MANAGEMENT
(/reference/android/content/Context#BIND_ALLOW_OOM_MANAGEMENT)
Context#BIND_WAIVE PRIORITY (/reference/android/content/Context#BIND_WAIVE_PRIORITY)
Context#BIND_IMPORTANT (/reference/androidicontent/Context#BIND_IMPORTANT)
Context#BIND_ADJUST_WITH_ ACTIVITY
(ireferencefandroid/content/Context#BIND_ADJUST.WITH_ACTIVITY)
+ Astarted service can use the AP! to put the service in a foreground state, where the
system considers it to be something the user is actively aware of and thus not a
candidate for killing when low on memory. (It is still theoretically possible for the
service to be killed under extreme memory pressure from the current foreground
application, but in practice this should not be a concern.) startForeground(int,,
android. app.Notification)
(ireferencefandroid/app/Service#tstartForeground(int, %20android.app.Notification))
Note this means that most of the time your service is running, it may be killed by the system
if it is under heavy memory pressure. If this happens, the system will later try to restart the
service. An important consequence of this is that if you implement to schedule work to be
done asynchronously or in another thread, then you may want to use to have the system re-
if your service is killed while processing
deliver an Intent for you so that it does not get lost
it. onStartCommand()
(ireferencefandroid/app/Service#onStartCommand(android.content.Intent,%20int,%20int))
‘START_FLAG_REDELIVERY (/reference/androidiapp/Service##START_FLAG_REDELIVERY)
Other application components running in the same process as the service (such as an) can,
of course, increase the importance of the overall process beyond just the importance of the
service itself. Activity (/reference/android/app/Activity)
Local Service Sample
One of the most common uses of a Service is as a secondary component running alongside
other parts of an application, in the same process as the rest of the components. All
components of an .apk run in the same process unless explicitly stated otherwise, so this is
a typical situation.
hitosvldeveloperandroll.comireferencelandoldlappiService anos anv2i24, 1:90 PM Servigo [DesenvoWedores Android
When used in this way, by assuming the components are in the same process, you can
greatly simplify the interaction between them: clients of the service can simply cast the
[Binder they receive from it to a concrete class published by the service.
An example of this use of a Service is shown here. First is the Service itself, publishing a
custom class when bound:
public class LocalService extends Service {
private NotificationManager mNM;
// Unique Identification Number for the Notification.
// We use it on Notification start, and to cancel it.
private int NOTIFICATION = R.string.local_service_started;
ye
* Class for clients to access. Because we know this service always
* runs in the same process as its clients, we don't need to deal with
* Ipc.
*”
public class LocalBinder extends Binder {
LocalService getService() {
return LocalService. this;
@0verride
public void onCreate() {
mNM = (NotificationManager )getSystemService(NOTIFICATION_SERVICE) ;
// Display a notification about us starting. We put an icon in the status b
showNotification() ;
@0verride
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(*LocalService”, "Received start id" + startId + + intent);
return START_NOT_STICKY;
@0verride
public void onDestroy() {
// Cancel the persistent notification.
mNM.cancel (NOTIFICATION) ;
hitosvldeveloperandroll.comireferencelandoldlappiService son03 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
// Tell the user we stopped
Toast.makeText(this, R.string.local_service_stopped, Toast.LENGTH_SHORT) .sho
@0verride
public IBinder onBind(Intent intent) {
return mBinder ;
}
// This is the object that receives interactions from clients. See
// RemoteService for a more complete example.
private final IBinder mBinder = new LocalBinder();
i
* Show a notification while this service is running.
*”
private void showNotification() {
// In this sample, we'll use the same text for the ticker and the expanded n
CharSequence text = getText(R.string.local_service_started) ;
JJ The PendingIntent to launch our activity if the user selects this notific
PendingIntent contentIntent = PendingIntent.getActivity(this, 2,
new Intent(this, LocalServiceActivities.Controller.class), @);
// Set the info for the views that show in the notification panel
Notification notification = new Notification Builder(this)
-setSmallIcon(R.drawable.stat_sample) // the status icon
-setTicker(text) // the status text
setWhen(System.currentTimeMillis()) // the time stamp
-setContentTitle(getText(R.string.local_service_label)) // the labe
-setContentText(text) // the contents of the entry
-setContentIntent(contentIntent) // The intent to send when the ent
build();
// Send the notification.
NM. notify(NOTIFICATION, notification) ;
With that done, one can now write client code that directly accesses the running service,
such as:
hitosvldeveloperandroll.comireferencelandoldlappiService sito. anv2i24, 1:90 PM Servigo [DesenvoWedores Android
ys
Example of binding and unbinding to the local service.
bind to, receiving an object through which it can communicate with the service.
Note that this is implemented as an inner class only keep the sample
all together; typically this code would appear in some separate class.
*
public static class Binding extends Activity {
// Don't attempt to unbind from the service unless the client has received some
// information about the service's state.
private boolean mShouldUnbind;
// To invoke the bound service, first make sure that this value
// is not null.
private LocalService mBoundService;
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
// This is called when the connection with the service has been
// established, giving us the service object we can use to
// interact with the service. Because we have bound to a explicit
// service that we know is running in our own process, we can
// cast its IBinder to a concrete class and directly access it.
mBoundService = ((LocalService.LocalBinder)service) .getService();
// Tell the user about this for our demo.
Toast makeText (Binding. this, R.string.local_service_connected,
Toast .LENGTH_SHORT) .show() ;
public void onServiceDisconnected(ComponentName className) {
// This is called when the connection with the service has been
// unexpectedly disconnected -- that is, its process crashed.
// Because it is running in our same process, we should never
11 see this happen.
mBoundService = null;
Toast .makeText (Binding. this, R.string.local_service_disconnected,
Toast..LENGTH_SHORT) .show() ;
hi
void doBindService() {
// Attempts to establish a connection with the service. We use an
// explicit class name because we want a specific service
hitosvldeveloperandroll.comireferencelandoldlappiService sanos anv2i24, 1:90 PM Servigo [DesenvoWedores Android
// implementation that we know will be running in our own process
// (and thus won't be supporting component replacement by other
11 applications) .
if (bindService(new Intent(Binding.this, LocalService.class),
mConnection, Context .BIND_AUTO_CREATE)) {
mShouldUnbind = true;
} else {
Log.e("MY_APP_TAG", "Error: The requested service doesn't
exist, or this client isn't allowed access to it
void doUnbindService() {
if (mShouldUnbind) {
// Release information about the service's state.
unbindService(mConnection) ;
mShouldUnbind = false;
@0verride
protected void onDestroy() {
super .onDestroy();
doUnbindservice() ;
Remote Messenger Service Sample
If you need to be able to write a Service that can perform complicated communication with
clients in remote processes (beyond simply the use of to send commands tot), then you
can use the class instead of writing full AIDL files. Context startService
(/reference/androidicontent/Context#startService(android.content.intent)) Messenger
(/reference/android/os/Messenger)
An example of a Service that uses Messenger as its client interface is shown here. First is
the Service itself, publishing a Messenger to an internal Handler when bound:
public class MessengerService extends Service {
7** For showing and hiding our notification. */
NotificationManager mNM;
hitosvldeveloperandroll.comireferencelandoldlappiService ssn03 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
/** Keeps track of all current registered clients. */
ArrayList mClients = new ArrayList();
/** Holds last value set by a client. */
int mValue = @;
i
* Command to the service to register a client, receiving callbacks
* from the service. The Message's replyTo field must be a Messenger of
* the client where callbacks should be sent.
*”
static final int MSG_REGISTER_CLIENT = 1
ee
* Command to the service to unregister a client, ot stop receiving callbacks
* from the service. The Message's replyTo field must be a Messenger of
* the client as previously given with MSG_REGISTER_CLIENT.
*”
static final int MSG_UNREGISTER_CLIENT
ys
* Command to service to set anew value. This can be sent to the
* service to supply a new value, and will be sent by the service to
* any registered clients with the new value.
*”
static final int MSG_SET_VALUE
re
* Handler of incoming messages from clients.
*”
class IncomingHandler extends Handler {
@0verride
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_REGISTER_CLIENT:
mCLients.add(msg.replyTo) ;
break;
case MSG_UNREGISTER_CLIENT:
Clients. remove(msg.replyTo) ;
break;
case MSG_SET_VALUE:
mValue = msg.argl;
for (int ismClients.size()-1; i>=0;
try ¢
mCLients..get (i) .send(Message.obtain(nul1,
MSG_SET_VALUE, nValue, @));
4
hitosvldeveloperandroll.comireferencelandoldlappiService anos anv2i24, 1:90 PM Servigo [DesenvoWedores Android
} catch (RemoteException e) {
// The client is dead. Remove it from the list;
// we are going through the list from back to front
// 0 this is safe to do inside the loop.
mClients.remove(i) ;
}
}
break;
default
super .handleMessage(msg) ;
}
}
}
pee
* Target we publish for clients to send messages to IncomingHandler.
*
final Messenger messenger = new Messenger(new IncomingHandler()) ;
@0verride
public void onCreate() {
mNM = (NotificationManager ) getSystemService(NOTIFICATION_SERVICE) ;
// Display a notification about us starting.
showNotification();
@0verride
public void onDestroy() {
// Cancel the persistent notification
mNM.cancel(R.string.remote_service_started) ;
// Tell the user we stopped.
Toast.makeText(this, R.string.remote_service_stopped, Toast.LENGTH_SHORT) sh
ye
* When binding to the service, we return an interface to our messenger
* for sending messages to the service.
*
e0verride
public IBinder onBind(Intent intent) {
return messenger .getBinder() ;
hitosvldeveloperandroll.comireferencelandoldlappiService 5103 anv2i24, 1:90 PM Servigo [DesenvoWedores Android
i
* Show a notification while this service is running
*7
private void showNotification() {
// In this sample, we'll use the same text for the ticker and the expanded n
CharSequence text = getText(R.string.remote_service_started) ;
// The PendingIntent to launch our activity if the user selects this notific
PendingIntent contentIntent = PendingIntent.getActivity(this, @,
new Intent(this, Controller.class), 8);
// Set the info for the views that show in the notification panel.
Notification notification = new Notification. Builder(this)
setSmallIcon(R.drawable.stat_sample) // the status icon
-setTicker(text) // the status text
-setWhen(System.currentTimeMillis()) // the time stamp
-setContentTitle(getText(R.string.local_service_label)) // the labe
setContentText(text) // the contents of the entry
-setContentIntent(contentIntent) // The intent to send when the ent
-build();
IJ Send the notification.
// We use a string id because it is a unique number. We use it later to can
mNM notify(R.string.remote_service_started, notification) ;
If we want to make this service run in a remote process (instead of the standard one for its
-apk), we can use in its manifest tag to specify one: android:process
You might also like
- The Subtle Art of Not Giving a F*ck: A Counterintuitive Approach to Living a Good LifeFrom EverandThe Subtle Art of Not Giving a F*ck: A Counterintuitive Approach to Living a Good LifeRating: 4 out of 5 stars4/5 (5810)
- The Gifts of Imperfection: Let Go of Who You Think You're Supposed to Be and Embrace Who You AreFrom EverandThe Gifts of Imperfection: Let Go of Who You Think You're Supposed to Be and Embrace Who You AreRating: 4 out of 5 stars4/5 (1092)
- Never Split the Difference: Negotiating As If Your Life Depended On ItFrom EverandNever Split the Difference: Negotiating As If Your Life Depended On ItRating: 4.5 out of 5 stars4.5/5 (844)
- Grit: The Power of Passion and PerseveranceFrom EverandGrit: The Power of Passion and PerseveranceRating: 4 out of 5 stars4/5 (590)
- Hidden Figures: The American Dream and the Untold Story of the Black Women Mathematicians Who Helped Win the Space RaceFrom EverandHidden Figures: The American Dream and the Untold Story of the Black Women Mathematicians Who Helped Win the Space RaceRating: 4 out of 5 stars4/5 (897)
- Shoe Dog: A Memoir by the Creator of NikeFrom EverandShoe Dog: A Memoir by the Creator of NikeRating: 4.5 out of 5 stars4.5/5 (540)
- The Hard Thing About Hard Things: Building a Business When There Are No Easy AnswersFrom EverandThe Hard Thing About Hard Things: Building a Business When There Are No Easy AnswersRating: 4.5 out of 5 stars4.5/5 (348)
- Elon Musk: Tesla, SpaceX, and the Quest for a Fantastic FutureFrom EverandElon Musk: Tesla, SpaceX, and the Quest for a Fantastic FutureRating: 4.5 out of 5 stars4.5/5 (474)
- Her Body and Other Parties: StoriesFrom EverandHer Body and Other Parties: StoriesRating: 4 out of 5 stars4/5 (822)
- The Emperor of All Maladies: A Biography of CancerFrom EverandThe Emperor of All Maladies: A Biography of CancerRating: 4.5 out of 5 stars4.5/5 (271)
- The Sympathizer: A Novel (Pulitzer Prize for Fiction)From EverandThe Sympathizer: A Novel (Pulitzer Prize for Fiction)Rating: 4.5 out of 5 stars4.5/5 (122)
- The Little Book of Hygge: Danish Secrets to Happy LivingFrom EverandThe Little Book of Hygge: Danish Secrets to Happy LivingRating: 3.5 out of 5 stars3.5/5 (401)
- The World Is Flat 3.0: A Brief History of the Twenty-first CenturyFrom EverandThe World Is Flat 3.0: A Brief History of the Twenty-first CenturyRating: 3.5 out of 5 stars3.5/5 (2259)
- The Yellow House: A Memoir (2019 National Book Award Winner)From EverandThe Yellow House: A Memoir (2019 National Book Award Winner)Rating: 4 out of 5 stars4/5 (98)
- Devil in the Grove: Thurgood Marshall, the Groveland Boys, and the Dawn of a New AmericaFrom EverandDevil in the Grove: Thurgood Marshall, the Groveland Boys, and the Dawn of a New AmericaRating: 4.5 out of 5 stars4.5/5 (266)
- A Heartbreaking Work Of Staggering Genius: A Memoir Based on a True StoryFrom EverandA Heartbreaking Work Of Staggering Genius: A Memoir Based on a True StoryRating: 3.5 out of 5 stars3.5/5 (231)
- Team of Rivals: The Political Genius of Abraham LincolnFrom EverandTeam of Rivals: The Political Genius of Abraham LincolnRating: 4.5 out of 5 stars4.5/5 (234)
- On Fire: The (Burning) Case for a Green New DealFrom EverandOn Fire: The (Burning) Case for a Green New DealRating: 4 out of 5 stars4/5 (74)
- The Unwinding: An Inner History of the New AmericaFrom EverandThe Unwinding: An Inner History of the New AmericaRating: 4 out of 5 stars4/5 (45)
- ToastDocument19 pagesToastGabriel FilipiNo ratings yet
- Bottom PagesDocument3 pagesBottom PagesGabriel FilipiNo ratings yet
- Content ProviderDocument29 pagesContent ProviderGabriel FilipiNo ratings yet
- Broadcast ReceiverDocument21 pagesBroadcast ReceiverGabriel FilipiNo ratings yet
- Guia Rápido de RubyDocument156 pagesGuia Rápido de RubyGabriel FilipiNo ratings yet
- Learning Spring BootDocument141 pagesLearning Spring BootGabriel FilipiNo ratings yet
- Quarkus in Action Meap v03Document214 pagesQuarkus in Action Meap v03Gabriel FilipiNo ratings yet
