Может кто-нибудь, пожалуйста, покажет мне пример того, что можно сделать с помощью IntentService, который не может быть выполнен с помощью Service (и наоборот)?
Я также считаю, что IntentService работает в другом потоке, а Service - нет. Итак, насколько я вижу, запуск службы в рамках собственного потока похож на запуск IntentService. Разве это не?
Буду признателен, если кто-то может помочь мне с обоими моими вопросами.
Tejas Lagvankar написал хороший пост об этой теме. Ниже приведены некоторые ключевые различия между сервисом и IntentService.
Когда использовать?
Служба может использоваться в задачах без пользовательского интерфейса, но не должна быть слишком длинной. Если вам нужно выполнять длительные задачи, вы должны использовать потоки в службе.
IntentService может использоваться в длинных задачах, обычно без связи с главной нитью. Если требуется связь, можно использовать обработчик Main Thread или трансляцию. Другой случай использования - когда требуются обратные вызовы (запущенные задачи Intent).
Как запустить?
Служба запускается методом вызова startService().
IntentService запускается с использованием Intent, он создает новый рабочий поток, и в этом потоке вызывается метод onHandleIntent().
Запуск из
Выполняется
Служба работает в фоновом режиме, но работает в основном потоке приложения.
IntentService работает на отдельном рабочем потоке.
Ограничения/Недостатки
Служба может блокировать главный поток приложения.
IntentService не может запускать задачи параллельно. Следовательно, все последовательные намерения войдут в очередь сообщений для рабочего потока и будут выполняться последовательно.
Когда останавливаться?
Если вы внедряете Сервис, вы обязаны прекратить обслуживание, когда его работа будет выполнена, вызывая stopSelf() или stopService(). (Если вы хотите предоставить привязку, вам не нужно реализовывать этот метод).
IntentService останавливает службу после того, как все начальные запросы были обработаны, поэтому вам не нужно вызывать stopSelf().
Если кто-то может показать мне пример того, что вы можете сделать с помощью намерения, и не может быть сделано с Сервисом и наоборот.
По определению это невозможно. IntentService является подклассом Service, написанным на Java-коде. Следовательно, что-либо, что делает IntentService, a Service, путем включения соответствующих бит кода, который использует IntentService.
Запуск службы с собственным потоком - это как запуск IntentService. Разве это не?
Три основных элемента IntentService:
фоновый поток
автоматический порядок Intent доставляется на onStartCommand(), поэтому, если один Intent обрабатывается onHandleIntent() в фоновом потоке, остальные команды ждут очереди в очереди
автоматическое выключение IntentService, путем вызова stopSelf(), когда очередь пуста
Любое и все это может быть реализовано с помощью Service без расширения IntentService.
Различия
main, а IntentService создает поток worker и использует этот поток для запуска службы. onHandleIntent(). Таким образом, реализация многопоточного потока должна выполняться путем непосредственного распространения класса сервиса. stopSelf(). Тем временем IntentService автоматически останавливается, когда в очереди нет намерений, обрабатываются все очереди. onBind(), который возвращает null. Это означает, что IntentService не может быть привязан по умолчанию. onStartCommand(), который отправляет Intent в очередь и на onHandleIntent().Сервис
IntentService
Добавление точек к принятому ответу:
См. использование IntentService в Android API. например:
public class SimpleWakefulService extends IntentService {
public SimpleWakefulService() {
super("SimpleWakefulService");
}
@Override
protected void onHandleIntent(Intent intent) { ...}
Чтобы создать компонент IntentService для вашего приложения, определите класс, который расширяет IntentService и внутри него, определите метод, который переопределяет onHandleIntent().
Также см. исходный код IntentService, его методы консцессора и жизненного цикла, такие как onStartCommand..
@Override
public int More ...onStartCommand(Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
Сервис вместе AsyncTask - один из лучших подходов для многих где нет полезной нагрузки. или просто создать класс расширяя IntentSerivce. Начиная с версии 4.0 Android всей сети операции должны выполняться в фоновом режиме, иначе сбой компиляции/сборки приложения. отдельный поток из пользовательского интерфейса. Класс AsyncTask предоставляет один из самых простых способов запуска новой задачи из потока пользовательского интерфейса. Подробнее об этой теме см. В сообщении в блоге
из руководство для разработчиков Android:
IntentService - это базовый класс для служб, которые обрабатывают асинхронные запросы (выраженные как намерения) по требованию. Клиенты отправляют запросы через вызовы startService (Intent); служба запускается по мере необходимости, обрабатывает каждое намерение по очереди с использованием рабочего потока и останавливается при завершении работы.
Схема проектирования, используемая в IntentService
: Этот шаблон "Work queue processor" обычно используется для выгрузки задач из основного потока приложения. Класс IntentService существует, чтобы упростить этот шаблон и позаботиться о механике. Чтобы использовать его, расширьте IntentService и реализуйте onHandleIntent (Intent). IntentService получит Intents, запустит рабочий поток и прекратит обслуживание по мере необходимости.
Все запросы обрабатываются на одном рабочем потоке - они могут занимать столько времени, сколько необходимо (и не будут блокировать основной цикл приложения), но только один запрос будет обрабатываться одновременно.
Класс IntentService обеспечивает прямую структуру для запуска операции на одном фоновом потоке. Это позволяет обрабатывать длительные операции, не влияя на отзывчивость вашего пользовательского интерфейса. Кроме того, IntentService не влияет на большинство событий жизненного цикла пользовательского интерфейса, поэтому он продолжает работать в обстоятельствах, которые закрывали бы AsyncTask.
У IntentService есть несколько ограничений:
Он не может напрямую взаимодействовать с вашим пользовательским интерфейсом. Чтобы привести свои результаты в пользовательский интерфейс, вы должны отправить их в Activity. Рабочие запросы выполняются последовательно. Если в IntentService выполняется операция, и вы отправляете ей другой запрос, запрос ожидает завершения первой операции. Невозможно прервать операцию, запущенную на IntentService. Однако в большинстве случаев
IntentService является предпочтительным способом для простых фоновых операций
**
Библиотека волейбола
Существует библиотека, называемая volley-library для разработки приложений для Android. Исходный код доступен для публики в github.
Официальная документация по android для Лучшая практика для фоновых заданий: помогает лучше понять работу службы, поток, обработчик, сервис. а также Выполнение сетевых операций
Я уверен, что вы можете найти обширный список различий, просто используя googling, например "Android IntentService vs Service"
Одним из наиболее важных различий в примере является то, что IntentService завершается сам по себе.
Некоторые примеры (быстро составленные) могут быть;
IntentService: если вы хотите загрузить кучу изображений в начале открытия своего приложения. Это одноразовый процесс и может очистить себя, как только все будет загружено.
Служба: Служба, которая будет постоянно использоваться для связи между вашим приложением и внутренним концом с помощью вызовов веб-API. Даже если это завершено с его текущей задачей, вы все равно хотите, чтобы это было несколько минут спустя, для большей коммуникации.
IntentService работает в своем потоке.
Когда это будет сделано, он остановится. Больше похоже на огонь и забыть.
Последующие вызовы будут поставлены в очередь. Хорошо для вызовов в очереди.
Вы также можете открутить несколько потоков в IntentService, если вам нужно - вы можете достичь этого, используя ThreadPoolExecutor.
Я говорю это, потому что многие спрашивали меня: "зачем использовать IntentService, поскольку он не поддерживает параллельное выполнение".
IntentService - это просто поток. Вы можете делать все, что вам нужно, внутри - даже вращая несколько потоков. Только оговорка заключается в том, что IntentService завершается, как только вы вращаете эти несколько потоков. Он не ждет, пока эти потоки вернутся. Вам нужно позаботиться об этом. Поэтому я рекомендую использовать ThreadPoolExecutor в этих сценариях.
По умолчанию Service выполняется в основном потоке. Вам нужно открутить рабочий поток, чтобы выполнить свою работу.
Вам нужно остановить Service явно.
Я использовал его для ситуации, когда вам нужно запускать материал в фоновом режиме, даже когда вы отходите от своего приложения и возвращаетесь больше для безголового Service.
Вы всегда можете вернуться к своей деятельности, используя BroadcastReceivers, если вам нужно.
IntentService - это расширение службы, которая предназначена для облегчения выполнения задачи, которая должна выполняться в фоновом режиме и в отдельном потоке.
IntentService запускается, создает поток и запускает его задачу в потоке. как только это сделано, он очищает все. Одновременно может запускаться только один экземпляр IntentService, несколько вызовов помещаются в очередь.
Он очень прост в использовании и очень удобен для многих применений, например, для загрузки файлов. Но у него есть ограничения, которые могут заставить вас вместо этого использовать более базовую (не просто) Сервис.
Например, сервис, подключенный к серверу xmpp и связанный с действиями, не может быть просто выполнен с использованием IntentService. Вы в конечном итоге игнорируете или переопределяете материалы IntentService.
Если кто-то может показать мне пример того, что вы можете сделать с помощью
IntentServiceи не может быть сделано с помощьюserviceи наоборот.
IntentService не может использоваться для длительного прослушивания, как и для слушателей XMPP, его одноразовый оператор, выполняет задание и прощается с волной.
Также он имеет только один threadworker, но с трюком вы можете использовать его как неограниченное.
Основное отличие:
Для класса обслуживания требуется ручная остановка с использованием stopSelf(). Тем временем IntentService автоматически останавливается, когда в очереди нет намерений.
IntentService обычно может использоваться в длинных задачах, но если вам нужно выполнять длительные задачи, вы должны использовать потоки в службе.
Основное различие между a Service и a IntentService описывается следующим образом:
Сервис:
1.A Service по умолчанию работает в главном потоке приложения (здесь нет рабочего потока по умолчанию). Таким образом, пользователю необходимо создать отдельный поток и выполнить необходимую работу в этом потоке.
2.Allows Несколько запросов за раз. (Multi Threading)
IntentService:
1. Теперь, придя в Intent Service, здесь доступен рабочий поток по умолчанию для выполнения любой операции. Обратите внимание: - вам нужно реализовать метод onHandleIntent(), который получает намерение для каждого запроса на запуск, где вы можете выполнить фоновая работа.
2. Но он позволяет одновременно выполнять только один запрос.
IntentService extends Service класса, что явно означает, что IntentService намеренно делается с определенной целью.
Цель
Цель IntentService заключается в том, чтобы упростить нашу работу для выполнения фоновых задач, даже не беспокоясь о
Создание рабочего потока
Очередь обработки нескольких запросов один за другим (Threading)
Таким образом, нет, служба может выполнять любую задачу, которую сделает IntentService. Если ваши требования подпадают под указанные критерии, вам не нужно писать эту логику в классе обслуживания. Не изобретайте велосипед, потому что IntentService - это изобретенное колесо.
Нормальная служба запускается в потоке пользовательского интерфейса. Если вам нужно сделать что-то, что может занять некоторое время, то вы должны создать поток. В случае нескольких запросов вам придется иметь дело с синхронизацией.
Intent Service получает некоторую реализацию по умолчанию, которая выполняет эти задачи для вас.
Согласно странице
Intent Service создает рабочий поток
IntentService создает рабочую очередь, которая отправляет запрос методу onHandleIntent() по одному
stopSelf()onBind(), который равен nullonHandleIntent()