Autore Topic: [Difficile] Servizio remoto + BroadcastReceiver  (Letto 9704 volte)

Offline zerocool87

  • Utente junior
  • **
  • Post: 131
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Htc Legend
  • Sistema operativo:
    Ubuntu 10.04
[Difficile] Servizio remoto + BroadcastReceiver
« il: 08 Settembre 2010, 23:44:26 CEST »
+4
Livello di difficoltà: difficile
Versione SDK utilizzata: 2.1
Link al file compresso del progetto eclipse: file in allegato


Avendo avuto difficoltà nel ritrovare su Internet informazioni al riguardo, ho deciso di fare questo tutorial in cui spiego come creare un servizio remoto che invia messaggi in broadcast ad un broadcastReceiver :)

Nel file manifest ho dovuto dichiarare l'activity test, il Service TestService di cui ho specificato 2 action:

1) ServiceConnected rappresenta l'interfaccia pubblica con cui accedere al mio servizio e che viene specificata nel file ServiceConnected.aidl
2) ServiceUpdate rappresenta l'intent personalizzato che mando in Broadcast

Codice (XML): [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="r.app" android:versionCode="1" android:versionName="1.0">
        <application android:icon="@drawable/icon" android:label="@string/app_name">
                <activity android:name=".test" android:label="@string/app_name">
                        <intent-filter>
                                <action android:name="android.intent.action.MAIN" />
                                <category android:name="android.intent.category.LAUNCHER" />
                        </intent-filter>
                </activity>

                <service android:name="TestService">
                        <intent-filter>
                                <action android:name="r.app.ServiceConnected"></action>
                        </intent-filter>
                        <intent-filter>
                                <action android:name="r.app.ServiceUpdate"></action>
                        </intent-filter>
                </service>
        </application>
        <uses-sdk android:minSdkVersion="7" />

</manifest>


Questo di seguito è il file ServiceConnected.aidl in cui rappresenta l'interfaccia con cui accedere al Servizio

Codice: [Seleziona]
package r.app;

interface ServiceConnected{

boolean getConnected();

void setCancel();

}



Il codice del servizio remoto con tanto di Invio in Broadcast è il seguente


Codice (Java): [Seleziona]
package r.app;

import java.util.Timer;
import java.util.TimerTask;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;

public class TestService extends Service{

        private boolean connected=false; //mi serve solo per la funzione di test getConnected

        private boolean cancel=false; //Lo utilizzo per cancellare il Timer

        Timer t = new Timer();

        Intent update=new Intent("r.app.ServiceUpdate"); //Creo un nuovo intent a partire dalla mia Action

        private final ServiceConnected.Stub mBinder = new ServiceConnected.Stub(){

        /* implemento l'interfaccia del servizio facendo l'override dei metodi */

                @Override
                public boolean getConnected(){

                        Log.e("Connected="+Boolean.toString(connected), "GetConnected");

                        return connected;

                }

                @Override
                public void setCancel(){

                        Log.e("Cancello il Timer","Service");

                        cancel=true;
                }



        };



        @Override
        public void onCreate(){

/* qui dentro si entra sia durante il Bind, sia durante l'avvio del servizio */

                Log.e("Service","OnCreate()");
                super.onCreate();

        }

        @Override
        public int onStartCommand(Intent intent, int flags, int startId){

/*Entro solamente all'avvio del servizio ( startService(Intent) ) */
                connected=true;
                cancel=false;
                Log.e("Connected=true","OnStartCommand");
                boolean temp=true;

                sleep(); //Chiamo la funzione sleep in cui imposto il TimerTask e il sendBroadcast(Intent)

                return super.onStartCommand(intent, flags, startId);




        }
        @Override
        public IBinder onBind(Intent intent){ //Entro durante il Bind
                Log.e("Bind","onBind()");
                return mBinder;

        }

        @Override
        public boolean onUnbind(Intent intent){//Entro durante l'Unbind
               
                Log.e("Unbind","Service");
                super.onUnbind(intent);
                return true;
        }

        @Override
        public void onDestroy(){

/*Questo metodo viene invocato sia durante l'Unbind, sia durante lo stopService */
               
               connected=false;

                if(cancel==true) //Cancel=true quando stoppo il servizio (Vedi l'activity Test)
                        t.cancel(); //Cancello il Task

                Log.e("Cancel="+Boolean.toString(cancel),"onDestroy Service");
                Log.e("Connected=false","onDestroy()");
                super.onDestroy();

        }



        private void sleep(){
                Log.e("Dentro Sleep","Service");


                final Handler handler = new Handler();

                t.schedule(new TimerTask() {
                        public void run() {
                                handler.post(new Runnable() {
                                        public void run() {
                                                if(cancel==true)
                                                        t.cancel();
                                                sendBroadcast(update); //Mando in broadcast l'intent della Action creata da me
                                                Log.e("Mi addormento","onStart");
                                        }
                                });
                        }
                }, 5000/*inserisco un ritardo iniziale di 5 secondi*/,5000/*lo faccio ripetere ogni 5 secondi*/);





        }

}

Qui di seguito c'è l'activity di Test

Codice (Java): [Seleziona]
package r.app;


import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class test extends Activity {
        /** Called when the activity is first created. */

        private final Intent serviceIntent = new Intent(ServiceConnected.class
                        .getName()); //Creo l'intent che mi serve per avviare il servizio

        private ServiceConnected serviceConnected; //Rappresenta l'interfacci pubblica del servizio

        private final ServiceConnection serviceConnection = new ServiceConnection() {//Mi permette di connettermi/disconnettermi dal servizio

                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {


                        serviceConnected = ServiceConnected.Stub.asInterface(service); //Recupero l'interfaccia tramite la quale invoco i metodi
                        Log.e("Connessione al Servizio", "onServiceConnected");
                        Toast.makeText(test.this, "Connessione con il Service Effettuata", Toast.LENGTH_SHORT).show();
                }

                @Override
                public void onServiceDisconnected(ComponentName name) {
                        Log.e("Disconnessione dal servizio", "onServiceDisconnected");
                        Toast.makeText(test.this, "Scollegamento effettuato", Toast.LENGTH_SHORT).show();
                }

        };

        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);

                final Button startService=(Button) findViewById(R.id.StartService);

                startService.setOnClickListener(new OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                // TODO Auto-generated method stub

                                startService(new Intent("r.app.ServiceConnected")); //Avvio il servizio

                        }
                });

                final Button stopService=(Button) findViewById(R.id.StopService);

                stopService.setOnClickListener(new OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                /* Interrompo il servizio, ma prima verifico di avere effettuato il bind
                                    Avrei potuto invocare stopService anche senza fare il bind,
                                    ma creava problemi con il TimerTask. Ho dovuto perciò creare il metodo setCancel()
                                    che setta la variabile cancel a true così che nel metodo onDestroy (invocato tramite stopService)
                                    mi cancella il task. successivamente faccio l'unbind
                                 */

                                try {
                                        if(serviceConnected!=null){ //Ho fatto il bind
                                                serviceConnected.setCancel();
                                                stopService(new Intent("r.app.ServiceConnected"));     
                                                unbindRemoteService();
                                        }
                                } catch (RemoteException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }


                        }
                });

                final Button BindService=(Button) findViewById(R.id.Bind);

                BindService.setOnClickListener(new OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                // TODO Auto-generated method stub

                                bindRemoteService();//effettuo il Bind

                        }
                });


                final Button unBindService=(Button) findViewById(R.id.Unbind);

                unBindService.setOnClickListener(new OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                // TODO Auto-generated method stub

                                unbindRemoteService();//Effettuo l'Unbind

                        }
                });

                final Button verifica=(Button) findViewById(R.id.GetConnected);

                verifica.setOnClickListener(new OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                // TODO Auto-generated method stub

                                if(serviceConnected!=null)
                                        try {
                                                boolean temp=serviceConnected.getConnected(); //Funzione di prova per verificare il collegamento con il servizio

                                                Toast.makeText(test.this, "Connected="+Boolean.toString(temp), Toast.LENGTH_SHORT).show();

                                        } catch (RemoteException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }

                        }
                });
        }


        public void bindRemoteService() {
                if (serviceConnected == null) {//Se non ho fatto il bind
                        if( bindService(serviceIntent, serviceConnection,
                                        Context.BIND_AUTO_CREATE) ){//Effettuo il Bind

                                Log.e("Bind Effettuato", "bindRemoteService");
                                Toast.makeText(this, "Service Binded", Toast.LENGTH_SHORT).show();

                        }
                }
        }

        public void unbindRemoteService() {
                if(serviceConnected!=null){//Se avevo effettuato il BInd
                        unbindService(serviceConnection);//Effettuo l'Unbind
                        Log.e("unBind Effettuato", "unbindRemoteService");             
                        serviceConnected = null;               
                        Toast.makeText(this, "Service Unbinded", Toast.LENGTH_SHORT).show();
                }
        }

        private final BroadcastReceiver receiver= new BroadcastReceiver() {//Questo è il ReceiverBroadcast che riceve l'intent inviato dal service

                @Override
                public void onReceive(Context context, Intent intent) {
                        // Qui si può mettere qualsiasi funzione, io genero solamente un Toast di avviso
                        Toast.makeText(test.this, "Ricevuto messaggio in broadcast", Toast.LENGTH_SHORT).show();
                }
        };

/* Le operazione di registrazione e di deregistrazione del Broadcast Receiver le faccio dentro onPause e onResume */

        public void onPause(){
                Log.e("onPause()","test");
                unregisterReceiver(receiver);
                super.onPause();


        }

        public void onResume(){
                Log.e("OnResume","test");
                IntentFilter filter=new IntentFilter("r.app.ServiceUpdate");
                registerReceiver(receiver, new IntentFilter(filter));
                super.onResume();

        }
}

Qui di seguito c'è il layout utilizzato

Codice (XML): [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical" android:layout_width="fill_parent"
        android:layout_height="fill_parent">

        <Button android:text="Avvia Servizio" android:id="@+id/StartService"
                android:layout_width="wrap_content" android:layout_height="wrap_content"
                android:layout_gravity="center_horizontal"></Button>

        <Button android:text="Effettua Bind" android:id="@+id/Bind"
                android:layout_width="wrap_content" android:layout_height="wrap_content"
                android:layout_gravity="center_horizontal"></Button>
               
        <Button android:text="VerificaConnessione" android:id="@+id/GetConnected"
                android:layout_width="wrap_content" android:layout_height="wrap_content"
                android:layout_gravity="center_horizontal"></Button>
               
        <Button android:text="EffettuaUnbind" android:id="@+id/Unbind"
                android:layout_width="wrap_content" android:layout_height="wrap_content"
                android:layout_gravity="center_horizontal"></Button>
               
                        <Button android:text="Stop Servizio" android:id="@+id/StopService"
                android:layout_width="wrap_content" android:layout_height="wrap_content"
                android:layout_gravity="center_horizontal"></Button>
               
</LinearLayout>


Spero possa ritornare utile a qualcuno :)
« Ultima modifica: 09 Settembre 2010, 00:11:07 CEST da JD »

Offline zerocool87

  • Utente junior
  • **
  • Post: 131
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Htc Legend
  • Sistema operativo:
    Ubuntu 10.04
Re:[Medio] Servizio remoto + BroadcastReceiver
« Risposta #1 il: 09 Settembre 2010, 00:03:10 CEST »
0
Se doveste avere problemi con il progetto fatemelo sapere che lo ricarico :)

Offline lo

  • Utente junior
  • **
  • Post: 65
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    nexus one
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #2 il: 16 Ottobre 2010, 20:26:14 CEST »
0
ciao e grazie per questo utile post.
non sono sicuro di aver compreso tutto a dovere e avrei bisogno di porre alcune domande:

  • per ottenere il bind ho dovuto modificare il serviceIntent utilizzato nel metodo bindRemoteService(), facendolo puntare alla classe TestService e non all'interfaccia ServiceConnected: correzione giusta?
  • binding creato, messaggi toast di conferma e unbinding possibile. a questo punto mi sarei aspettato di vedere il servizio nell'elenco dei "running serivces", come mai non compare? forse non mi è ancora chiarissima la differenza fra startService e bindService...

quello che vorrei ottenere è un servizio totalmente indipendente dall'applicazione, che continui a girare anche quando l'applicazione viene stoppata: remote service, aidl e bindService sono la strada giusta?

grazie mille :)

Offline zerocool87

  • Utente junior
  • **
  • Post: 131
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Htc Legend
  • Sistema operativo:
    Ubuntu 10.04
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #3 il: 16 Ottobre 2010, 21:39:54 CEST »
0
ciao e grazie per questo utile post.
non sono sicuro di aver compreso tutto a dovere e avrei bisogno di porre alcune domande:

  • per ottenere il bind ho dovuto modificare il serviceIntent utilizzato nel metodo bindRemoteService(), facendolo puntare alla classe TestService e non all'interfaccia ServiceConnected: correzione giusta?
  • binding creato, messaggi toast di conferma e unbinding possibile. a questo punto mi sarei aspettato di vedere il servizio nell'elenco dei "running serivces", come mai non compare? forse non mi è ancora chiarissima la differenza fra startService e bindService...

quello che vorrei ottenere è un servizio totalmente indipendente dall'applicazione, che continui a girare anche quando l'applicazione viene stoppata: remote service, aidl e bindService sono la strada giusta?

grazie mille :)


ciao. la prima modifica è sbagliata in quanto tu devi riferirti al servizio vero e proprio(ServiceConnected) e non alla classe (testService) che lo sfrutta.
Per quanto riguarda la seconda questione considera che il bind ti permette di utilizzare le funzioni del remoteService, ma per fare ciò devi prima avere avere fatto partire il servizio con il metodo startService.

Scarica il progetto in eclipse che ho allegato e dai un'occhiata a quello. è tutto funzionante ;)

P.s. se riesco devo fare delle aggiunte alla guida in modo da eliminare il TimerTask e invece utilizzare l'AlarmManager. é un pò più complesso però è più funzionale in quanto con il TimerTask può succedere (e succede sempre) che android ti killa il servizio perchè lo vede sempre attivo e non utilizzato. se ho tempo lo pubblico prossimamente ;)

Offline lo

  • Utente junior
  • **
  • Post: 65
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    nexus one
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #4 il: 16 Ottobre 2010, 22:21:35 CEST »
0
ciao e grazie per la risposta.

in realtà avevo già scaricato e importato il progetto in eclipse ma senza la modifica del punto 1 non mi funzionava, strano... riferendomi invece a TestService sono riuscito a fare il binding. questa non l'ho capita ma mi documenterò più a fondo.
[edit]riscaricato, tutto ok ;)[/edit]


potrei chiederti però di togliermi alcune curiosità che non sono riuscito a soddisfare con la documentazione ufficiale?
mi saresti molto utile...

da quanto ho capito i servizi, a differenza delle activity, sono meno soggetti ad essere killati dal sistema quando le risorse scarseggiano.
dovrei anche aver chiare le differenze fra servizio locale e servizio remoto: il secondo gira in un processo suo e può essere quindi utilizzato, tramite la sua interfaccia, da più applicazioni.

detto questo mi aspetterei che, se stoppo un'activity che ha precedentemente avviato un servizio remoto, quest'ultimo non venga killato con essa, dato che gira in un processo a parte...
e i servizi locali? non girando in un processo a parte vengono killati insieme all'applicazione? perdono così la loro caratteristica di servizio...

...oppure non ho capito niente ed anche i servizi locali rimango in vita oltre l'activity...
[edit]magari il discriminante per l'indipendenza del servizio dall'activity non è la caratteristica locale/remoto, magari viene gestito tutto tramite l'attributo android:process...[/edit]


scusa se ho fatto un po' di confusione ma spero di averti spiegato in modo sufficientemente chiaro i miei dubbi... :)
« Ultima modifica: 17 Ottobre 2010, 13:58:39 CEST da lo »

Offline lo

  • Utente junior
  • **
  • Post: 65
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    nexus one
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #5 il: 17 Ottobre 2010, 15:49:52 CEST »
0
dunque, mi sono riletto più volte la documentazione e sono giunto a queste conclusioni:

  • il sistema a corto di risorse non killa applicazioni ma componenti delle applicazioni (coincide quando un'applicazione è composta da un solo componente), riconoscendo differenti priorità ai diversi tipi di componenti;
  • la differenza fra servizio locale e servizio remoto è che il secondo può, tramite la sua interfaccia, essere utilizzato da più applicazioni;
  • tutti i componenti di un'applicazione girano di default in un unico processo ma è possibile decidere di far girare uno o più componenti in un processo dedicato tramite la proprietà android:process nel manifest.

correggetemi se ho scritto qualcosa di errato. :)
grazie comunque della possibilità di esporre dubbi e ricevere chiarimenti...

Offline zerocool87

  • Utente junior
  • **
  • Post: 131
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Htc Legend
  • Sistema operativo:
    Ubuntu 10.04
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #6 il: 17 Ottobre 2010, 16:33:38 CEST »
0
allora parti dal presupposto che android killa tutto.non esiste cosa che non venga killata da android.  è anche vero che ci sono delle priorità. infatti killa per prima le activity e poi i servizi (a me succede che lo killava ogni 12/15 ore).

Per quanto si possa venire a dire che i servizi vengono killati solo in caso di necessità, in realtà se Android pensa che quel servizio è inutile lo killa indipendentemente se ha necessità di risorse o meno.

Per risponderti all'altra domanda i servizi si usano proprio per essere indipendenti dall'activity. se per esempio tu usi l'activity1 per lanciare il servizio e dopo invochi il metodo finish senza stoppare il servizio quest'ultimo rimarrà attivo. Nel caso sia un servizio remoto devi fare il bind e poi puoi utilizzare i metodi specificati nella sua interfaccia, anche da activity differenti. L'importante è che siano nello stesso package e, se sono in programmi diversi, abbiano tutti lo stesso file aidl che definisce l'interfaccia del Servizio.

Di default gira tutto in un singolo thread. se tu vuoi utilizzare processi differenti, o crei un servizio, oppure utilizzi degli AsyncTask.

Fammi sapere se hai bisogno di altre informazioni ;)
« Ultima modifica: 17 Ottobre 2010, 16:40:44 CEST da zerocool87 »

Offline MarcoDuff

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 1073
  • Respect: +202
    • Google+
    • marcoduff
    • Mostra profilo
    • MarcoDuff's Blog
  • Dispositivo Android:
    Samsung Galaxy Nexus
  • Play Store ID:
    MarcoDuff
  • Sistema operativo:
    Windows 7
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #7 il: 18 Ottobre 2010, 08:58:45 CEST »
+1
è anche vero che ci sono delle priorità. infatti killa per prima le activity e poi i servizi

Non proprio, anzi è proprio il contrario!

Andiamo per ordine:

1.
La cosa che non verrà mai (quasi mai) killata è un foreground process ed il 90% delle volte è proprio una Activity, ovvero quella che stiamo *utilizzando* in quel momento (sta nello stato tra onResume ed onPause). Tutti i servizi che sono legati a quella activity stanno un gradino sotto, cosi come i servizi che stanno in fase di inizializzazione/distruzione e i Receiver in fase di svolgimento del loro lavoro. Questi sono "tecnicamente" intoccabili.

2.
Dopo vi sono i processi visibili. Ovvero tutte quelle activity che stanno nello stato tra onStart e onStop ma che *non* stanno tra onResume e onPause (caso che ricade in quello appena detto sopra) e tutti i servizi legati a queste.

3.
Tutti i Servizi che non ricadono tra i casi 1 & 2

4.
Tutte le attività che hanno lo stato al di fuori di onStart e onStop.

5.
Tutti i restanti componenti.

Offline zerocool87

  • Utente junior
  • **
  • Post: 131
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Htc Legend
  • Sistema operativo:
    Ubuntu 10.04
Re: [Difficile] Servizio remoto + BroadcastReceiver
« Risposta #8 il: 18 Ottobre 2010, 22:14:06 CEST »
0
Intendevo le activity in background ..... é normale che se hai un'activity in foreground é quasi impossibile che te la killa....

Sent from my Legend using Tapatalk

Offline ginoz

  • Nuovo arrivato
  • *
  • Post: 42
  • Respect: 0
    • Mostra profilo
  • Sistema operativo:
    windows
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #9 il: 18 Marzo 2011, 23:41:45 CET »
0
e se invece di essere remoto il servizio è locale cosa cambia?

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #10 il: 18 Marzo 2011, 23:51:13 CET »
0
e se invece di essere remoto il servizio è locale cosa cambia?

A dire il vero a me sembra che il service in questo tutorial sia locale e non remoto...

Offline zerocool87

  • Utente junior
  • **
  • Post: 131
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Htc Legend
  • Sistema operativo:
    Ubuntu 10.04
Re: Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #11 il: 19 Marzo 2011, 01:00:02 CET »
0
A dire il vero a me sembra che il service in questo tutorial sia locale e non remoto...

É un servizio remoto..


Sent from my Legend using Tapatalk

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #12 il: 19 Marzo 2011, 11:50:11 CET »
0
É un servizio remoto..

Remoto significa che è in un processo diverso rispetto al client. Magari mi sfugge qualcosa, ma mi sembra che nel tuo esempio entrambi sono nello stesso processo.

Offline gsources75

  • Utente normale
  • ***
  • Post: 327
  • Respect: +9
    • Google+
    • pepigno75
    • devandroid_it
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Nexus S - Vodafone Smart -BB Bold- Iphone 4-
  • Play Store ID:
    Giuseppe+Sorce
  • Sistema operativo:
    Ubuntu-Windows Seven- Mac Lion
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #13 il: 02 Ottobre 2012, 15:08:56 CEST »
0
E' remoto ma è usato dall' app che lo crea, nulla vieta di creare un apk solo con il servizio e dopo usarlo da tutte le app che vuoi...

L' unica perplessità è se il solo modo di comunicare tra Service e Activity sia il BroadCast.
Volevo proprio evitare i broadcast visto che so che sono pesantini.
La domanda stupida è quella che non si fa

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:[Difficile] Servizio remoto + BroadcastReceiver
« Risposta #14 il: 02 Ottobre 2012, 15:18:45 CEST »
0
E' remoto ma è usato dall' app che lo crea, nulla vieta di creare un apk solo con il servizio e dopo usarlo da tutte le app che vuoi...

L' unica perplessità è se il solo modo di comunicare tra Service e Activity sia il BroadCast.
Volevo proprio evitare i broadcast visto che so che sono pesantini.

Per favore non riesumare topic vecchi.
Comunque il servizio di questo tutorial *non* è remoto, lo confermo.

Per comunicare puoi creare un interfaccia tramite aidl, fartela ritornare nel momento in cui fai il bindService e usare i metodi per controllare il servizio.
Leggi qui: Android Interface Definition Language (AIDL) | Android Developers
Questo ha molto senso se devi comunicare con un processo remoto (che ribadisco, si intende girare in un processo diverso dal client che lo binda).

Leggi inoltre qui:
Bound Services | Android Developers