मेरे मूल उत्तर के लिए नीचे देखें - उस पैटर्न ने अच्छी तरह से काम किया है, लेकिन हाल ही में मैंने सेवा / गतिविधि संचार के लिए एक अलग दृष्टिकोण का उपयोग करना शुरू कर दिया है:
- एक बाउंड सेवा का उपयोग करें जो गतिविधि को सेवा का सीधा संदर्भ प्राप्त करने में सक्षम बनाती है, इस प्रकार इंटेंट्स का उपयोग करने के बजाय इस पर सीधे कॉल की अनुमति देती है।
अतुल्यकालिक कार्यों को निष्पादित करने के लिए RxJava का उपयोग करें।
यदि सेवा में कोई गतिविधि नहीं चल रही है, तब भी पृष्ठभूमि के संचालन को जारी रखने की आवश्यकता है, तो अनुप्रयोग वर्ग से भी सेवा शुरू करें, ताकि जब वह आगे न बढ़े।
स्टार्टस् सेवा () / लोकलब्रॉडकास्ट तकनीक की तुलना में मुझे इस दृष्टिकोण में जो फायदे मिले हैं
- पार्सलबल को लागू करने के लिए डेटा ऑब्जेक्ट की आवश्यकता नहीं है - यह मेरे लिए विशेष रूप से महत्वपूर्ण है क्योंकि मैं अब एंड्रॉइड और आईओएस के बीच कोड साझा कर रहा हूं (रोबो वीवीएम का उपयोग करके)
- RxJava डिब्बाबंद (और क्रॉस-प्लेटफ़ॉर्म) शेड्यूलिंग, और अनुक्रमिक एसिंक्रोनस संचालन की आसान संरचना प्रदान करता है।
- यह एक LocalBroadcast का उपयोग करने से अधिक कुशल होना चाहिए, हालांकि RxJava का उपयोग करने के ओवरहेड कि पल्ला झुकना हो सकता है।
कुछ उदाहरण कोड। पहली सेवा:
public class AndroidBmService extends Service implements BmService {
private static final int PRESSURE_RATE = 500000; // microseconds between pressure updates
private SensorManager sensorManager;
private SensorEventListener pressureListener;
private ObservableEmitter<Float> pressureObserver;
private Observable<Float> pressureObservable;
public class LocalBinder extends Binder {
public AndroidBmService getService() {
return AndroidBmService.this;
}
}
private IBinder binder = new LocalBinder();
@Nullable
@Override
public IBinder onBind(Intent intent) {
logMsg("Service bound");
return binder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return START_NOT_STICKY;
}
@Override
public void onCreate() {
super.onCreate();
sensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
Sensor pressureSensor = sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE);
if(pressureSensor != null)
sensorManager.registerListener(pressureListener = new SensorEventListener() {
@Override
public void onSensorChanged(SensorEvent event) {
if(pressureObserver != null) {
float lastPressure = event.values[0];
float lastPressureAltitude = (float)((1 - Math.pow(lastPressure / 1013.25, 0.190284)) * 145366.45);
pressureObserver.onNext(lastPressureAltitude);
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
}, pressureSensor, PRESSURE_RATE);
}
@Override
public Observable<Float> observePressure() {
if(pressureObservable == null) {
pressureObservable = Observable.create(emitter -> pressureObserver = emitter);
pressureObservable = pressureObservable.share();
}
return pressureObservable;
}
@Override
public void onDestroy() {
if(pressureListener != null)
sensorManager.unregisterListener(pressureListener);
}
}
और एक गतिविधि जो सेवा से जुड़ती है और दबाव ऊंचाई अपडेट प्राप्त करती है:
public class TestActivity extends AppCompatActivity {
private ContentTestBinding binding;
private ServiceConnection serviceConnection;
private AndroidBmService service;
private Disposable disposable;
@Override
protected void onDestroy() {
if(disposable != null)
disposable.dispose();
unbindService(serviceConnection);
super.onDestroy();
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = DataBindingUtil.setContentView(this, R.layout.content_test);
serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
logMsg("BlueMAX service bound");
service = ((AndroidBmService.LocalBinder)iBinder).getService();
disposable = service.observePressure()
.observeOn(AndroidSchedulers.mainThread())
.subscribe(altitude ->
binding.altitude.setText(
String.format(Locale.US,
"Pressure Altitude %d feet",
altitude.intValue())));
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
logMsg("Service disconnected");
}
};
bindService(new Intent(
this, AndroidBmService.class),
serviceConnection, BIND_AUTO_CREATE);
}
}
इस गतिविधि का लेआउट है:
<?xml version="1.0" encoding="utf-8"?>
<layout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.controlj.mfgtest.TestActivity">
<TextView
tools:text="Pressure"
android:id="@+id/altitude"
android:gravity="center_horizontal"
android:layout_gravity="center_vertical"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
</LinearLayout>
</layout>
यदि सेवा को एक बाध्य गतिविधि के बिना पृष्ठभूमि में चलाने की आवश्यकता होती है, तो इसे अनुप्रयोग वर्ग से और साथ ही OnCreate()उपयोग में शुरू किया जा सकता है Context#startService()।
मेरा मूल उत्तर (2013 से):
आपकी सेवा में: (नीचे उदाहरण में COPA सेवा के रूप में)।
एक LocalBroadCastManager का उपयोग करें। आपकी सेवा के ऑनक्रैट में, ब्रॉडकास्टर सेट करें:
broadcaster = LocalBroadcastManager.getInstance(this);
जब आप किसी चीज़ के UI को सूचित करना चाहते हैं:
static final public String COPA_RESULT = "com.controlj.copame.backend.COPAService.REQUEST_PROCESSED";
static final public String COPA_MESSAGE = "com.controlj.copame.backend.COPAService.COPA_MSG";
public void sendResult(String message) {
Intent intent = new Intent(COPA_RESULT);
if(message != null)
intent.putExtra(COPA_MESSAGE, message);
broadcaster.sendBroadcast(intent);
}
आपकी गतिविधि में:
OnCreate पर एक श्रोता बनाएँ:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
super.setContentView(R.layout.copa);
receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String s = intent.getStringExtra(COPAService.COPA_MESSAGE);
// do something here.
}
};
}
और इसे onStart में पंजीकृत करें:
@Override
protected void onStart() {
super.onStart();
LocalBroadcastManager.getInstance(this).registerReceiver((receiver),
new IntentFilter(COPAService.COPA_RESULT)
);
}
@Override
protected void onStop() {
LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
super.onStop();
}