Définir un Écouteur dans un Service de Classe en fonction de

Le Service de la documentation est assez complet exemple de code pour la mise en œuvre d'un service dans votre application, qu'une autre partie de votre application peuvent se lier et de faire des appels sur:

http://developer.android.com/reference/android/app/Service.html#LocalServiceSample

Il suffit de mettre votre setUpdateListener() la méthode sur le Service, et de l'appeler une fois que vous obtenez onServiceConnected() avec le service.

De sorte que votre code serait quelque chose comme ceci:

public interface UpdateListener {
public void onUpdate(long value);
}
class LocalService {
//Like in the Service sample code, plus:
public static String ACTION_START = "com.mypackage.START";
private final ArrayList<UpdateListener> mListeners
= new ArrayList<UpdateListener>();
private final Handler mHandler = new Handler();
private long mTick = 0;
private final Runnable mTickRunnable = new Runnable() {
public void run() {
mTick++;
sendUpdate(mTick);
mHandler.postDelayed(mTickRunnable, 1000);
}
}
public void registerListener(UpdateListener listener) {
mListeners.add(listener);
}
public void unregisterListener(UpdateListener listener) {
mListeners.remove(listener);
}
private void sendUpdate(long value) {
for (int i=mListeners.size()-1; i>=0; i--) {
mListeners.get(i).onUpdate(value);
}
}
public int onStartCommand(Intent intent, int flags, int startId) {
if (ACTION_START.equals(intent.getAction()) {
mTick = 0;
mHandler.removeCallbacks(mTickRunnable);
mHandler.post(mTickRunnable);
}
return START_STICKY;
}
public void onDestroy() {
mHandler.removeCallbacks(mTickRunnable);
}

Maintenant, vous pouvez démarrer le service de l'obtenir pour commencer à compter, et n'importe qui peut se lier à elle pour enregistrer un écouteur pour recevoir des rappels comme il le faut.

C'est vraiment si dur que pour répondre à votre question très bien parce que vous n'êtes pas vraiment dire ce que vous voulez vraiment accomplir. Il y a beaucoup de façons d'utiliser les services, de départ ou de liaison ou de mélanger les deux ensemble, selon exactement ce que vous voulez accomplir.

Maintenant, vous pouvez mettre en œuvre votre code client sur la base de l'échantillon:

public class SomeActivity extends Activity implements UpdateListener {
private LocalService mBoundService;
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
mBoundService = ((LocalService.LocalBinder)service).getService();
mBoundService.registerListener(this);
}
public void onServiceDisconnected(ComponentName className) {
mBoundService = null;
}
};
void doBindService() {
bindService(new Intent(Binding.this, 
LocalService.class), mConnection, Context.BIND_AUTO_CREATE);
mIsBound = true;
}
void doUnbindService() {
if (mIsBound) {
if (mBoundService != null) {
mBoundService.unregisterListener(this);
}
unbindService(mConnection);
mIsBound = false;
}
}
protected void onDestroy() {
super.onDestroy();
doUnbindService();
}

OriginalL'auteur hackbod

MrJre est exact que le démarrage est déprécié et que vous devriez être en utilisant onStartCommand().

Si vous voulez obtenir que cela fonctionne, il y a une meilleure façon.

Je suis en train de faire quelque chose de similaire, en voulant mettre à jour d'une INTERFACE à partir des résultats qui se passe dans un service. Ce n'était pas particulièrement facile. (À mon avis)

Voici comment faire: tout d'Abord la ferraille votre code existant)

Dans l'INTERFACE utilisateur de la classe d'ajouter:

public Intent service;
service = new Intent(thisContext, TimerService.class);
service.putExtra("ms", ms);
startService(service);
//bind service to the UI **Important**
bindService();
IntentFilter timerFilter = new IntentFilter("TimerIntent"); //Filter that gets stuff from the service
registerReceiver(myReceiver, timerFilter);
void bindService() {
Intent newIntent = new Intent(this, TimerService.class);
bindService(newIntent, mConnection, Context.BIND_AUTO_CREATE);
mIsBound = true;
}
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName className, IBinder binder) {
s = ((TimerService.MyBinder) binder).getService();
}
@Override
public void onServiceDisconnected(ComponentName className) {
s = null;
}
};
public void releaseBind() {
if (mIsBound) {
unbindService(mConnection);
mIsBound = false;
}
}
//Now in this class we need to add in the listener that will update the UI (the receiver registered above) 
private BroadcastReceiver myReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
//TODO Auto-generated method stub
//Get Bundles
Bundle extras = intent.getExtras();
/* DO ANY UI UPDATING YOU WANT HERE (set text boxes, etc.) TAKING INFO FROM THE "extras" Bundle ie: setting the clock*/
//ie: int timerTest = extras.getInt("0");
//Now update screen with value from timerTest
}
};

Service Du Fichier:

public class TimerService extends Service {
public TimerService () {
super();
}
private final IBinder mBinder = new MyBinder();
public Timer clockTimer = new Timer();  
public int timer = 0;   
//We return the binder class upon a call of bindService
@Override
public IBinder onBind(Intent arg0) {
return mBinder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
//After service starts this executes
Bundle extras; 
extras = intent.getExtras(); 
/* Call a function to do stuff here. Like if you are a clock call a timer function updates every second */ 
//Here's an example, modify to fit your needs. 
clock();
return START_STICKY;
}
public class MyBinder extends Binder {
TimerService getService() {
return TimerService.this;
}
}
public void clock() {
clockTimer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
try {
//Some function ie: Time = Time + 1 //
/* MAKE SURE YOU BROADCAST THE RECEIVER HERE. This is what you send back to the UI.  IE:*/
timer = timer+ 1; //increment counter
Intent intent = new 
//Bundle the timervalue with Intent
intent.putExtra("0", timer);
intent.setAction("TimerIntent");
sendBroadcast(intent); //finally broadcast to the UI
} catch(Exception ie) {
}
}   
},
0, //Delay to start timer
1000); //how often this loop iterates in ms (so look runs every second)
}   

Il pourrait y avoir quelques erreurs de syntaxe dans le présent code, j'ai juste modifié mon travail et code de l'essayer et de l'adapter à vos besoins. Il y aura évidemment besoin d'être aussi quelques modifications en fonction de ce que vous voulez faire. Mais ce cadre et vous serez en mesure de faire ce que vous essayez de faire.

Cela fonctionne pour moi, donc j'espère que vous pouvez modifier cela fonctionne pour vous. (Seule chose que j'ai laissé de côté sont les importations, mais vous devriez être capable de facilement trouver)

Points clés:

• Service Bind de l'INTERFACE utilisateur
• Registre auditeur dans le fichier d'INTERFACE d'utilisateur pour répondre à la diffusion de l'intérieur du service.

Acclamations.

OriginalL'auteur Dave