Android Update Activity UI vom Dienst

Siehe unten für meine ursprüngliche Antwort - das Muster hat gut funktioniert, aber vor kurzem habe ich angefangen mit einen anderen Ansatz, um Service - /Aktivitäts-Kommunikation:

• Verwenden gebunden-service die es ermöglicht, die Aktivität zu erhalten einen direkten
  Referenz auf den Service, so dass direkte Gespräche auf, sondern
  als die Verwendung von Intents.

• Verwenden RxJava für die Ausführung von asynchronen Operationen.

• Wenn der Dienst muss weiterhin im hintergrund-Operationen, selbst wenn keine
  Aktivität ausgeführt wird, starten Sie den Dienst aus der Anwendung
  Klasse, so dass es nicht gestoppt, wenn ungebundene.

Die Vorteile, die ich gefunden habe, ist bei diesem Ansatz im Vergleich zu den startService()/LocalBroadcast Technik sind

• Keine Notwendigkeit für Daten-Objekte zu implementieren, die Parcelable - dies ist besonders wichtig für mich, da bin ich nun der Austausch von code zwischen Android und iOS (mit RoboVM)
• RxJava bietet Dosen (und cross-Plattform) - Planung und der einfachen Zusammensetzung der sequentiell asynchronen Operationen.
• Dies sollte effizienter sein als die Verwendung eines LocalBroadcast, obwohl der Aufwand mit RxJava kann das aufwiegen.

Einige Beispiel-code. Zuerst der service:

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);
    }
} 

Und eine Tätigkeit, die an den Dienst bindet und erhält Druck-Höhe-updates:

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);
    }
}

Layout für diese Tätigkeit ist:

<?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>

Wenn der service muss im hintergrund laufen, ohne eine gebundene Tätigkeit, die er gestartet werden kann von der Application-Klasse als auch in OnCreate() mit Context#startService().

Meine Ursprüngliche Antwort (von 2013):

In Ihren Dienst: (mit COPA als service im Beispiel unten).

Verwenden LocalBroadCastManager. In Ihrem Dienst onCreate, einrichten der Sender:

broadcaster = LocalBroadcastManager.getInstance(this);

Wenn Sie möchten, Benachrichtigen Sie die UI etwas:

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);
}

In Ihre Tätigkeit:

Erstellen eines Listeners, der auf 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.
        }
    };
}

und registrieren Sie es in 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();
}

InformationsquelleAutor der Antwort Clyde

Ich mit einem gebunden-service zu tun und mit ihm zu kommunizieren durch die Implementierung einer listener in meiner Tätigkeit. Also, wenn Sie Ihre app implementiert myServiceListener, können Sie registrieren sich als listener in Ihren Dienst, nachdem Sie gebunden haben, rufen Hörer.onUpdateUI von Ihrem gebundenen service und update UI!

InformationsquelleAutor der Antwort psykhi

Clyde ' s Lösung funktioniert, aber es ist eine Sendung, die ich bin mir ziemlich sicher, dass es weniger effizient ist als der Aufruf einer Methode direkt. Ich könnte mich irren, aber ich denke, die Sendungen sind dazu gedacht, mehr für die inter-application communication.

Ich nehme an, Sie wissen bereits, wie zu binden eine Dienstleistung, die mit einer Aktivität.
Ich mache etwas in der Art, wie Sie den code unten, um mit dieser Art problem umzugehen:

class MyService extends Service {
    MyFragment mMyFragment = null;
    MyFragment mMyOtherFragment = null;

    private void networkLoop() {
        ...

        //received new data for list.
        if(myFragment != null)
            myFragment.updateList();
        }

        ...

        //received new data for textView
        if(myFragment !=null)
            myFragment.updateText();

        ...

        //received new data for textView
        if(myOtherFragment !=null)
            myOtherFragment.updateSomething();

        ...
    }
}


class MyFragment extends Fragment {

    public void onResume() {
        super.onResume()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyFragment=this;
    }

    public void onPause() {
        super.onPause()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyFragment=null;
    }

    public void updateList() {
        runOnUiThread(new Runnable() {
            public void run() {
                //Update the list.
            }
        });
    }

    public void updateText() {
       //as above
    }
}

class MyOtherFragment extends Fragment {
             public void onResume() {
        super.onResume()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyOtherFragment=this;
    }

    public void onPause() {
        super.onPause()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyOtherFragment=null;
    }

    public void updateSomething() {//etc... }
}

Ließ ich bits für die thread-Sicherheit, die unerlässlich ist. Stellen Sie sicher, zu sperren oder so etwas wie, dass bei der Prüfung und mit oder ändern Sie das fragment verweist auf die service.

InformationsquelleAutor der Antwort Reynard

Meine Lösung ist vielleicht nicht die sauberste, aber es sollte funktionieren ohne Probleme.
Die Logik ist einfach, erstellen Sie eine statische variable zum speichern Ihrer Daten auf der Service und aktualisieren Sie Ihre anzeigen in jeder Sekunde auf Ihren Activity.

Lassen Sie uns sagen, dass Sie String auf Ihre Service dass Sie möchten, senden Sie es zu einem TextView auf Ihre Activity. Es sollte so Aussehen

Ihren Dienst:

public class TestService extends Service {
    public static String myString = "";
    //Do some stuff with myString

Ihre Activty:

public class TestActivity extends Activity {
    TextView tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        tv = new TextView(this);
        setContentView(tv);
        update();
        Thread t = new Thread() {
            @Override
            public void run() {
                try {
                    while (!isInterrupted()) {
                        Thread.sleep(1000);
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                update();
                            }
                        });
                    }
                } catch (InterruptedException ignored) {}
            }
        };
        t.start();
        startService(new Intent(this, TestService.class));
    }
    private void update() {
        //update your interface here
        tv.setText(TestService.myString);
    }
}

InformationsquelleAutor der Antwort Naheel