# Werteübergabe nach unbestimmter Zeit



## Gast2 (16. Okt 2012)

Hallo,

ich habe zwei Klassen. 
In der ersten Klasse MainActivity initialisiere ich eine zweite Klasse WaitingForLight.

```
public WaitingForLight wfl;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		wfl = new WaitingForLight(this);
		wfl.askForLight();
	}

	@Override
	public void onClick(View v) {
		wfl.askForLight();
	}
```
und starte eine Methode askForLight()

In dieser Klasse befindet sich ein Listener und ein Algorithmus, der irgendwann einen Wert ausspuckt. 
Dieser Wert soll dann wieder in der ersten Klasse MainActivity landen.


```
public class WaitingForLight {

	private boolean pause;
	private int threshold, ergebnis;	
	private SensorManager manager;
	private Sensor sensorLight;
	private SensorEventListener listener;
        private Context ctxt; 

	WaitingForLight(Context ctxtMain) {
		this.ctxt = ctxtMain;
		threshold = 200;
		pause = false;
		manager = (SensorManager) this.ctxt.getSystemService(Context.SENSOR_SERVICE);
		sensorLight = manager.getDefaultSensor(Sensor.TYPE_LIGHT);		
	}

	public void askForLight() {
		pause = false;
		listener = new SensorEventListener() {
			@Override
			public void onAccuracyChanged(Sensor sensor1, int accuracy) { }

			@Override
			public void onSensorChanged(SensorEvent event) {
				if (!pause && event.values.length > 0) {
					ergebnis = (int) (event.values[0] + 0.5f);
					if (ergebnis > threshold) {
//						JETZT SOLL DER WERT ergebnis IN DIE AUFRUFENDE KLASSE ZURÜCK
					     pause = true;
					     
					} 
				}
			}
		};
		manager.registerListener(listener, sensorLight, SensorManager.SENSOR_DELAY_NORMAL);
	}
}
```

Ich weiß nicht, wie sich das lösen lässt.
Vorstellen könnte ich mir, dass in der ersten Klasse so was wie ein Listener ist, der auf das Ergebnis von der zweiten Klasse wartet. Aber vermutlich ist das auch recht kompliziert.
*Welche Möglichkeiten gibt es und vor allem welche Möglichkeit lässt sich relativ einfach umsetzen?*

Danke für Deine Gedanken!
Frank


----------



## schlingel (16. Okt 2012)

Am leichtesten ist es, wenn du in deiner Activity den Listener implementierst und diesen deiner WaitForLight-Klasse mit gibst.

Zweite Möglichkeit ist das ganze über Broadcast-Intents zu lösen. IMHO vernünftig wenn du die Daten in mehr als einer Activity benötigst.


----------



## Gast2 (16. Okt 2012)

schlingel hat gesagt.:


> Zweite Möglichkeit ist das ganze über Broadcast-Intents zu lösen. IMHO vernünftig wenn du die Daten in mehr als einer Activity benötigst.



Ja, die zweite Klasse soll eine Bibliothek werden.


----------



## schlingel (16. Okt 2012)

Das heißt ja nicht, dass sich nicht jede Activity das selbst registrieren kann. Das musst du dann abwägen.

Ist das Szenario

Activity1 stößt WaitLight an, Activity2 startet, Ergebnis kommt, Activity3 verwendet es.

eines dass du bedienen möchtest?


----------



## Gast2 (16. Okt 2012)

schlingel hat gesagt.:


> Ist das Szenario
> 
> Activity1 stößt WaitLight an, Activity2 startet, Ergebnis kommt, Activity3 verwendet es.
> 
> eines dass du bedienen möchtest?



*Für meine Zwecke würde es reichen, wenn das Ergebnis an Activity1 zurückgegeben wird.*
Wenn das Ergebnis überall nutzbar ist / wäre, dann wär das ein schöner Luxus (dazu fällt mir auch sharePreferences ein).

Frank


----------



## Gast2 (16. Okt 2012)

schlingel hat gesagt.:


> Am leichtesten ist es, wenn du in deiner Activity den Listener implementierst und diesen deiner WaitForLight-Klasse mit gibst.



Ich weiß ja noch nicht, wie es als Quellcode aussehen würde,
aber als Bibliothek wäre es von Vorteil, wenn der Nutzer der Bibliothek möglichst wenig mit Extras (den Listener implementieren) "belastet" wird.

Denk ich mir so...


----------



## Gast2 (16. Okt 2012)

schlingel hat gesagt.:


> Zweite Möglichkeit ist das ganze über Broadcast-Intents zu lösen. IMHO vernünftig wenn du die Daten in mehr als einer Activity benötigst.



Sind *Broadcast-Intents das Selbe wie Intents*, die ich übergebe, wenn ich eine andere Activity aufrufe?
(Übergabe von einer Klasse in eine andere)
z.B.

```
Intent intent = new Intent(this, MainActivity.class);
		intent.putExtra("dieZahl", String.valueOf(ergebnis));
		startActivity(intent);
```


Wenn ja, wie bemerkt MainActivity, dass _jetzt _was gesendet wurde,
also das Problem, dass die Antwort zu einem unbestimmten Zeitpunkt eintrifft.
Und wie wird das abgefangen?

Oder sind Broadcast-Intents was andres?
(dann muss ich dazu erste mal googlen und lesen)


----------



## schlingel (16. Okt 2012)

> dann muss ich dazu erste mal googlen und lesen


Immer gescheiter wenn man sich nicht sicher ist ;-)

Das sind spezielle Intents die man mittels BroadcastReceiver empfangen kann. Dazu muss man dem Intent anstatt einer Klasse eine bestimmte Action mitgeben auf die der BroadcastReceiver horcht.

Außerdem sendet man diese mittels sendBroadcast.


----------



## Gast2 (17. Okt 2012)

schlingel hat gesagt.:


> Immer gescheiter wenn man sich nicht sicher ist ;-)
> Das sind spezielle Intents die man mittels BroadcastReceiver empfangen kann.



Leider habe ich nichts wirklich Gutes im Internet dazu gefunden.
Die Seiten, welche BroadcastReceiver beschreiben halten sich entweder mit den absoluten Grundlagen auf (Empfangen von Broadcasts) bzw. sind ab irgendeinen Punkt falsch oder nicht mehr nachvollziehbar.

Gibt es Empfehlungen für Tutorials oder passende Beispiele zum Thema BroadcastReceiver?

Mein Ziel:
Von einer Activity eine Klasse starten,
darin läuft ein SensorEventListener und die Werte werden ausgewertet
(soll später mal zu einer Bibliothek werden),
in einer zeitlich unbestimmten Situation (z.B. es ist hell)
soll ein Wert resultActivity gegeben werden.

Ich würde mich freuen, wenn jemand Hilfe zu dem Thema hätte!

Danke!
Frank


----------



## schlingel (17. Okt 2012)

Es ist ja bei BroadcastReceiver bzw. BroadcastIntents keine großartige Magie dabei. Es gibt zwei verschiedene Modi:
1. Du registrierst einen Empfänger im Manifest. Dieser Empfänger wird vom System gestartet ohne dass du etwas dazu tun muss.

2. Du registrierst einen BroadcastReceiver in der Activity. Das heißt, läuft keine Activity die den Receiver registriert hat, geht der Broadcast ins Leere.

Folgendes: 


> [...]eine Klasse starten


Was genau soll das heißen? Welche Sensorergebnisse möchtest du haben? Macht es Sinn dass in einen Service zu packen? Dann musst du einen Service starten. Am besten auch über BroadcastIntents steuerbar, denn das Service binding funktioniert unangenehm langsam.

Tutorials, fällt mir jetzt nichts ein, ist ja wie gesagt auch dead simple, wo gibt's denn Probleme?


----------



## Gast2 (17. Okt 2012)

schlingel hat gesagt.:


> Es ist ja bei BroadcastReceiver bzw. BroadcastIntents keine großartige Magie dabei.


Mir kommt es so vor, ich verstehe das alles noch nicht so richtig...



schlingel hat gesagt.:


> Es gibt zwei verschiedene Modi:
> 1. Du registrierst einen Empfänger im Manifest. Dieser Empfänger wird vom System gestartet ohne dass du etwas dazu tun muss.
> 
> 2. Du registrierst einen BroadcastReceiver in der Activity. Das heißt, läuft keine Activity die den Receiver registriert hat, geht der Broadcast ins Leere.


Da ich den Broadcast nur innerhalb der App brauche, ist sicherlich die zweite Variante vernünftiger. Oder?



schlingel hat gesagt.:


> Folgendes:
> 
> Was genau soll das heißen? Welche Sensorergebnisse möchtest du haben?


Ich will eine Klasse (später solls eine Bibliothek werden) schreiben, in welcher SensorDaten ausgewertet werden. 
Als Beispiel: In der Klasse wird der SensorListener angeworfen und wenn der Lichtwert über 200 steigt, dann soll die Result.class / *.java aufgerufen werden und der Lichtwert (z.B.208) übergeben werden.



schlingel hat gesagt.:


> Macht es Sinn dass in einen Service zu packen? Dann musst du einen Service starten. Am besten auch über BroadcastIntents steuerbar, denn das Service binding funktioniert unangenehm langsam.


Das weiß ich nicht. Ich habe gerade mal eine Vermutung, was Services sind. (Übertragung von Daten zwischen Klassen?!)

In der Klasse, welche die ListenerWerte verarbeitet, WaitingForLight.java,
muss ich in dem Moment, wenn der Lichtwert über 200 steigt so etwas wie 
	
	
	
	





```
Intent intent = new Intent(Intent.ACTION_PICK, ergebnis);
        intent.putExtra("dieZahl", String.valueOf(ergebnis));
        startActivity(intent);
```
aufrufen, vermute ich. Aber das funktioniert auf jeden Fall gar nicht. 

F.


----------



## schlingel (17. Okt 2012)

> Ich habe gerade mal eine Vermutung, was Services sind. (Übertragung von Daten zwischen Klassen?!)


Schauen wir mal was die Doku sagt:


> A Service is an application component representing either an application's desire to perform a longer-running operation while not interacting with the user or to supply functionality for other applications to use.


Das kannst du dir als nebenläufigen Code innerhalb deines Main-Threads vorstellen, der erledigt was du eben von ihm erledigt haben möchtest.

Du kannst einen Service auch in einen anderen Thread packen aber das ist nur nötig, wenn du etwas tust was sehr resourcenintensiv ist. Auf ein Event warten ist das jedenfalls nicht.



> Intent intent = new Intent(Intent.ACTION_PICK, ergebnis);


ACTION_PICK verwendet man z.B. um Build In Activities zu starten um Musik-Tracks oder ähnliches auswählen zu lassen. Warum verwendest du diesen Action-String?

Was möchtest du tun? Eine neue Activity aus deiner App starten? Dann musst du die richtige Klasse nehmen und nicht ACTION_PICK. Möchtest du einen Broadcast senden? Dann musst du sendBroadcast verwenden. Sonst wird ja kein Broadcast gesendet.



> Da ich den Broadcast nur innerhalb der App brauche, ist sicherlich die zweite Variante vernünftiger. Oder?


Nein, das kommt ganz auf die Lebensdauer an. Soll es immer einen Empfänger geben, soll also immer auf den Broadcast reagiert werden? Falls JA, dann musst du dies ins Manifest packen.

Soll nur darauf reagiert werden wenn gerade eine Activity oder ein Service läuft, der darauf reagieren kann weil er einen BroadcastReceiver registriert hat, dann nimm Option 2.



> Als Beispiel: In der Klasse wird der SensorListener angeworfen und wenn der Lichtwert über 200 steigt, dann soll die Result.class / *.java aufgerufen werden und der Lichtwert (z.B.208) übergeben werden.


Ich würde das so designen, dass du einen Service startest der auf diesen Event wartet und dann gegebenenfalls einen Broadcast sendet. Auf den kann man, muss man aber nicht reagieren.


----------



## Gast2 (17. Okt 2012)

schlingel hat gesagt.:


> Soll nur darauf reagiert werden wenn gerade eine Activity oder ein Service läuft, der darauf reagieren kann weil er einen BroadcastReceiver registriert hat, dann nimm Option 2.


Ja genau, das meinte ich.




schlingel hat gesagt.:


> Ich würde das so designen, dass du einen Service startest der auf diesen Event wartet und dann gegebenenfalls einen Broadcast sendet. Auf den kann man, muss man aber nicht reagieren.


Das klingt sehr gut, so kann ich es mir auch sehr gut vorstellen.

Ich habe nun in meiner Klasse WaitingForLight
an der Stelle, wenn der Lichtwert über 200 steigt folgenden Code:

```
Intent intent = new Intent();
		intent.putExtra("dieZahl", String.valueOf(ergebnis));
		context.sendBroadcast(intent);
```

Geht das in die richtige Richtung?

In der MainActivity brauche ich vermutlich eine innere Klasse extends BroadcastReceiver???


----------



## schlingel (17. Okt 2012)

Ja, geht in die richtige Richtung. Dir fehlt aber nach wie vor die ACTION für den Intent.

Also definier, wo es halt gerade passt, einen String (ich mach das meistens in meinem Service) ala:


```
// irgendwo, vielleicht als Feld des Services
public static final String MY_SERVICE_ACTION = "com.example.MY_SERVICE_ACTION"; // was da drinnen steht is glaub ich ziemlich egal.
```

Und dann verwende den String wenn du den Receiver registrierst:


```
// z.B. im onCreate oder wo immer du das auch machst:
IntentFilter filter = new IntentFilter();
filter.addAction(MyService.MY_SERVICE_ACTION);
registerBroadcastReceiver(myReceiverObj, filter);
```

Und wenn du dann einen Broadcast verschicken möchtest:


```
Intent i = new Intent(MyService.MY_SERVICE_ACTION);
// dann fügst du die Extras hinzu
sendBroadcast(i);
```

Du kannst dem filter auch mehrere ACTIONs hinzufügen. Das ist sinnvoll wenn man einen Receiver für verschiedene Arten von Nachrichten verwenden möchte.


----------



## Gast2 (17. Okt 2012)

schlingel hat gesagt.:


> Und dann verwende den String wenn du den Receiver registrierst:
> 
> 
> ```
> ...



Ich stecke das in die Klasse mit dem Listener, weil von dort soll der Broadcast schließlich gesendet werden.

Da es eine Klasse ohne layout ist würde ich es in den Konstruktor packen:

```
public static final String MY_SERVICE_ACTION = "de.warteauflicht.MY_SERVICE_ACTION";


	WaitingForLight(Context ctxtMain) {
		this.context = ctxtMain;
		threshold = 200;
		pause = false;
		manager = (SensorManager) this.context
				.getSystemService(Context.SENSOR_SERVICE);
		sensorLight = manager.getDefaultSensor(Sensor.TYPE_LIGHT);
		IntentFilter filter = new IntentFilter();
		filter.addAction(MY_SERVICE_ACTION);
		registerBroadcastReceiver(myReceiverObj, filter);
		askForLight();
	}
	
	private void registerBroadcastReceiver(Object myReceiverObj, IntentFilter filter){
		Intent i = new Intent(MY_SERVICE_ACTION);
		sendBroadcast(i);
	}
```

*Soweit korrekt?
Aber was soll das myReceiverObj in Zeile 13 sein?*


----------



## Gast2 (22. Okt 2012)

Wie registriere ich in der Klasse, welche auf den Broadcast lauschen soll, den Broadcast?
Mit implements scheint es nicht zu gehen.

? ? ?


----------



## schlingel (22. Okt 2012)

Ähm, nein so geht das nicht.

Also prinzipiell brauchst du 3 Komponenten:

1. Den Service der die Arbeit macht und bei einem Ergebnis einen Broadcast rausschickt.

2. Die Lib die den Service startet.

3. Einen BroadcastReceiver auf Seiten des Clients der die Information haben will.

myReceiverObj ist genau so ein BroadcastReceiver-Objekt. Das hat an der Stelle nichts verloren. Das muss der Client in seiner Activity selbst einbauen wenn er die Lib nutzen möchte.


----------



## Gast2 (22. Okt 2012)

schlingel hat gesagt.:


> Also prinzipiell brauchst du 3 Komponenten:
> 
> 1. Den Service der die Arbeit macht und bei einem Ergebnis einen Broadcast rausschickt.


In meinem Fall die Klasse WaitingForLight?!
Da wo der SensorListener aufgerufen und ausgewertet wird und die Daten per Intent und sendBroadcast weitergegeben werden.



schlingel hat gesagt.:


> 2. Die Lib die den Service startet.


Meine Klasse MainActivity startet die Klasse WaitingForLight.
Wieso Lib? Die Klasse WaitingForLight soll mal als Lib enden, wenn sie fertig ist, aber wie meinst DU das, dass eine Lib den Service starten soll?



schlingel hat gesagt.:


> 3. Einen BroadcastReceiver auf Seiten des Clients der die Information haben will.
> 
> myReceiverObj ist genau so ein BroadcastReceiver-Objekt. Das hat an der Stelle nichts verloren. Das muss der Client in seiner Activity selbst einbauen wenn er die Lib nutzen möchte.


Das kann ja auch in der MainActivity.java sein. Oder?


----------



## schlingel (22. Okt 2012)

Das muss ein echter Service oder IntentService sein.

Eine solche Klasse, kann noch weiter seine Arbeit tun, auch wenn die aktuelle Activity in's Nirvana befördert wurde. (User drückt Back-Taste, eine Notification bringt den Nutzer dazu die App zu wechseln, etc.)

Diese Service-Klasse ist dann Bestandteil deiner Library. Als eigene Klasse. 



> Die Lib die den Service startet?.


Was ich damit gemeint habe, ist, dass du den Code der sich um das registrieren des BroadcastReceivers kümmert, in deine Library auslagerst. Das wäre z.B. ein guter Platz für WaitingLight.

Die Klasse würde dann zwei Methoden anbieten:
1. startWaitingForLight() <- Startet den Service mittels startService(Intent);
2. registerOnLightHandler(DeinHandlerObj); <- Hier registrierst du einen Event-Handler der feuert wenn der Service sich zurück meldet.

ODER du lagerst registerOnLightHandler nicht aus, und stellst nur den Code bereit der den nötigen IntentFilter liefert, damit man den Code für seinen BroadcastReceiver etwas kürzen kann.


----------



## Gast2 (22. Okt 2012)

Von wegen es sei einfach,
ich finde es kompliziert.
Das ist alles relativ.

Ich möchte das noch einmal mit meinen Worten formulieren:
Die Klasse MainActivity instanziert ein Objekt wfl der Klasse WaitingForLight.jar, welche sich in Libs befindet. Dann rufe ich wfl.startWaitingForLight() auf.

In der aktuellen Klasse, in der sich dann der Programmablauf befindet und in welcher ich das Ereignis (Lichtwert über 200) auswerten will, rufe ich wfl.registerOnLightHandler(DeinHandlerObj) auf. (DeinHandlerObj ist wahrscheinlich this, oder?) 
Das stelle ich mir ähnlich vor wie btn.setOnClickListener(this), eben nicht für einen Button, sondern für das Ereignis Lichtwert > 200.

Theoretisch kann jetzt irgendein Programmablauf passieren, was mehr oder weniger unwesentlich für diese Geschichte ist.

Das Objekt wfl feuert bei einem Lichtwert von über 200 einen Broadcast, der in der aktiven Klasse empfangen und ausgewertet wird.​
*Habe ich das soweit richtig verstanden?*

Und wenn ja, dann brauche ich in der empfangenden Klasse noch so etwas wie einen Listener?!?


----------



## schlingel (22. Okt 2012)

> Habe ich das soweit richtig verstanden?


Ja, so habe ich das gemeint. Alles richtig bis auf den Punkt, dass Android-Klassenbibliotheken APKs sind.



> Und wenn ja, dann brauche ich in der empfangenden Klasse noch so etwas wie einen Listener?!?


Ja, den definierst du dir einfach selbst mit den nötigen Parametern die aufgerufen werden sollen.


----------



## Gast2 (22. Okt 2012)

Ich habe jetzt die Klasse WaitingForLight,
die so aussieht:

```
package de.warteauflicht;

import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;

public class WaitingForLight {

	private boolean pause;
	private int threshold, ergebnis;
	private SensorManager manager;
	private Sensor sensorLight;
	private SensorEventListener listener;
	private Context context;
	public static final String MY_SERVICE_ACTION = "de.warteauflicht.MY_SERVICE_ACTION";
	private Intent i;

	WaitingForLight(Context ctxtMain) {
		this.context = ctxtMain;
		threshold = 200;
		pause = false;
		manager = (SensorManager) this.context
				.getSystemService(Context.SENSOR_SERVICE);
		sensorLight = manager.getDefaultSensor(Sensor.TYPE_LIGHT);
		IntentFilter filter = new IntentFilter();
		filter.addAction(MY_SERVICE_ACTION);
		startWaitingForLight();
	}
	
	public void registerOnLightHandler(Object myReceiverObj){
		i = new Intent(MY_SERVICE_ACTION);
		sendBroadcast(i);
	}

	private void sendBroadcast(Intent getIntent) {
		Intent intent = getIntent;
		intent.putExtra("dieZahl", String.valueOf(ergebnis));
		context.sendBroadcast(intent);	
	}

	public void startWaitingForLight() {
		pause = false;
		listener = new SensorEventListener() {
			@Override
			public void onAccuracyChanged(Sensor sensor1, int accuracy) {
			}

			@Override
			public void onSensorChanged(SensorEvent event) {
				if (!pause && event.values.length > 0) {
					ergebnis = (int) (event.values[0] + 0.5f);
					if (ergebnis > threshold) {
						pause = true;
						sendBroadcast(i);
					}
				}
			}
		};
		manager.registerListener(listener, sensorLight,
				SensorManager.SENSOR_DELAY_NORMAL);
	}
}
```

Jetzt frage ich mich, wie ich diese Klasse als APK speicher?
Ich habe probiert, aber eine Funktion "speichern als apk" oder so nicht gefunden.
Muss ich die Klasse in einem neuen Projekt erzeugen, um sie zu einer apk zu machen?


----------



## schlingel (22. Okt 2012)

Also, deine Klasse arbeitet nach wie vor ohne Service. Ein Service ist etwas, dass man extra definieren muss und vom System auch so behandelt wird.

Zu deiner Frage: Ja, das müsste in ein eigenes Android Library Projekt.


----------



## Gast2 (22. Okt 2012)

Ist onBind so etwas wie ein Konstruktor oder die onCreate bei einer Activity?
Also die Methode, welche bei Start ausgeführt wird?


----------



## schlingel (22. Okt 2012)

onBind benötigst du nur, wenn du dich an den Service binden möchtest. Ich persönlich finde dass unnötig kompliziert und mache so etwas lieber mit Broadcasts. 

onStart gibt's beim Service.


----------



## Gast2 (22. Okt 2012)

ok, ich habe die Klasse in einem extra Package
mit extends Service
und (zwangsläufig) die Methode onBind() überschrieben.


```
package de.lightlistener;

import android....

public class WaitingForLight extends Service {

	private boolean pause;
	private int threshold, ergebnis;
	private SensorManager manager;
	private Sensor sensorLight;
	private SensorEventListener listener;
	private Context context;
	public static final String MY_SERVICE_ACTION = "de.warteauflicht.MY_SERVICE_ACTION";
	private Intent i;

	WaitingForLight(Context ctxtMain) {
		this.context = ctxtMain;
		threshold = 200;
		pause = false;
		manager = (SensorManager) this.context
				.getSystemService(Context.SENSOR_SERVICE);
		sensorLight = manager.getDefaultSensor(Sensor.TYPE_LIGHT);
		IntentFilter filter = new IntentFilter();
		filter.addAction(MY_SERVICE_ACTION);
		startWaitingForLight();
	}
	
	public void registerOnLightHandler(Object myReceiverObj){
		i = new Intent(MY_SERVICE_ACTION);
		sendBroadcast(i);
	}
	
	public void startWaitingForLight() {
		pause = false;
		listener = new SensorEventListener() {
			@Override
			public void onAccuracyChanged(Sensor sensor1, int accuracy) {
			}

			@Override
			public void onSensorChanged(SensorEvent event) {
				if (!pause && event.values.length > 0) {
					ergebnis = (int) (event.values[0] + 0.5f);
					if (ergebnis > threshold) {
						pause = true;
						sendBroadcast(i);
					}
				}
			}
		};
		manager.registerListener(listener, sensorLight,
				SensorManager.SENSOR_DELAY_NORMAL);
	}

	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
}
```

*Wenn ich diese Klasse zur APK mache,
kann ich diese APK dann in der Lib eines anderen Package einbinden?*


----------



## Gast2 (22. Okt 2012)

Aber mit Service kann ich ja gar nicht auf Ereignisse reagieren,
dafür bräuchte ich doch eher den BroadcastReceiver?!


----------



## schlingel (23. Okt 2012)

Stimmt. Du vermischt die zwei Komponenten hier.

Zudem der Service keinen Constructer mehr mit einem Context-Parameter braucht, da ein Service auch ein Context-Objekt ist.

Wie gesagt:

Der Service ist eine Klasse.

WaitingForLight ist die andere Klasse, die den Code kapselt, der den Service startet (per Intent!) und den BroadcastReceiver enthält.

Du würdest bei einem Socket Client/Server Beispiel ja auch nicht den Client und den Server in die selbe Klasse packen.


----------



## Gast2 (23. Okt 2012)

Mir ist das über'n Kopf gewachsen.
Ich fange noch mal von vorne an,
mit einem Broadcast in einer jar-Datei.


----------

