Как сделать так, чтобы Android-сервис общался с Activity

251

Я пишу свое первое приложение для Android и пытаюсь наладить связь между услугами и действиями. У меня есть служба, которая будет работать в фоновом режиме и делать некоторые записи GPS и времени. У меня будет Активность, которая будет использоваться для запуска и остановки Сервиса.

Итак, во-первых, я должен быть в состоянии выяснить, работает ли Служба при запуске Действия. Здесь есть и другие вопросы, так что я думаю, что смогу это выяснить (но не стесняйтесь предлагать советы).

Моя настоящая проблема: если активность запущена, а служба запущена, мне нужен способ для отправки сообщений в активность. Простые строки и целые числа на данный момент - сообщения о статусе в основном. Сообщения не будут появляться регулярно, поэтому я не думаю, что опрос службы - это хороший способ, если есть другой путь. Я хочу получить это сообщение только тогда, когда действие было запущено пользователем - я не хочу запускать действие из службы. Другими словами, если вы запустите Activity, а служба будет запущена, вы увидите некоторые сообщения о состоянии в пользовательском интерфейсе Activity, когда произойдет что-то интересное. Если вы не запустите действие, вы не увидите эти сообщения (они не так интересны).

Похоже, я должен быть в состоянии определить, запущена ли служба, и если да, добавить активность в качестве прослушивателя. Затем удалите Activity как слушателя, когда Activity приостановится или остановится. Это действительно возможно? Единственный способ понять, как это сделать, - это заставить Activity реализовать Parcelable и создать файл AIDL, чтобы я мог передать его через удаленный интерфейс Сервиса. Хотя это кажется излишним, и я понятия не имею, как Activity должна реализовывать writeToParcel () / readFromParcel ().

Есть ли более простой или лучший способ? Спасибо за любую помощь.

РЕДАКТИРОВАТЬ:

Для тех, кто заинтересован в этом позже, есть пример кода от Google для обработки этого через AIDL в каталоге примеров: /apis/app/RemoteService.java

Скотт Сондерс
источник

Ответы:

94

Существует три очевидных способа общения с сервисами:

  1. Использование Intents
  2. Использование AIDL
  3. Использование самого сервисного объекта (как синглтона)

В вашем случае я бы выбрал вариант 3. Сделать статическую ссылку на сервис, который он сам, и заполнить его в onCreate ():

void onCreate(Intent i) {
  sInstance = this;
}

Сделайте статическую функцию MyService getInstance(), которая возвращает статическую sInstance.

Затем при Activity.onCreate()запуске службы асинхронно дождитесь, пока служба фактически не запустится (ваша служба может уведомить ваше приложение о готовности, отправив намерение в действие.), И получить его экземпляр. Когда у вас есть экземпляр, зарегистрируйте свой объект прослушивателя службы для вашей службы, и вы настроены. ПРИМЕЧАНИЕ: при редактировании представлений внутри Activity вы должны изменить их в потоке пользовательского интерфейса, сервис, вероятно, будет запускать свой собственный поток, поэтому вам нужно вызвать Activity.runOnUiThread().

Последнее, что вам нужно сделать, - это удалить ссылку на ваш объект слушателя Activity.onPause(), иначе экземпляр вашего контекста активности будет неэффективным.

ПРИМЕЧАНИЕ. Этот метод полезен только в том случае, если ваше приложение / действие / задача является единственным процессом, который будет обращаться к вашему сервису. Если это не так, вы должны использовать вариант 1. или 2.

MrSnowflake
источник
2
Как я могу busy-waitактивность? Объясните пожалуйста ?
iTurki
1
Поэтому либо после onCreate, либо после onStartCommand в вашем классе обслуживания установите открытую статическую переменную, назовите ее isConnected или что-то в true. Затем в своей Деятельности сделайте следующее: Intent intent = new Intent (act, YourService.class); StartService (намерение); while (! YourService.isConnected) {sleep (300); } После этого цикла ваш сервис работает, и вы можете установить с ним связь. По моему опыту, существуют определенные ограничения для взаимодействия с сервисом, подобным этому.
Мэтт Вулф
Почему это можно запустить только в Activity.onCreate()?
Skywall
Любое слово о том, почему вы не хотите использовать Intents, отправляя данные через Parcellableсообщения между ними?
Аман Алам
2
Это работает, но ответ @ MaximumGoat намного чище и не требует ожидания.
Мэтт
262

Аскер, вероятно, давно прошел мимо этого, но в случае, если кто-то еще ищет это ...

Есть другой способ справиться с этим, который, я думаю, может быть самым простым.

Добавьте BroadcastReceiverк своей деятельности. Зарегистрируйте его, чтобы получить какое-либо пользовательское намерение, onResumeи отмените его регистрацию onPause. Затем отправьте это намерение из вашей службы, если вы хотите отправить свои обновления статуса или что у вас есть.

Убедитесь, что вы не будете несчастны, если какое-то другое приложение прислушается к вашему Intent(может ли кто-нибудь сделать что-нибудь вредоносное?), Но кроме этого, вы должны быть в порядке.

Образец кода был запрошен:

В моем сервисе у меня есть это:

// Do stuff that alters the content of my local SQLite Database
sendBroadcast(new Intent(RefreshTask.REFRESH_DATA_INTENT));

( RefreshTask.REFRESH_DATA_INTENTэто просто постоянная строка.)

В своей деятельности по прослушиванию я определяю BroadcastReceiver:

private class DataUpdateReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(RefreshTask.REFRESH_DATA_INTENT)) {
          // Do stuff - maybe update my view based on the changed DB contents
        }
    }
}

Я объявляю мой получатель на вершине класса:

private DataUpdateReceiver dataUpdateReceiver;

Я переопределить, onResumeчтобы добавить это:

if (dataUpdateReceiver == null) dataUpdateReceiver = new DataUpdateReceiver();
IntentFilter intentFilter = new IntentFilter(RefreshTask.REFRESH_DATA_INTENT);
registerReceiver(dataUpdateReceiver, intentFilter);

И я переопределить, onPauseчтобы добавить:

if (dataUpdateReceiver != null) unregisterReceiver(dataUpdateReceiver);

Теперь я слушаю, как моя служба говорит: «Эй, иди обновляйся». Я мог бы передавать данные Intentвместо обновления таблиц базы данных и затем возвращаться, чтобы найти изменения в моей деятельности, но, поскольку я все равно хочу, чтобы изменения сохранялись, имеет смысл передавать данные через БД.

MaximumGoat
источник
5
Как? То, что вы описываете, это именно то, что мне нужно. Но более того, мне нужен полный пример кода. Заранее спасибо. К вашему сведению, в последний раз, когда я пытался написать виджет, обмен сообщениями занял у меня 2 месяца. Смейтесь, если хотите, но вы, эксперты, должны публиковать больше, так как IMHO Android сложнее, чем iOS!
1
aaaaaaa, в Руководстве по расширенной разработке Android для занятых программистов есть отличная глава о виджетах. Это единственный ресурс, который провел меня через этот беспорядок. Автор CommonsWare имеет репутацию 115 тыс. На StackOverflow, и я настоятельно рекомендую эту книгу. commonsware.com/AdvAndroid
MaximumGoat
64
Broadcastsэто фантастика, и, кроме того, если вы не хотите, чтобы ваша трансляция выходила за рамки вашего собственного процесса, рассмотрите возможность использования LocalBroadcast: developer.android.com/reference/android/support/v4/content/…
Cody Caughlan
2
Спасибо, Коди, я раньше такого не видел.
MaximumGoat
3
Это очень хороший способ общения. Но что делать, если результаты были достигнуты, когда активность была в состоянии паузы? Так что после активности onResume можно долго ждать результатов. И никакие данные не будут получены, потому что данные были пропущены.
Антон-М
39

Используйте, LocalBroadcastManagerчтобы зарегистрировать получателя для прослушивания трансляции, отправленной с локального сервиса внутри вашего приложения, ссылка здесь:

http://developer.android.com/reference/android/support/v4/content/LocalBroadcastManager.html

Джек Гао
источник
3
Да, очень хорошая дискуссия о местной трансляции здесь ссылка
SohailAziz
1
LocalBroadcastManagerтеперь осуждается в пользу LiveDataили других инструментов шаблона наблюдателя: developer.android.com/reference/androidx/localbroadcastmanager/...
Али NEM
20

Я удивлен, что никто не дал ссылку на библиотеку событий Отто

http://square.github.io/otto/

Я использую это в моих приложениях для Android, и это работает без проблем.

Мадхур Ахаджа
источник
7
Кроме того, есть библиотека EventBus Greenrobot .
Джаззер
15
Но помните, что EventBus и otto всегда в одном процессе. Когда вы используете службу, которая находится в своем собственном процессе (началось с настройки, android:process=":my_service"они не могут общаться.
Ron
20

Использование Messenger - это еще один простой способ связи между Сервисом и Деятельностью.

В действии создайте обработчик с соответствующим мессенджером. Это будет обрабатывать сообщения от вашего Сервиса.

class ResponseHandler extends Handler {
    @Override public void handleMessage(Message message) {
            Toast.makeText(this, "message from service",
                    Toast.LENGTH_SHORT).show();
    }
}
Messenger messenger = new Messenger(new ResponseHandler());

Посланник может быть передан в службу, прикрепив его к сообщению:

Message message = Message.obtain(null, MyService.ADD_RESPONSE_HANDLER);
message.replyTo = messenger;
try {
    myService.send(message);
catch (RemoteException e) {
    e.printStackTrace();
}

Полный пример можно найти в демонстрациях API: MessengerService и MessengerServiceActivity . Обратитесь к полному примеру, чтобы узнать, как работает MyService.

Кьетил
источник
1
Очень признателен! Работает отлично. Просто деталь в коде: myService.send(message);должно быть messenger.send(message);вместо.
Федерико Кристина
9

Другой метод, который не упоминается в других комментариях, - это привязка к сервису из действия с использованием bindService () и получение экземпляра сервиса в обратном вызове ServiceConnection. Как описано здесь http://developer.android.com/guide/components/bound-services.html

Мигел
источник
4
Это правильный способ получения ссылки на экземпляр службы.
김준호
9

Вы также можете использовать LiveDataэто работает как EventBus.

class MyService : LifecycleService() {
    companion object {
        var BUS = MutableLiveData<Object>()
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        super.onStartCommand(intent, flags, startId)

        val testItem : Object

        // expose your data
        if (BUS.hasActiveObservers()) {
            BUS.postValue(testItem)
        }

        return START_NOT_STICKY
    }
}

Затем добавьте наблюдателя от вашего Activity.

MyService.BUS.observe(this, Observer {
    it?.let {
        // Do what you need to do here
    }
})

Вы можете прочитать больше из этого блога.

zeenosaur
источник
2

Другим способом может быть использование наблюдателей с поддельным классом модели через деятельность и сам сервис, реализуя вариацию шаблона MVC. Я не знаю, является ли это лучшим способом для достижения этой цели, но это способ, который работал для меня. Если вам нужен пример, попросите об этом, и я что-нибудь опубликую.

ReDirEct__
источник
Я борюсь с подобными мыслями. У меня есть активность и 2 службы, которые имеют ту же модель. Модель может быть обновлена ​​в любом действии или в любом другом сервисе, поэтому я как-то думал об использовании Observers, но не могу понять. Можете ли вы опубликовать пример, чтобы показать свою идею?
Пзо
2

Мой метод:

Класс для управления отправкой и получением сообщения от / к службе / деятельности:

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 java.util.ArrayList;
import java.util.List;

public class MessageManager {

    public interface IOnHandleMessage{
        // Messages
        int MSG_HANDSHAKE = 0x1;

        void onHandleMessage(Message msg);
    }

    private static final String LOGCAT = MessageManager.class.getSimpleName();

    private Messenger mMsgSender;
    private Messenger mMsgReceiver;
    private List<Message> mMessages;

    public MessageManager(IOnHandleMessage callback, IBinder target){
        mMsgReceiver = new Messenger(new MessageHandler(callback, MessageHandler.TYPE_ACTIVITY));
        mMsgSender = new Messenger(target);
        mMessages = new ArrayList<>();
    }

    public MessageManager(IOnHandleMessage callback){
        mMsgReceiver = new Messenger(new MessageHandler(callback, MessageHandler.TYPE_SERVICE));
        mMsgSender = null;
        mMessages = new ArrayList<>();
    }

    /* START Getter & Setter Methods */
    public Messenger getMsgSender() {
        return mMsgSender;
    }

    public void setMsgSender(Messenger sender) {
        this.mMsgSender = sender;
    }

    public Messenger getMsgReceiver() {
        return mMsgReceiver;
    }

    public void setMsgReceiver(Messenger receiver) {
        this.mMsgReceiver = receiver;
    }

    public List<Message> getLastMessages() {
        return mMessages;
    }

    public void addMessage(Message message) {
        this.mMessages.add(message);
    }
    /* END Getter & Setter Methods */

    /* START Public Methods */
    public void sendMessage(int what, int arg1, int arg2, Bundle msgData){
        if(mMsgSender != null && mMsgReceiver != null) {
            try {
                Message msg = Message.obtain(null, what, arg1, arg2);
                msg.replyTo = mMsgReceiver;
                if(msgData != null){
                    msg.setData(msgData);
                }
                mMsgSender.send(msg);
            } catch (RemoteException rE) {
                onException(rE);
            }
        }
    }

    public void sendHandshake(){
        if(mMsgSender != null && mMsgReceiver != null){
            sendMessage(IOnHandleMessage.MSG_HANDSHAKE, 0, 0, null);
        }
    }
    /* END Public Methods */

    /* START Private Methods */
    private void onException(Exception e){
        Log.e(LOGCAT, e.getMessage());
        e.printStackTrace();
    }
    /* END Private Methods */

    /** START Private Classes **/
    private class MessageHandler extends Handler {

        // Types
        final static int TYPE_SERVICE = 0x1;
        final static int TYPE_ACTIVITY = 0x2;

        private IOnHandleMessage mCallback;
        private int mType;

        public MessageHandler(IOnHandleMessage callback, int type){
            mCallback = callback;
            mType = type;
        }

        @Override
        public void handleMessage(Message msg){
            addMessage(msg);
            switch(msg.what){
                case IOnHandleMessage.MSG_HANDSHAKE:
                    switch(mType){
                        case TYPE_SERVICE:
                            setMsgSender(msg.replyTo);
                            sendHandshake();
                            break;
                        case TYPE_ACTIVITY:
                            Log.v(LOGCAT, "HERE");
                            break;
                    }
                    break;
                default:
                    if(mCallback != null){
                        mCallback.onHandleMessage(msg);
                    }
                    break;
            }
        }

    }
    /** END Private Classes **/

}

В примере деятельности:

public class activity extends AppCompatActivity
      implements     ServiceConnection,
                     MessageManager.IOnHandleMessage { 

    [....]

    private MessageManager mMessenger;

    private void initMyMessenger(IBinder iBinder){
        mMessenger = new MessageManager(this, iBinder);
        mMessenger.sendHandshake();
    }

    private void bindToService(){
        Intent intent = new Intent(this, TagScanService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
        /* START THE SERVICE IF NEEDED */
    }

    private void unbindToService(){
    /* UNBIND when you want (onDestroy, after operation...)
        if(mBound) {
            unbindService(mServiceConnection);
            mBound = false;
        }
    }

    /* START Override MessageManager.IOnHandleMessage Methods */
    @Override
    public void onHandleMessage(Message msg) {
        switch(msg.what){
            case Constants.MSG_SYNC_PROGRESS:
                Bundle data = msg.getData();
                String text = data.getString(Constants.KEY_MSG_TEXT);
                setMessageProgress(text);
                break;
            case Constants.MSG_START_SYNC:
                onStartSync();
                break;
            case Constants.MSG_END_SYNC:
                onEndSync(msg.arg1 == Constants.ARG1_SUCCESS);
                mBound = false;
                break;
        }
    }
    /* END Override MessageManager.IOnHandleMessage Methods */

    /** START Override ServiceConnection Methods **/
    private class BLEScanServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            initMyMessenger(iBinder);
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mMessenger = null;
            mBound = false;
        }
    }
    /** END Override ServiceConnection Methods **/

В примере обслуживания:

public class Blablabla extends Service
    implements     MessageManager.IOnHandleMessage {

    [...]

    private MessageManager mMessenger;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        super.onBind(intent);
        initMessageManager();
        return mMessenger.getMsgReceiver().getBinder();
    }

    private void initMessageManager(){
        mMessenger = new MessageManager(this);
    }

    /* START Override IOnHandleMessage Methods */
    @Override
    public void onHandleMessage(Message msg) {
    /* Do what you want when u get a message looking the "what" attribute */
    }
    /* END Override IOnHandleMessage Methods */

Отправить сообщение от Activity / Service:

mMessenger.sendMessage(what, arg1, arg2, dataBundle);

Как это работает:

на активности вы запускаете или привязываете сервис. Методы «OnBind» службы возвращают Binder его MessageManager. В Activity через реализацию методов интерфейса «Service Connection» «OnServiceConnected» вы получаете этот IBinder и инициализируете его с помощью MessageManager. После того, как Activity инициирует свой MessageManager, MessageHandler отправляет и Handshake в службу, чтобы он мог установить своего отправителя «MessageHandler» («private Messenger mMsgSender;» в MessageManager). При этом сервис узнает, кто отправляет его сообщения.

Вы также можете реализовать это с помощью «отправителя» Списка / Очереди Messenger в MessageManager, чтобы вы могли отправлять несколько сообщений в разные Действия / Службы, или вы можете использовать «получатель» Списка / Очереди Messenger в MessageManager, чтобы вы могли получить несколько сообщение из разных видов деятельности / услуг.

В экземпляре «MessageManager» у вас есть список всех полученных сообщений.

Как вы можете видеть, соединение между «Activity Messenger» и «Service Messenger» с помощью этого экземпляра «MessageManager» является автоматическим, оно выполняется с помощью метода «OnServiceConnected» и с помощью «Рукопожатия».

Надеюсь, что это полезно для вас :) Большое спасибо! Пока: D

Z3R0
источник
2

Чтобы ответить на вопрос @MrSnowflake, приведите пример кода. Это XABBER в настоящее время с открытым исходным кодом Applicationкласса . ApplicationКласс централизации и координации Listenersи ManagerInterfaces и многое другое. Менеджеры всех видов загружаются динамически. Activity´sЗапущенный в Xabber сообщит в каком Listenerони виде. И когда Serviceначало это сообщить в Applicationклассе, как началось. Теперь , чтобы отправить сообщение на Activityвсе , что вам нужно сделать , это сделать ваш Activityстать listenerкакой тип вам нужно. В OnStart() OnPause()реестре / отрег. Он Serviceможет попросить Applicationкласс о том, с чем listenerему нужно поговорить, и если он там, то действие готово к получению.

Пройдя через Applicationурок, вы увидите, что происходит гораздо больше, чем это.

Erik
источник
Предоставленная ссылка теперь приводит к появлению github 404. Переместился ли он?
Картер II
Да, похоже, сейчас работает. Должно быть, временная проблема на github.
Картер II
1

Связывание - это еще один способ общения

Создать обратный звонок

public interface MyCallBack{

   public void getResult(String result);

}

Сторона деятельности:

  1. Реализуйте интерфейс в Activity

  2. Обеспечить реализацию метода

  3. Привязать активность к сервису

  4. Зарегистрируйтесь и отмените обратный вызов, когда Служба будет связана и не связана с Активностью.

    public class YourActivity extends AppCompatActivity implements MyCallBack{
    
          private Intent notifyMeIntent;
          private GPSService gpsService;
          private boolean bound = false;
    
          @Override
          public void onCreate(Bundle sis){
    
              // activity code ...
    
              startGPSService();
    
          }
    
          @Override
          public void getResult(String result){
           // show in textView textView.setText(result);
          }
    
          @Override
          protected void onStart()
          {
              super.onStart();
              bindService();
          }
    
          @Override
          protected void onStop() {
              super.onStop();
              unbindService();
          }
    
          private ServiceConnection serviceConnection = new ServiceConnection() {
    
                @Override
                public void onServiceConnected(ComponentName className, IBinder service) {
    
                      GPSService.GPSBinder binder = (GPSService.GPSBinder) service;
                      gpsService= binder.getService();
                      bound = true;
                      gpsService.registerCallBack(YourActivity.this); // register
    
               }
    
               @Override
               public void onServiceDisconnected(ComponentName arg0) {
                      bound = false;
               }
          };
    
          private void bindService() {
    
               bindService(notifyMeIntent, serviceConnection, Context.BIND_AUTO_CREATE);
          }
    
          private void unbindService(){
               if (bound) {
                     gpsService.registerCallBack(null); // unregister            
                     unbindService(serviceConnection);
                     bound = false;
                }
          }
    
          // Call this method somewhere to start Your GPSService
          private void startGPSService(){
               notifyMeIntent = new Intent(this, GPSService.class);
               startService(myIntent );
          }
    
     }

Сторона обслуживания:

  1. Инициализировать обратный вызов

  2. При необходимости вызывайте метод обратного вызова.

     public class GPSService extends Service{
    
         private MyCallBack myCallback;
         private IBinder serviceBinder = new GPSBinder();
    
         public void registerCallBack(MyCallBack myCallback){
              this.myCallback= myCallback;
         }
    
         public class GPSBinder extends Binder{
    
             public GPSService getService(){
                  return GPSService.this;
             }
        }
    
        @Nullable
        @Override
        public IBinder onBind(Intent intent){
             return serviceBinder;
        }
     }
Рохит Сингх
источник
ваш serviceConnectionвне onCreate. Пожалуйста, отредактируйте его.
Адель Зафар
Это не должно быть внутри onCreate
Рохит Сингх
0

Как упомянул Мадхур, вы можете использовать автобус для общения.

В случае использования шины у вас есть несколько вариантов:

Библиотека шины событий Otto (устарела в пользу RxJava)

http://square.github.io/otto/

Зеленый робот EventBus

http://greenrobot.org/eventbus/

NYBus (RxBus, реализованный с использованием RxJava. Очень похож на EventBus)

https://github.com/MindorksOpenSource/NYBus

Mahpooya
источник
0

Помимо LocalBroadcastManager, Event Bus и Messenger уже ответили на этот вопрос, мы можем использовать Pending Intent для связи с сервисом.

Как уже упоминалось здесь, в моем блоге

Связь между сервисом и Activity может быть осуществлена ​​с помощью PendingIntent. Для этого мы можем использовать createPendingResult () .createPendingResult () создает новый объект PendingIntent, который вы можете передать службе и использовать для отправки данных результата обратно в вашу деятельность внутри onActivityResult (int, int, Intent) callback. Поскольку PendingIntent имеет значение Parcelable, и поэтому его можно поместить в дополнительный Intent, ваша деятельность может передать этот PendingIntent службе. Служба, в свою очередь, может вызвать метод send () в PendingIntent, чтобы уведомить активность через onActivityResult события.

Деятельность

public class PendingIntentActivity extends AppCompatActivity
{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

PendingIntent pendingResult = createPendingResult(
100, new Intent(), 0);
Intent intent = new Intent(getApplicationContext(), PendingIntentService.class);
intent.putExtra("pendingIntent", pendingResult);
startService(intent);

}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == 100 && resultCode==200) {
Toast.makeText(this,data.getStringExtra("name"),Toast.LENGTH_LONG).show();
}
super.onActivityResult(requestCode, resultCode, data);
}
}

обслуживание

public class PendingIntentService extends Service {

    private static final String[] items= { "lorem", "ipsum", "dolor",
            "sit", "amet", "consectetuer", "adipiscing", "elit", "morbi",
            "vel", "ligula", "vitae", "arcu", "aliquet", "mollis", "etiam",
            "vel", "erat", "placerat", "ante", "porttitor", "sodales",
            "pellentesque", "augue", "purus" };
    private PendingIntent data;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        data = intent.getParcelableExtra("pendingIntent");

        new LoadWordsThread().start();
        return START_NOT_STICKY;
    }

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

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    class LoadWordsThread extends Thread {
        @Override
        public void run() {
            for (String item : items) {
                if (!isInterrupted()) {

                    Intent result = new Intent();
                    result.putExtra("name", item);
                    try {
                        data.send(PendingIntentService.this,200,result);
                    } catch (PendingIntent.CanceledException e) {

                        e.printStackTrace();
                    }
                    SystemClock.sleep(400);

                }
            }
        }
    }
}
Android-разработчик
источник