例：メッセージングを使用したアクティビティとサービス間の通信

Question

アクティビティとサービスの間でメッセージを送信する方法の例を見つけることができませんでした。そして、これを理解するのに非常に長い時間を費やしました。これは他の人が参照するためのサンプルプロジェクトです。

この例では、サービスを直接開始または停止したり、サービスから個別にバインド/バインド解除することができます。サービスが実行されているとき、それは10 Hzで数を増やします。アクティビティがServiceにバインドされている場合は、現在の値が表示されます。データは整数としても文字列としても転送されるので、その2通りの方法がわかります。アクティビティにはメッセージをサービスに送信するためのボタンもあります（値の増加を変更します）。

スクリーンショット：

AndroidManifest.xml：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
      package="com.exampleservice"
      Android:versionCode="1"
      Android:versionName="1.0">
    <application Android:icon="@drawable/icon" Android:label="@string/app_name">
        <activity Android:name=".MainActivity"
                  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=".MyService"></service>
    </application>
    <uses-sdk Android:minSdkVersion="8" />
</manifest>

res\values\strings.xml：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">ExampleService</string>
    <string name="service_started">Example Service started</string>
    <string name="service_label">Example Service Label</string>
</resources>

res\layout\main.xml：

<RelativeLayout
    Android:id="@+id/RelativeLayout01"
    Android:layout_width="fill_parent"
    Android:layout_height="wrap_content" >

    <Button
        Android:id="@+id/btnStart"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:text="Start Service" >
    </Button>

    <Button
        Android:id="@+id/btnStop"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:layout_alignParentRight="true"
        Android:text="Stop Service" >
    </Button>
</RelativeLayout>

<RelativeLayout
    Android:id="@+id/RelativeLayout02"
    Android:layout_width="fill_parent"
    Android:layout_height="wrap_content" >

    <Button
        Android:id="@+id/btnBind"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:text="Bind to Service" >
    </Button>

    <Button
        Android:id="@+id/btnUnbind"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:layout_alignParentRight="true"
        Android:text="Unbind from Service" >
    </Button>
</RelativeLayout>

<TextView
    Android:id="@+id/textStatus"
    Android:layout_width="fill_parent"
    Android:layout_height="wrap_content"
    Android:text="Status Goes Here"
    Android:textSize="24sp" />

<TextView
    Android:id="@+id/textIntValue"
    Android:layout_width="fill_parent"
    Android:layout_height="wrap_content"
    Android:text="Integer Value Goes Here"
    Android:textSize="24sp" />

<TextView
    Android:id="@+id/textStrValue"
    Android:layout_width="fill_parent"
    Android:layout_height="wrap_content"
    Android:text="String Value Goes Here"
    Android:textSize="24sp" />

<RelativeLayout
    Android:id="@+id/RelativeLayout03"
    Android:layout_width="fill_parent"
    Android:layout_height="wrap_content" >

    <Button
        Android:id="@+id/btnUpby1"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:text="Increment by 1" >
    </Button>

    <Button
        Android:id="@+id/btnUpby10"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:layout_alignParentRight="true"
        Android:text="Increment by 10" >
    </Button>
</RelativeLayout>

src\com.exampleservice\MainActivity.Java：

package com.exampleservice;

import Android.app.Activity;
import Android.content.ComponentName;
import Android.content.Context;
import Android.content.Intent;
import Android.content.ServiceConnection;
import Android.os.Bundle;
import Android.os.Handler;
import Android.os.IBinder;
import Android.os.Message;
import Android.os.Messenger;
import Android.os.RemoteException;
import Android.util.Log;
import Android.view.View;
import Android.view.View.OnClickListener;
import Android.widget.Button;
import Android.widget.TextView;

public class MainActivity extends Activity {
    Button btnStart, btnStop, btnBind, btnUnbind, btnUpby1, btnUpby10;
    TextView textStatus, textIntValue, textStrValue;
    Messenger mService = null;
    boolean mIsBound;
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MyService.MSG_SET_INT_VALUE:
                textIntValue.setText("Int Message: " + msg.arg1);
                break;
            case MyService.MSG_SET_STRING_VALUE:
                String str1 = msg.getData().getString("str1");
                textStrValue.setText("Str Message: " + str1);
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = new Messenger(service);
            textStatus.setText("Attached.");
            try {
                Message msg = Message.obtain(null, MyService.MSG_REGISTER_CLIENT);
                msg.replyTo = mMessenger;
                mService.send(msg);
            }
            catch (RemoteException e) {
                // In this case the service has crashed before we could even do anything with it
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been unexpectedly disconnected - process crashed.
            mService = null;
            textStatus.setText("Disconnected.");
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        btnStart = (Button)findViewById(R.id.btnStart);
        btnStop = (Button)findViewById(R.id.btnStop);
        btnBind = (Button)findViewById(R.id.btnBind);
        btnUnbind = (Button)findViewById(R.id.btnUnbind);
        textStatus = (TextView)findViewById(R.id.textStatus);
        textIntValue = (TextView)findViewById(R.id.textIntValue);
        textStrValue = (TextView)findViewById(R.id.textStrValue);
        btnUpby1 = (Button)findViewById(R.id.btnUpby1);
        btnUpby10 = (Button)findViewById(R.id.btnUpby10);

        btnStart.setOnClickListener(btnStartListener);
        btnStop.setOnClickListener(btnStopListener);
        btnBind.setOnClickListener(btnBindListener);
        btnUnbind.setOnClickListener(btnUnbindListener);
        btnUpby1.setOnClickListener(btnUpby1Listener);
        btnUpby10.setOnClickListener(btnUpby10Listener);

        restoreMe(savedInstanceState);

        CheckIfServiceIsRunning();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString("textStatus", textStatus.getText().toString());
        outState.putString("textIntValue", textIntValue.getText().toString());
        outState.putString("textStrValue", textStrValue.getText().toString());
    }
    private void restoreMe(Bundle state) {
        if (state!=null) {
            textStatus.setText(state.getString("textStatus"));
            textIntValue.setText(state.getString("textIntValue"));
            textStrValue.setText(state.getString("textStrValue"));
        }
    }
    private void CheckIfServiceIsRunning() {
        //If the service is running when the activity starts, we want to automatically bind to it.
        if (MyService.isRunning()) {
            doBindService();
        }
    }

    private OnClickListener btnStartListener = new OnClickListener() {
        public void onClick(View v){
            startService(new Intent(MainActivity.this, MyService.class));
        }
    };
    private OnClickListener btnStopListener = new OnClickListener() {
        public void onClick(View v){
            doUnbindService();
            stopService(new Intent(MainActivity.this, MyService.class));
        }
    };
    private OnClickListener btnBindListener = new OnClickListener() {
        public void onClick(View v){
            doBindService();
        }
    };
    private OnClickListener btnUnbindListener = new OnClickListener() {
        public void onClick(View v){
            doUnbindService();
        }
    };
    private OnClickListener btnUpby1Listener = new OnClickListener() {
        public void onClick(View v){
            sendMessageToService(1);
        }
    };
    private OnClickListener btnUpby10Listener = new OnClickListener() {
        public void onClick(View v){
            sendMessageToService(10);
        }
    };
    private void sendMessageToService(int intvaluetosend) {
        if (mIsBound) {
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, MyService.MSG_SET_INT_VALUE, intvaluetosend, 0);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                }
                catch (RemoteException e) {
                }
            }
        }
    }


    void doBindService() {
        bindService(new Intent(this, MyService.class), mConnection, Context.BIND_AUTO_CREATE);
        mIsBound = true;
        textStatus.setText("Binding.");
    }
    void doUnbindService() {
        if (mIsBound) {
            // If we have received the service, and hence registered with it, then now is the time to unregister.
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, MyService.MSG_UNREGISTER_CLIENT);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                }
                catch (RemoteException e) {
                    // There is nothing special we need to do if the service has crashed.
                }
            }
            // Detach our existing connection.
            unbindService(mConnection);
            mIsBound = false;
            textStatus.setText("Unbinding.");
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        try {
            doUnbindService();
        }
        catch (Throwable t) {
            Log.e("MainActivity", "Failed to unbind from the service", t);
        }
    }
}

src\com.exampleservice\MyService.Java：

package com.exampleservice;

import Java.util.ArrayList;
import Java.util.Timer;
import Java.util.TimerTask;

import Android.app.Notification;
import Android.app.NotificationManager;
import Android.app.PendingIntent;
import Android.app.Service;
import Android.content.Intent;
import Android.os.Bundle;
import Android.os.Handler;
import Android.os.IBinder;
import Android.os.Message;
import Android.os.Messenger;
import Android.os.RemoteException;
import Android.util.Log;

public class MyService extends Service {
    private NotificationManager nm;
    private Timer timer = new Timer();
    private int counter = 0, incrementby = 1;
    private static boolean isRunning = false;

    ArrayList<Messenger> mClients = new ArrayList<Messenger>(); // Keeps track of all current registered clients.
    int mValue = 0; // Holds last value set by a client.
    static final int MSG_REGISTER_CLIENT = 1;
    static final int MSG_UNREGISTER_CLIENT = 2;
    static final int MSG_SET_INT_VALUE = 3;
    static final int MSG_SET_STRING_VALUE = 4;
    final Messenger mMessenger = new Messenger(new IncomingHandler()); // Target we publish for clients to send messages to IncomingHandler.


    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
    class IncomingHandler extends Handler { // Handler of incoming messages from clients.
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MSG_REGISTER_CLIENT:
                mClients.add(msg.replyTo);
                break;
            case MSG_UNREGISTER_CLIENT:
                mClients.remove(msg.replyTo);
                break;
            case MSG_SET_INT_VALUE:
                incrementby = msg.arg1;
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }
    private void sendMessageToUI(int intvaluetosend) {
        for (int i=mClients.size()-1; i>=0; i--) {
            try {
                // Send data as an Integer
                mClients.get(i).send(Message.obtain(null, MSG_SET_INT_VALUE, intvaluetosend, 0));

                //Send data as a String
                Bundle b = new Bundle();
                b.putString("str1", "ab" + intvaluetosend + "cd");
                Message msg = Message.obtain(null, MSG_SET_STRING_VALUE);
                msg.setData(b);
                mClients.get(i).send(msg);

            }
            catch (RemoteException e) {
                // The client is dead. Remove it from the list; we are going through the list from back to front so this is safe to do inside the loop.
                mClients.remove(i);
            }
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("MyService", "Service Started.");
        showNotification();
        timer.scheduleAtFixedRate(new TimerTask(){ public void run() {onTimerTick();}}, 0, 100L);
        isRunning = true;
    }
    private void showNotification() {
        nm = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
        // In this sample, we'll use the same text for the ticker and the expanded notification
        CharSequence text = getText(R.string.service_started);
        // Set the icon, scrolling text and timestamp
        Notification notification = new Notification(R.drawable.icon, text, System.currentTimeMillis());
        // The PendingIntent to launch our activity if the user selects this notification
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0);
        // Set the info for the views that show in the notification panel.
        notification.setLatestEventInfo(this, getText(R.string.service_label), text, contentIntent);
        // Send the notification.
        // We use a layout id because it is a unique number.  We use it later to cancel.
        nm.notify(R.string.service_started, notification);
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("MyService", "Received start id " + startId + ": " + intent);
        return START_STICKY; // run until explicitly stopped.
    }

    public static boolean isRunning()
    {
        return isRunning;
    }


    private void onTimerTick() {
        Log.i("TimerTick", "Timer doing work." + counter);
        try {
            counter += incrementby;
            sendMessageToUI(counter);

        }
        catch (Throwable t) { //you should always ultimately catch all exceptions in timer tasks.
            Log.e("TimerTick", "Timer Tick Failed.", t);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (timer != null) {timer.cancel();}
        counter=0;
        nm.cancel(R.string.service_started); // Cancel the persistent notification.
        Log.i("MyService", "Service Stopped.");
        isRunning = false;
    }
}

Answer 1

LocalServiceの例 を見てください。

あなたのServiceは、自分自身のインスタンスをonBindと呼ぶ消費者に返します。その後、あなたは直接サービスと対話することができます。コールバックを取得できるように、サービスに独自のリスナーインタフェースを登録します。

Answer 2

サービスにデータを送るためにあなたは使うことができます：

Intent intent = new Intent(getApplicationContext(), YourService.class);
intent.putExtra("SomeData","ItValue");
startService(intent);

そしてonStartCommand（）でインサービスになった後、インテントからデータを取得します。

サービスからアプリケーションにデータまたはイベントを送信する場合（1つ以上のアクティビティの場合）

private void sendBroadcastMessage(String intentFilterName, int arg1, String extraKey) {
    Intent intent = new Intent(intentFilterName);
    if (arg1 != -1 && extraKey != null) {
        intent.putExtra(extraKey, arg1);
    }
    sendBroadcast(intent);
}

このメソッドはあなたのサービスから呼び出しています。あなたは単にあなたの活動のためにデータを送ることができます。

private void someTaskInYourService(){

    //For example you downloading from server 1000 files
    for(int i = 0; i < 1000; i++) {
        Thread.sleep(5000) // 5 seconds. Catch in try-catch block
        sendBroadCastMessage(Events.UPDATE_DOWNLOADING_PROGRESSBAR, i,0,"up_download_progress");
    }

データを含むイベントを受信するには、アクティビティにメソッドregisterBroadcastReceivers（）を作成して登録します。

private void registerBroadcastReceivers(){
    broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            int arg1 = intent.getIntExtra("up_download_progress",0);
            progressBar.setProgress(arg1);
        }
    };
    IntentFilter progressfilter = new IntentFilter(Events.UPDATE_DOWNLOADING_PROGRESS);
    registerReceiver(broadcastReceiver,progressfilter);

さらにデータを送信するには、メソッドsendBroadcastMessage();を変更します。覚えておいてください：あなたはonResume（）にブロードキャストを登録し、onStop（）メソッドに登録を解除しなければなりません！

_ update _

私のActivity＆Service間のコミュニケーションは使わないでください。これは間違った方法です。より良い経験のために、私たちのような特別なライブラリを使ってください。

1） EventBus greenrobotから

2） オットー Square Incから

P.S私は自分のプロジェクトでgreenrobotのEventBusだけを使っています、

Answer 3

注：サービスが実行されているかどうかを確認する必要はありません。CheckIfServiceIsRunning()は、実行されていない場合はbindService()によって開始されるためです。

また、bindService()が再度呼び出されるので、電話を回転させても、再びonCreate()にすることは望ましくありません。これを防ぐためにonConfigurationChanged()を必ず定義してください。

Answer 4

Messenger を使ったactivity/serviceコミュニケーションの良い例です。

一つのコメント： メソッドMyService.isRunning()は必須ではありません.. bindService()は何回でも実行できます。それに害はありません。

MyServiceが別のプロセスで実行されている場合、静的関数MyService.isRunning()は常にfalseを返します。そのため、この機能は必要ありません。

Answer 5

Message msg = Message.obtain(null, 2, 0, 0);
                    Bundle bundle = new Bundle();
                    bundle.putString("url", url);
                    bundle.putString("names", names);
                    bundle.putString("captions",captions); 
                    msg.setData(bundle);

それであなたはそれをサービスに送ります。あとで受け取る。

Answer 6

これが私がActivity-> Service Communicationを実装した方法です。

private static class MyResultReciever extends ResultReceiver {
     /**
     * Create a new ResultReceive to receive results.  Your
     * {@link #onReceiveResult} method will be called from the thread running
     * <var>handler</var> if given, or from an arbitrary thread if null.
     *
     * @param handler
     */
     public MyResultReciever(Handler handler) {
         super(handler);
     }

     @Override
     protected void onReceiveResult(int resultCode, Bundle resultData) {
         if (resultCode == 100) {
             //dostuff
         }
     }

それから私は私のサービスを開始するためにこれを使いました

protected void onCreate(Bundle savedInstanceState) {
MyResultReciever resultReciever = new MyResultReciever(handler);
        service = new Intent(this, MyService.class);
        service.putExtra("receiver", resultReciever);
        startService(service);
}

私のサービスで私は持っていた

public int onStartCommand(Intent intent, int flags, int startId) {
    if (intent != null)
        resultReceiver = intent.getParcelableExtra("receiver");
    return Service.START_STICKY;
}

お役に立てれば

Answer 7

素晴らしいチュートリアル、素晴らしいプレゼンテーション。きちんとしていて、シンプルで、短く、そして非常に説明的です。 notification.setLatestEventInfo(this, getText(R.string.service_label), text, contentIntent);メソッドはもうありません。 tranteが述べたように ここ 、良いアプローチは次のようになります。

private static final int NOTIFICATION_ID = 45349;

private void showNotification() {
    NotificationCompat.Builder builder =
            new NotificationCompat.Builder(this)
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setContentTitle("My Notification Title")
                    .setContentText("Something interesting happened");

    Intent targetIntent = new Intent(this, MainActivity.class);
    PendingIntent contentIntent = PendingIntent.getActivity(this, 0, targetIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    builder.setContentIntent(contentIntent);
    _nManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    _nManager.notify(NOTIFICATION_ID, builder.build());
}

@Override
public void onDestroy() {
    super.onDestroy();
    if (_timer != null) {_timer.cancel();}
    _counter=0;
    _nManager.cancel(NOTIFICATION_ID); // Cancel the persistent notification.
    Log.i("PlaybackService", "Service Stopped.");
    _isRunning = false;
}

私自身をチェックして、すべてが魅力のように働きます（活動とサービス名はオリジナルと異なるかもしれません）。

Answer 8

私はすべての答えを見ました。私は今日は最も堅牢な方法と伝えたいのです。それはあなたがActivity - Service - Dialog - Fragments（Everything）の間でコミュニケーションをとるようにするでしょう。

EventBus

私のプロジェクトで使用しているこのlibには、メッセージングに関連した優れた機能があります。

3ステップでEventBus

1. イベントを定義します。

   public static class MessageEvent { /* Additional fields if needed */ }

2. 加入者を準備します。

購読メソッドを宣言して注釈を付けます。オプションで スレッドモードを指定します ：

@Subscribe(threadMode = ThreadMode.MAIN) 
public void onMessageEvent(MessageEvent event) {/* Do something */};

加入者を登録および登録解除します。例えばAndroidでは、アクティビティとフラグメントは通常そのライフサイクルに従って登録する必要があります。

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
public void onStop() {
    super.onStop();
    EventBus.getDefault().unregister(this);
}

3. イベントを投稿：

   EventBus.getDefault().post(new MessageEvent());

アプリレベルの評価にこの依存関係を追加するだけです。

compile 'org.greenrobot:eventbus:3.1.1'

Answer 9

あなたのアクティビティを "implements Handler.Callback"で宣言することで、いくらかメモリを節約できたと私には思えます