Не одобряется ли выход из приложения?


1154

Продвигаясь в попытке изучить Android, я просто прочитал следующее :

Вопрос: есть ли у пользователя выбор убить приложение, если мы не добавим пункт меню, чтобы убить его? Если такой опции не существует, как пользователь закрывает приложение?

Ответ: (Romain Guy): пользователь этого не делает, система обрабатывает это автоматически. Для этого и нужен жизненный цикл активности (особенно onPause / onStop / onDestroy). Независимо от того, что вы делаете, не ставьте кнопку «выйти» или «выйти» из приложения. Это бесполезно с моделью приложения Android. Это также противоречит принципам работы основных приложений.

Хе-хе, за каждый мой шаг в мире Android я сталкиваюсь с какой-то проблемой = (

По-видимому, вы не можете закрыть приложение в Android (но система Android может очень хорошо полностью уничтожить ваше приложение, когда оно будет похоже). Что с этим? Я начинаю думать, что невозможно написать приложение, которое функционирует как «обычное приложение» - что пользователь может выйти из приложения, когда он / она решит это сделать. Это не то, на что должна полагаться ОС.

Приложение, которое я пытаюсь создать, не является приложением для Android Market. Это не приложение для «широкого использования» широкой публикой, это бизнес-приложение, которое будет использоваться в очень узкой сфере бизнеса.

Я действительно с нетерпением ждал разработки для платформы Android, поскольку она решает множество проблем, существующих в Windows Mobile и .NET. Тем не менее, последняя неделя была для меня своего рода поворотом ... Надеюсь, мне не придется отказываться от Android, но сейчас это выглядит не очень хорошо = (

Есть ли способ для меня действительно выйти из приложения?

Ответы:


1287

Это в конечном итоге дойдет до вашего вопроса, но я сначала хочу затронуть ряд вопросов, которые вы поднимаете в своих различных комментариях к различным ответам, уже приведенным на момент написания этой статьи. У меня нет намерения передумать - скорее, это здесь для других, кто придет читать этот пост в будущем.

Дело в том, что я не могу позволить Android определять, когда мое приложение будет закрыто. это должен быть выбор пользователя.

Миллионы людей совершенно довольны моделью, в которой среда закрывает приложение по мере необходимости. Эти пользователи просто не думают о «прекращении» работы Android-приложения, равно как и о «прекращении» веб-страницы или «прекращении» термостата.

Пользователи iPhone во многом аналогичны, в том смысле, что нажатие кнопки iPhone не обязательно «чувствует», как приложение было закрыто, так как многие приложения iPhone поднимаются с того места, где пользователь остановился, даже если приложение действительно было закрыто (так как только iPhone позволяет одно стороннее приложение одновременно, в настоящее время).

Как я уже говорил выше, в моем приложении происходит много вещей (данные, передаваемые на устройство, списки с задачами, которые всегда должны быть там, и т. Д.).

Я не знаю, что означает «списки с задачами, которые всегда должны быть там», но «данные, передаваемые на устройство» - это приятная выдумка, которая ни в коем случае не должна выполняться какой-либо деятельностью. Используйте запланированное задание (через AlarmManager), чтобы обновить ваши данные для максимальной надежности.

Наши пользователи входят в систему и не могут делать это каждый раз, когда им звонят, и Android решает убить приложение.

Есть много приложений для iPhone и Android, которые занимаются этим. Обычно это происходит из-за того, что они держат учетные данные для входа, а не заставляют пользователей каждый раз входить в систему вручную.

Например, мы хотим проверять обновления при выходе из приложения

Это ошибка в любой операционной системе. Насколько вы знаете, причина того, что ваше приложение «закрывается», заключается в том, что ОС закрывается, и тогда ваш процесс обновления завершится ошибкой. Как правило, это не очень хорошая вещь. Либо проверяйте обновления при запуске, либо проверяйте обновления полностью асинхронно (например, с помощью запланированной задачи), но не при выходе.

Некоторые комментарии предполагают, что нажатие кнопки «Назад» не убивает приложение вообще (см. Ссылку в моем вопросе выше).

Нажатие кнопки НАЗАД не «убивает приложение». Он завершает действие, которое было на экране, когда пользователь нажал кнопку НАЗАД.

Он должен завершаться только тогда, когда пользователи хотят прекратить его - никогда иным образом. Если вы не можете писать приложения, которые ведут себя так же, как в Android, то я думаю, что Android нельзя использовать для написания реальных приложений = (

Тогда ни один не может веб-приложений. Или WebOS , если я правильно понимаю их модель (у меня еще не было возможности поиграть с ней). Во всех этих случаях пользователи ничего не «прекращают» - они просто уходят. iPhone немного отличается тем, что в настоящее время он позволяет запускать только одну вещь за раз (за некоторыми исключениями), и поэтому процесс ухода подразумевает довольно немедленное прекращение работы приложения.

Есть ли способ для меня действительно выйти из приложения?

Как и все остальные говорили вам, пользователи (через BACK) или ваш код (через finish()) могут закрыть вашу текущую деятельность. Пользователям, как правило, больше ничего не нужно для правильно написанных приложений, больше, чем им нужна опция «выход» для использования веб-приложений.


По определению не существует двух одинаковых сред приложений. Это означает, что вы можете видеть тенденции в окружающей среде по мере появления новых и захоронения других.

Например, существует растущее движение, чтобы попытаться исключить понятие «файл». Большинство веб-приложений не заставляют пользователей думать о файлах. Приложения для iPhone обычно не заставляют пользователей думать о файлах. Приложения Android обычно не заставляют пользователей думать о файлах. И так далее.

Аналогичным образом, существует растущее движение, чтобы попытаться устранить понятие «прекращения» приложения. Большинство веб-приложений не заставляют пользователя выходить из системы, а неявно выходят из системы после определенного периода бездействия. То же самое с Android и, в меньшей степени, iPhone (и, возможно, WebOS).

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

Например, в некоторых средах разработки, таких как Hypercard и Smalltalk, приложение и инструменты разработки были объединены в одной установке. Эта концепция не получила широкого распространения за пределами языковых расширений приложений (например, VBA в Excel , Lisp в AutoCAD ). Поэтому разработчики, которые придумали ментальные модели, которые предполагали наличие инструментов разработки в самом приложении, должны были либо изменить свою модель, либо ограничить себя средами, в которых их модель была бы верна.

Итак, когда вы пишете:

Наряду с другими грязными вещами, которые я обнаружил, я думаю, что разработка нашего приложения для Android не произойдет.

Похоже, что это будет к лучшему, для вас, прямо сейчас. Точно так же я бы посоветовал вам не пытаться портировать ваше приложение в Интернет, поскольку некоторые из тех же проблем, о которых вы сообщали в Android, вы найдете и в веб-приложениях (например, без «завершения»). Или, наоборот, когда - нибудь , если вы делаете порт приложение к Интернету, вы можете обнаружить , что поток веб - приложение может быть лучше подходит для Android, и вы можете вернуться к Android порт в то время.


21
Одна мысль пришла мне в голову: если я просто переписываю все приложение как Службу и рассматриваю эту Службу как фактическое приложение - возможно, это будет работать лучше? Тогда я мог бы «замять» действия (так, как этого хочет Android), чтобы просто представить данные, содержащиеся в Сервисе. В этом случае я мог бы, возможно, сохранить состояние входа в систему и другие вещи там. Используя startForeground (int, Notification), я могу почти остановить Android от уничтожения Сервиса ...?
Тед

66
«Обратите внимание, что мои пользователи - профессионалы, которые используют устройство с единственной целью - использовать приложение, которое я пытаюсь перенести на Android». На самом деле, вы указали иначе («не могу делать это каждый раз, когда они получают телефонный звонок» - «телефонный звонок» не ваше приложение). Более того, если вы не создаете свое собственное устройство, вы не можете запретить людям устанавливать другие приложения, если они того пожелают.
CommonsWare

25
@SomeCallMeTim: Нет, это не является веской причиной для использования killProcess(). Это уважительная причина для написания лучшего кода iOS.
CommonsWare

24
@CommonsWare: Извините, но это банальный ответ, который мне не нужен. Я портирую код, который мне платят в порт. Должен ли я потратить вдвое больше времени, занимаясь портом, переписывая их код, или делать это таким образом, чтобы сократить расходы для моего работодателя, позволяя им быстрее ставить больше игр на Android? В любом случае, это чисто академический вопрос: они не хотят, чтобы я вносил такие серьезные изменения в их движок, так как я не могу протестировать изменения на iOS. И это просто неправильно: нет ничего «плохого» в использовании шаблонов Singleton для соответствующих объектов. Android просто сломал WRT NDK приложения.
SomeCallMeTim

10
@Ted для более надежной повторной инициализации, возможно, вы могли бы минимизировать объем состояния, которое хранится в самой деятельности или службе. Вместо этого поместите большую часть состояния и кода в отдельный класс, который вы воссоздаете «с нуля» при каждом запуске действия или службы.
Qwertie

290

Я просто хотел бы добавить здесь исправление для будущих читателей этой темы. Этот специфический нюанс долгое время ускользал от моего понимания, поэтому я хочу убедиться, что никто из вас не совершит подобных ошибок:

System.exit()не убивает ваше приложение, если у вас есть несколько действий в стеке. На самом деле происходит то, что процесс уничтожается и сразу же перезапускается с одним меньшим действием в стеке. Это также происходит, когда приложение закрывается в диалоговом окне Force Close, или даже когда вы пытаетесь завершить процесс из DDMS. Насколько мне известно, это совершенно недокументированный факт.

Короткий ответ: если вы хотите выйти из приложения, вы должны отслеживать все действия в вашем стеке и finish()ВСЕ, когда пользователь хочет выйти (и нет, нет способа перебрать стек действий так что вам придется все это делать самостоятельно). Даже это на самом деле не убивает процесс или любые свисающие ссылки, которые вы можете иметь. Это просто заканчивает деятельность. Кроме того, я не уверен, Process.killProcess(Process.myPid())работает ли лучше; Я не проверял это.

Если, с другой стороны, для вас нормально, чтобы в вашем стеке оставались действия, есть еще один метод, который сделает ваши вещи очень простыми: Activity.moveTaskToBack(true)он просто зафиксирует ваш процесс и покажет домашний экран.

Длинный ответ включает в себя объяснение философии этого поведения. Философия рождается из ряда предположений:

  1. Прежде всего, это происходит только тогда, когда ваше приложение находится на переднем плане. Если это в фоновом режиме, процесс будет просто нормально завершен. Однако, если она находится на переднем плане, ОС предполагает, что пользователь хочет продолжать делать то, что он / она делал. (Если вы пытаетесь убить процесс из DDMS, вы должны сначала нажать кнопку «Домой», а затем убить его)
  2. Это также предполагает, что каждое действие не зависит от всех других действий. Это часто верно, например, в том случае, если ваше приложение запускает активность браузера, которая является совершенно отдельной и не была написана вами. Действия браузера могут создаваться или не создаваться для одной и той же задачи в зависимости от ее атрибутов манифеста.
  3. Предполагается, что каждое из ваших действий является полностью самостоятельным и может быть убито / восстановлено в любой момент. (Мне скорее не нравится это конкретное предположение, так как в моем приложении много операций, которые основаны на большом количестве кэшированных данных, слишком больших, чтобы их можно было эффективно сериализовать во время onSaveInstanceState, но что это будет делать?) Для большинства хорошо написанных приложений Android это должно быть правдой, так как вы никогда не знаете, когда ваше приложение будет убито в фоновом режиме.
  4. Последний фактор - это не предположение, а скорее ограничение ОС: явное уничтожение приложения - это то же самое, что и аварийное завершение приложения, и то же самое, что и Android, убивающее приложение для восстановления памяти. Кульминацией этого является наш переворот: поскольку Android не может определить, было ли приложение закрыто, или оно зависло, или оно было убито в фоновом режиме, предполагается, что пользователь хочет вернуться с того места, где они остановились, и поэтому ActivityManager перезапускает процесс.

Когда вы думаете об этом, это подходит для платформы. Во-первых, это именно то, что происходит, когда процесс убивается в фоновом режиме, и пользователь возвращается к нему, поэтому его необходимо перезапустить с того места, где он остановился. Во-вторых, это то, что происходит, когда приложение аварийно завершает работу и представляет ужасное диалоговое окно Force Close.

Скажем, я хочу, чтобы мои пользователи могли сделать снимок и загрузить его. Я запускаю Camera Activity из своей активности и прошу вернуть изображение. Камера помещается в верхнюю часть моей текущей задачи (а не создается в своей собственной задаче). Если у камеры есть ошибка, и она вылетает, это должно привести к краху всего приложения? С точки зрения пользователя, только Камера вышла из строя, и они должны быть возвращены к предыдущей активности. Так что он просто перезапускает процесс со всеми теми же действиями в стеке, за исключением камеры. Поскольку ваша деятельность должна быть спроектирована таким образом, чтобы ее можно было убить и восстановить одним махом, это не должно быть проблемой. К сожалению, не все приложения могут быть разработаны таким образом, так что этопроблема для многих из нас, независимо от того, что вам скажет Ромэн Гай или кто-то еще. Итак, нам нужно использовать обходные пути.

Итак, мой заключительный совет:

  • Не пытайтесь убить процесс. Либо позвоните finish()на все мероприятия или позвоните moveTaskToBack(true).
  • Если ваш процесс завершается сбоем или уничтожается, и если вам, как и мне, нужны данные, которые были в памяти и сейчас потеряны, вам необходимо вернуться к корневому действию. Чтобы сделать это, вы должны позвонить startActivity()с намерением, которое содержит Intent.FLAG_ACTIVITY_CLEAR_TOPфлаг.
  • Если вы хотите убить свое приложение с точки зрения Eclipse DDMS, лучше не быть на переднем плане, либо оно само перезапустится. Сначала вы должны нажать кнопку «Домой», а затем завершить процесс.

8
На самом деле, поскольку я снова начал работать с Android, я завершаю все действия (в любой момент времени активна только одна операция), а затем я вызываю System.exit (0); в моем Служении - и это работает так же, как я этого хочу. Я знаю, что большинство людей говорят «не делай этого», но я получаю именно то поведение, которое мне нужно, с этим ходом ...
Тед

13
Иногда очень полезно убивать процесс - например, при написании игр, в которых используется нативный код. Завершение процесса означает немедленное освобождение всей выделенной памяти обратно в систему.
Sulthan

10
Для всех, кто заботится, Process.killProcess демонстрирует точно такое же поведение, что и System.exit ()
PacificSky

6
Получите все действия из общей базы AtivityBase. Затем удерживайте флаг, чтобы принудительно закрыть приложение, в onResume проверьте, установлен ли флаг принудительного закрытия. Если это так, вызовите System.exit (0); Это будет каскадно проходить через весь стек действий и, наконец, полностью закроет приложение.
Нар Гар

12
Спасибо за предоставление реальных ответов ( moveTaskToBack()было то, что я искал). Так много людей просто говорят: «Нет, ты идиот, который всегда хотел выйти из своего приложения». даже не учитывая, что могут быть случаи, когда вы этого хотите (например, неудачные входы в систему).
Тимммм

180

Все мои приложения имеют кнопки выхода ... и я довольно часто получаю положительные отзывы от пользователей из-за этого. Мне все равно, если платформа была разработана таким образом, чтобы приложения не нуждались в них. Говорить «не кладите их туда» довольно нелепо. Если пользователь хочет выйти ... Я предоставляю им доступ именно для этого. Я не думаю, что это снижает эффективность работы Android и кажется хорошей практикой. Я понимаю жизненный цикл ... и я заметил, что Android не справляется с этим ... и это основной факт.


15
+1, потому что, к сожалению, в данный момент он не очень хорошо работает (но я все еще хочу попытаться сделать все так, как задумано, поэтому это ставит меня в затруднительное положение)
Ричард Ле Мезурье

25
Какой механизм вы используете, чтобы выйти?
Гэри Рудольф

4
@Igor finish () - выполнение действий не убивает приложение (расширяет приложение). Таким образом, даже когда ни одно из действий не было активным, настройки все еще активны и актуальны, так что когда действия пытаются получить к ним доступ, они будут теми, которые использовались ранее. System.exit (0); с другой стороны убивает приложение, так что при повторном запуске приложение должно будет заново инициализировать настройки. Это то, что мне нужно при обновлении приложения вручную, потому что я часто меняю формат данных, и мне нужно, чтобы они были немедленно перезапущены.
Нар Гар

1
Ну, это единственный способ выполнить то, что мне нужно в данный момент. Я использую system.exit при обновлении приложения (в противном случае я получу исключения сериализации или приведения классов на основе моих изменений кода). Однако я должен упомянуть, что я не даю пользователю дескриптор пользовательского интерфейса для уничтожения приложения через system.exit - он зарезервирован для меня как инженера приложения, который будет использоваться только тогда, когда приложение абсолютно необходимо полностью выгрузить. В остальное время используется простая функция finish () (или операция кнопки возврата по умолчанию).
Нар Гар

13
Да ... к черту "не стандартное Android" .. Android - это мощное устройство, оно позволяет людям экспериментировать ... Если оно предоставляет API для чего-то, как можно сказать, что это не стандарт Android? Я не могу переварить все эти «философские» ответы. Вы делаете приложение с учетом ваших пользователей. если они счастливы или хотят увидеть эту функцию, то совершенно нормально реализовать это, даже если эти так называемые философы против нее ..
Рахул

144

Перестаньте думать о вашем приложении как о монолитном приложении. Это набор экранов пользовательского интерфейса, с которыми пользователь может взаимодействовать с вашим «приложением» и «функциями», предоставляемыми через сервисы Android.

Не знать, что "делает" ваше загадочное приложение, не так уж важно. Давайте предположим, что он туннелируется в какую-то сверх защищенную корпоративную интрасеть, выполняя некоторый мониторинг или взаимодействие, и остается в системе до тех пор, пока пользователь не «выйдет из приложения». Поскольку ваш ИТ-отдел командует им, пользователи должны очень хорошо знать, когда они находятся в или вне интранета. Следовательно, ваше мышление важно, чтобы пользователи «уходили».

Это просто Создайте службу, которая помещает текущее уведомление в панель уведомлений, говорящее «Я в интрасети, или я работаю». Пусть эта служба выполнит все функции, которые вам необходимы для вашего приложения. Есть действия, которые связаны с этой службой, чтобы позволить вашим пользователям получать доступ к битам пользовательского интерфейса, которые им нужны для взаимодействия с вашим «приложением». И есть кнопка Android Menu -> Quit (или выход из системы, или что-то еще), которая сообщает сервису о необходимости выйти, а затем закрывает само действие.

Это, по сути, именно то, что вы говорите, что вы хотите. Сделано способом Android. Посмотрите на Google Talk или Google Maps Navigation для примеров такого «выхода» из возможного менталитета. Единственное отличие состоит в том, что нажатие кнопки «Назад» из-за вашей активности может привести к тому, что процесс UNIX окажется в ожидании на тот случай, если пользователь захочет восстановить ваше приложение. Это действительно ничем не отличается от современной операционной системы, которая кэширует недавно использованные файлы в памяти. После выхода из программы Windows наиболее вероятные ресурсы, которые ей нужны, все еще находятся в памяти, ожидая замены другими ресурсами, поскольку они загружаются теперь, когда они больше не нужны. Android это то же самое.

Я действительно не вижу твоей проблемы.


3
@Eric, вы не видите проблемы, потому что убегаете от нее. Вы просто использовали другую программу, которая работает на старой «программной модели», чтобы сделать то, что не может сделать «модель Android». Чтобы увидеть проблему с «моделью Android», вы должны представить, что у вас нет такой роскоши, как делегирование задач блокам Linux / Windows. Вы должны представить, что вы вынуждены делать все, от переднего до заднего, только с блоками, которые запускают «модель Android». Затем вы увидите, что ограничения «модели Android» так же ясны, как небо.
Pacerier

думайте о вашем приложении как о монолитном приложении. Он написан на языке Java, который выполняется одним процессом JVM (виртуальная машина Java). System.exit () выходит из JVM и полностью и полностью закрывает все экраны пользовательского интерфейса и все остальное. Исключением является ЕСЛИ программист сталкивается с проблемой настройки нескольких потоков, которые выполняются в нескольких процессах, но по умолчанию это НЕ так, и, по мнению Google, это не должно выполняться нормально.
Джесси Гордон

@JesseGordon Это просто неправда. System.exit()удаляет только активность из стека. JVM немедленно повторно инициализируется. Смотрите этот ответ .
Форрестхопкинса

1
@forresthopkinsa Хорошо, я проверил это на Android 7.0. Простое однопоточное приложение по-прежнему работает в своем собственном выделенном экземпляре JVM, работая в качестве идентификатора пользователя, уникального для этого приложения. Я еще не пробовал многопоточное приложение для этого теста. И System.exit () все равно убивает всю JVM для этого приложения. Если System.exit () вызывается из основного действия, он просто завершается. Если System.exit () вызывается из подчиненной деятельности, JVM все еще убивается, но android перезапускает его с новым идентификатором процесса обратно в основное / первое действие. android.os.Process.killProcess (android.os.Process.myPid ()); и убить <pid> работать так же.
Джесси Гордон

1
Интересно ... Рассматривая связанный с вами ответ, @forresthopkinsa, похоже, что Android работает как веб-браузеры, восстанавливая действия после system.exit, так что пользователь не замечает его выхода, но исключает действие, вызвавшее выход. .? Weird. Но в любом случае, System.exit () делает близко все мероприятия и свободный () 'S памяти и завершает JVM для этого приложения. Но я понятия не имею, что делает Android, чтобы перезапустить / восстановить его. Это мешает приложениям-убийцам? Так что я думаю, что если кто-то хочет кнопку выхода, он должен поместить ее в основной вид деятельности.
Джесси Гордон

71

Это интересная и проницательная дискуссия с участием многих экспертов. Я чувствую, что этот пост должен быть зациклен на главном веб-сайте разработки Android, потому что он вращается вокруг одного из основных проектов ОС Android.

Я также хотел бы добавить свои два цента здесь.

До сих пор я был впечатлен тем, как Android обрабатывает события жизненного цикла, привнося концепцию веб-опыта в нативные приложения.

Сказав, что я до сих пор считаю, что должна быть Quitкнопка. Почему? ... не для меня или Теда или любого из технических гуру здесь, но с единственной целью удовлетворения спроса конечного пользователя.

Хотя я не большой поклонник Windows, но давным-давно они представили концепцию, к которой привыкло большинство конечных пользователей (кнопка X) ... «Я хочу прекратить запуск виджета, когда« я »хочу».

Это не означает, что кто-то (ОС, разработчик?) Позаботится об этом по своему усмотрению ... это просто означает "где моя красная кнопка X, к которой я привык". Мое действие должно быть аналогичным «завершить вызов нажатием кнопки», «выключить устройство нажатием кнопки» и т. Д. И т. Д. - это восприятие. Это само по себе приносит удовлетворение тем, что мои действия действительно достигают своей цели.

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


2
Правильно. Добрый старый Windows Mobile предлагал ту же кнопку X, что и ПК с Windows, за исключением того, что он фактически не выходил из приложения, он просто «умно свернул» его. Многие пользователи, вероятно, так и не узнали, что приложение не вышло. (Подход работал отлично, хотя, если вы использовали .NET Compact Framework, приложение не было уведомлено о том, что это произошло, и поэтому у него не было возможности освободить ресурсы или фактически выйти.)
Qwertie

3
На самом деле это равносильно лжи пользователям, чтобы дать им теплое, нечеткое чувство. В конечном счете, лучше позволить пережиткам прошлого упасть на обочину, чтобы они не стали постоянными приспособлениями технологии. Мобильные и веб - это новые платформы, и они не будут вести себя так же, как настольные компьютеры. И, по крайней мере, по крайней мере, решения о жизненном цикле Android, кажется, завоевывают популярность у пользователей: поскольку моему самому большому приложению исполнилось 2 года, я заметил поток запросов конечных пользователей о том, что кнопки «выхода» высыхают, когда они привыкают к новая платформа.
Джон О

2
@Jon Что вы рекомендуете? Не предлагаете вариант «выхода» где-либо в приложении?
Игорь Ганапольский

Хорошо, когда пользователь запрашивал кнопку выхода, я объяснял им точно, как все работает иначе, чем на рабочем столе (это то же самое объяснение, которое я даю им, когда они упоминают убийц задач). Теперь информация, кажется, завоевала популярность, и я больше не получаю эти запросы. Итак, я рекомендую вам объяснить это несколько раз (возможно, придумать готовый ответ) и пропустить кнопку. Или вставьте поддельную кнопку выхода, которая открывает диалоговое окно, объясняющее, почему больше нет кнопок выхода. : D (Также в Android 4+ пользователь может «убрать» приложение с экрана многозадачности, чтобы «убить» его.)
Jon O

3
Я также не нашел обоснования всего совета, говорящего «не убивай процесс». На мой взгляд, клиент всегда прав, так что плохого в том, чтобы предоставить кнопку выхода после того, как она была запрошена, и «лгать своим пользователям, чтобы дать им теплое, нечеткое чувство», если они этого хотят? Это частично то, о чем пишут хорошие приложения. Большинство пользователей не знают или не заботятся о том, что на самом деле происходит под капотом, но если им нравится ваше приложение, и оно делает то, что они хотят и ожидают, они вернутся и купят больше ваших приложений. Это то, чего мы все хотим, не так ли? Или я что-то упустил?
DDSports

37

Вы можете выйти, нажав Backкнопку или позвонив finish()в свой Activity. Просто позвоните finish()от А MenuItemесли вы хотите явно убить его.

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


5
Это не бессмысленно, если это удовлетворяет цели, и в нашем приложении это именно так. Например, мы хотим проверять обновления при выходе из приложения. Мы не можем выйти из приложения, тогда обновление невозможно. Некоторые комментарии предполагают, что нажатие кнопки «Назад» не убивает приложение вообще (см. Ссылку в моем вопросе выше).
Тед

2
Как говорит Ромен, это не то, как работают основные приложения. Так что, если пользователи привыкли нажимать «Назад», чтобы выйти из приложения, то, вероятно, они продолжат делать это с вашим приложением, а не явно выберут «Выход»? Вы можете выполнить проверку обновлений при запуске, или onDestroy (), или использовать повторяющуюся тревогу ... это не похоже на то, что требует запуска пользователем.
Кристофер Орр

1
Том: Я пишу для Windows Mobile уже почти 5 лет. Это телефон с "ограниченными ресурсами". Там нет такого поведения, и нет проблем, что оно не действует в этом "старшем брате". «Реальные приложения» = там, где программист имеет намного больший контроль над ним, то есть выход, когда GUI-контент удаляется и т. Д.
Тед

1
Jay: потому что, если он все еще в памяти, я не могу обновить приложение, которое я думаю. Не могу удалить файлы, которые используются, верно? Я хочу обновить при выходе, потому что мы не можем заставить наших пользователей обновляться при запуске. Это связано с тем, как они работают и что им нужно. Это не нормально для них, чтобы быть вынужденным обновление в начале своей смены по разным причинам. Это немного сложно.
Тед

1
Jay: Нет, как я сказал ранее, это не приложение Market, и оно тоже не будет таким. Это очень специализированное приложение, а не для общего пользования.
Тед

31

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

Тед отметил, что одним из самых скачиваемых приложений на Маркете является «Убийца приложений». Люди получают немного дополнительного серотонина, когда они выходят из приложений. Они привыкли к этому с настольным компьютером / ноутбуком. Это заставляет вещи двигаться быстро. Это держит процессор прохладным и вентилятор от включения. Он использует меньше энергии.

Если вы считаете, что мобильное устройство гораздо меньше, то вы особенно можете оценить их стимул «выбросить за борт то, что вам больше не нужно». Теперь разработчики Android считают, что ОС знает лучше, а выход из приложения - это антиквариат. Я искренне поддерживаю это.

Однако я также считаю, что вы не должны расстраивать пользователя, даже если это разочарование вызвано его собственным невежеством. Поэтому я прихожу к выводу, что наличие опции «Выход» - хороший дизайн, даже если это в основном кнопка плацебо, которая не делает ничего, кроме закрытия просмотра.


8
Да, кнопка «Выйти» действительно удобна для пользователя. Как еще пользователь мог бы выйти из приложения, если бы он занимался 5 видами деятельности? Конечно, они могут давить несколько раз, но я не думаю, что им это понравится.
Игорь Ганапольский

4
Только 5? Веб-браузер Android 2.2 заставляет меня тратить несколько минут, нажимая кнопку «Назад», пока я в итоге не выйду
Джо Планте,

3
Я бы начал слушать разработчиков Android, когда они разрабатывают менеджер памяти, который работает. Что касается Froyo, то он работал крайне плохо, убивая случайные приложения, перезапуская приложения, которые не нужны (и не имея намерений запускать их законно), и OTOH, замедляясь до ПОЛНОГО сканирования, когда память освобождает 50 МБ.
ДВК

10
Когда ваша религия говорит, что Android Task Killer «не нужен», но использование ATK для уничтожения немых задач, которые не выполняются, меняет ОС с сканирования на ~ 1-5% от нормальной скорости до 100% от нормальной скорости ( измерено) 100% времени при тысячах использования ATK в течение 2 лет каждый раз, когда система достигает 50 МБ свободного нижнего уровня, ваша религия неверна
DVK

@JoePlante Вы можете сначала закрыть все открытые вкладки и окна, а затем просто один раз нажать кнопку «Назад», чтобы выйти :) По крайней мере, на моем GS2.
ldam

29

Тед, то, что ты пытаешься сделать, может быть сделано, возможно, просто не то, как ты думаешь об этом сейчас.

Я предлагаю вам прочитать о деятельности и услугах. Прекратите использовать термин «приложение» и начните ссылаться на компоненты, то есть «Активность», «Сервис». Я думаю, вам просто нужно больше узнать о платформе Android; это изменение мышления от стандартного приложения для ПК. Тот факт, что ни в одном из ваших сообщений не было слова "Активность" (если не считать цитаты из часто задаваемых вопросов, т.е. не ваших слов), говорит о том, что вам нужно прочитать еще немного.


Я прочитал большую часть материала на android.com =) и могу сослаться на несколько своих вопросов, где я говорю о деятельности, так что это не так (например: stackoverflow.com/questions/2032335/… или stackoverflow.com/questions/ 2032335 /… и т. Д.) Однако я мог бы сделать еще один шаг и попытаться создать «приложение» who в качестве службы ...
Тед

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

23

Сообщение в блоге « Когда включить кнопку выхода в приложениях Android» (подсказка: никогда) объясняет это гораздо лучше, чем я. Жаль, что каждый разработчик Android уже прочитал это.

Выдержки:

По моему опыту, [пользователи] действительно хотят: Однозначный способ гарантировать, что приложение перестанет потреблять ресурсы (батарея, циклы процессора, передача данных и т. Д.).

Многие пользователи считают, что кнопка выхода реализует это требование, и просят добавить его. Разработчики, стремясь порадовать своих пользователей, обязательно добавят один. Вскоре после этого они оба терпят неудачу.

  • В большинстве случаев кнопка выхода просто вызывает Activity.finish(). Это в точности эквивалентно нажатию кнопки «назад». Точно. Службы продолжают работать, а опросы продолжаются. Пользователи могут подумать, что они убили приложение, но они этого не сделали, и вскоре они будут еще более раздражены.
  • Поведение при выходе теперь неоднозначно. Должна ли кнопка «Выход» просто закрыть действие, или она также должна остановить все связанные службы, получатели и сигналы тревоги? Что Backделать? Что произойдет, если они попали Home? Что произойдет, если в вашем приложении есть виджет? Должна ли кнопка выхода остановить это обновление тоже?

Решение состоит в том, чтобы заставить кнопку возврата вести себя так, как вы ожидаете от кнопки выхода. А еще лучше, просто прекратите потреблять ресурсы, когда приложение не видно.

Продолжайте и прочитайте полную статью.


3
Выход и Назад не всегда используются для одной и той же цели. Взять, к примеру, Пандору. Когда вы нажимаете кнопку, чтобы выйти из этого приложения, оно не выходит из приложения (сохраняет его в фоновом режиме в качестве службы).
Игорь Ганапольский

@IgorG. Музыкальному проигрывателю требуется кнопка «Стоп» для остановки воспроизведения музыки, а не кнопка «Выход» для выхода из приложения.
Джерадж Вепакомма

Вы когда-нибудь использовали Pandora, iHeartRadio, Spotify, Jango и другие приложения для потоковой передачи музыки? У всех есть кнопка выхода. Остановка воспроизведения музыки не то же самое, что выход из приложения. Особенно, если у вас есть служба, работающая в панели уведомлений.
Игорь Ганапольский

2
Мифично или нет, примитивные пользователи или нет, но почти каждое программное обеспечение пользовательского интерфейса, когда-либо написанное - на любой платформе и ОС - реализует кнопку выхода / закрытия / выхода. Как еще вы бы это реализовали?
Игорь Ганапольский

3
@ DheerajV.S. Просто перестанете расходовать ресурсы, если приложение не видно? Плохой совет Очень. Очень х99. Всякий раз, когда я пытаюсь отправить себе фотографию по электронной почте, я должен держать приложение видимым в течение полных 5 минут, потому что, если я сверну его, оно перестанет отправлять фотографию по электронной почте. Правильно, я не могу использовать свой телефон в течение полных 5 минут только из-за какого-то разработчика, который считает, что приложения должны запускаться только тогда, когда они видны. Теперь представьте, что отправляете файл большего размера, например, видео .....
Pacerier

21

Ответ: (Romain Guy): пользователь этого не делает, система обрабатывает это автоматически. Для этого и нужен жизненный цикл активности (особенно onPause / onStop / onDestroy). Независимо от того, что вы делаете, не ставьте кнопку «выйти» или «выйти» из приложения. Это бесполезно с моделью приложения Android. Это также противоречит принципам работы основных приложений.

1: Полный выход из приложения может быть вообще обязательным, но это не бесполезно. Что, если у окон не было выбора выхода? Система будет работать слишком медленно, так как память будет заполнена, и ОС придется угадывать, с какими программами вы работали. Мне все равно, что скажут Ромейн Гай или даже Ларри Пейдж и Сергей Брин - это неоспоримые факты: системы работают медленнее, когда им приходится убивать задачи, чтобы получить память перед запуском нового приложения. Вы просто не можете сказать мне, что не нужно времени, чтобы убить приложение! Даже свет от далеких звезд занять некоторое время ... Там является некоторая польза в позволяя пользователю полностью закрывать приложения.

2: В отличие от того, как работают основные приложения? Что это должно означать? Когда я закончу работу с приложением, оно больше не выполняет никакой работы ... Оно просто ждет, когда ОС его убьет, когда потребуется память.

Таким образом, существует четкое различие между минимизацией и выходом, и ни один из них не подходит для другого. Мы оставляем отвертку в каждом винте? Или ключ в каждой двери? Оставляем ли мы все наши приборы на высоте, пока не сломается выключатель, и нам нужно включить другой прибор? Разве мы оставляем посудомоечную машину полной посуды и вынимаем достаточно только каждый раз, чтобы освободить место для новых грязных? Оставим ли мы все машины на подъездной дороге, пока - о, неважно.

Если пользователь хочет свернуть приложение, лучше всего свести его к минимуму. Если пользователь хочет выйти из приложения, то лучше всего выйти из него.

Нахмурился? Это точка зрения Android - они нахмурились. И многие многие независимые разработчики Android-новичков нахмурились.

Но когда дело доходит до этого, есть хорошее кодирование и плохое кодирование. Есть хорошие модели программных потоков и есть плохие модели программных потоков.

Оставлять программы в памяти, когда пользователь знает, что они сделали с ними, просто нехорошо. Он абсолютно бесполезен и замедляет работу при запуске новых приложений или при запуске приложений, которые выделяют больше памяти.

Это похоже на ваш автомобиль: бывают ситуации, когда вы оставляете его включенным, например, останавливаетесь на стоп-сигнале или, возможно, проезжаете через фаст-фуд или останавливаетесь у банкомата. Но есть и другие ситуации, когда вы хотите отключить его - например, когда вы добираетесь на работу, или в продуктовый магазин, или даже домой.

Точно так же, если вы играете в игру и звонит телефон, да. Приостановите игру и продолжайте работать. Но если пользователь закончил с игрой на некоторое время, то непременно оставьте его.

Кнопка выхода на некоторых приложениях должна быть больше впереди, чем другие. Например, игры или программы, в которых пользователь, вероятно, захочет полностью выйти, должны иметь очевидный выход. Другие программы, такие как, возможно, программы электронной почты, где выход маловероятен (так что он может продолжать проверять электронную почту) - эти программы не должны тратить пространство экрана первичного управления с опцией выхода, но для хорошего потока программ, это должен иметь вариант выхода. Что если кто-то решит, что не хочет, чтобы его почтовая программа пыталась проверить электронную почту, когда он находится в зоне плохого покрытия, или, возможно, во время разговора по Skype или чего-то еще? Позвольте им выйти из программы электронной почты, если они хотят!

Приостановка и выход - две жизненно важные задачи, и ни одна не выполняет роль другой.


2
«Если пользователь хочет свести приложение к минимуму, то лучше всего свести его к минимуму. Если пользователь хочет выйти из приложения, то лучше всего выйти из него». - Есть вещь (основанная на более чем десятилетнем опыте): пользователи редко знают, чего они хотят. Если вы им не поможете, вам придется это изменить. О примерах выше: позвольте мне дать вам другой пример: вы работаете над машиной и держите под рукой стол для вещей. Вы всегда убираете, чтобы правильно разместить все необходимые инструменты в шкафу или держите наиболее часто используемые инструменты под рукой? И просто убрать большой опоздавший, чтобы иметь место для новых?
HoGo

4
HoGo, спасибо за ваш комментарий. Естественно, я не согласен. В частности, насколько я могу судить, ваше мнение таково, что, поскольку некоторые пользователи не знают, что им следует делать, поэтому не позволяйте делать то, что им следует делать, даже тем, кто знает, что делать. Если у андроида был способ точно знать, должно ли оно завершить приложение, а не сворачивать его, тогда все в порядке. Но это не так, и принуждение всех пользователей к минимизации, когда они хотят выйти, приводит к снижению производительности устройства.
Джесси Гордон

Дело в том, что система знает, что когда вы запускаете одно приложение, а памяти нет, оно должно убить последнее. Пользователь не должен этого знать. Вы хотите этого только потому, что вы человек, которому нравится чувство контроля, просто тупая мышечная память, даже бессмысленный контроль над закрытием программ. Компьютеры были изобретены для автоматизации, я хотел бы, чтобы Windows работала как Android и просто автоматически закрывалась для меня, но я должен помнить, чтобы сохранить и выйти, это глупо, зачем мне, пользователю, делать это? компьютеры должны управлять своей памятью, мне нужно управлять другими вещами.
Луис Фелипе

На самом деле я не закрываю программы на своей машине с Windows, у меня 32 ГБ ОЗУ, я просто оставляю все работающим, закрываю их, когда заканчиваю свою работу. Зачем закрывать программу, открывать ее снова через 5 минут, это не имеет смысла. Подумайте о большом проекте C ++, который занимает 2 минуты, чтобы стать отзывчивым, я просто оставляю Visual Studio открытым навсегда. И я ожидаю, что он также не потерпит крах после 15 дней работы (и да, для этого я использую память ECC).
Луис Фелипе

Хорошая аналогия с механическим цехом, я также оставляю наиболее часто используемые инструменты на столе, я не выбираю инструмент, не использую его и не кладу обратно каждый раз. Кроме того, я не начинаю день, включаю компьютер, жду его запуска, открываю IDE, что угодно. Я просто оставляю это включенным, современный компьютер может бездействовать в 40 Вт, почему закрытие? он также меньше изнашивается (без пускового тока, EEs это знает :))
Luiz Felipe

19

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

Например, Google Listen продолжает воспроизводить подкаст, когда приложение не отображается. Но всегда есть кнопка паузы, чтобы выключить подкаст, когда пользователь закончил с ним. Если я правильно помню, «Прослушивание» даже помещает ярлык в панель уведомлений, чтобы вы всегда могли быстро добраться до кнопки паузы. Другим примером является приложение, например, приложение для Twitter, которое постоянно опрашивает службу в Интернете. Эти типы приложений должны действительно позволять пользователю выбирать, как часто опрашивать сервер, или даже опрашивать в фоновом потоке.

Если вам нужен код, который запускается при выходе, вы можете переопределить onPause (), onStop () или onDestroy () в зависимости от ситуации. http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle


5
Наряду с другими грязными вещами, которые я обнаружил, я думаю, что разработка нашего приложения для Android не произойдет. Слишком много «старшего брата» - что-то происходит, когда Android сообщает мне, какое приложение должно работать или нет. У меня как у программиста должен быть такой выбор, а не гугл или андроид = (
Тед

3
Ваши действия - активный пользовательский интерфейс - уходят, когда другое приложение появляется сверху, или вы нажимаете назад или что-то еще. Пользователь не взаимодействует с ними, поэтому безопаснее сохранить состояние на случай, если пользователь не вернется в течение длительного времени, и так далее, как вы знаете. Ничто не мешает вам написать Serviceхотя бы для того, чтобы текущая работа происходила в фоновом режиме, например, получение данных или что-то еще. Google Talk не перестает работать, когда вы используете другое приложение. То же самое с музыкальным проигрывателем. Посмотрите на другие приложения и как они работают.
Кристофер Орр

3
Вы должны быть в состоянии сохранить учетные данные, чтобы пользователям не нужно было входить в систему каждый раз, когда они получают телефонный звонок или уходят из вашего приложения. Я бы порекомендовал посмотреть на жизненный цикл Android. Когда приложение приостанавливается, останавливается или уничтожается, вы можете сохранить все соответствующие данные, поэтому, когда приложение откроется снова, все будет так, как они его покинули. Пользователю даже не нужно знать, что приложение когда-либо было остановлено.
Джей Аскрен

1
Я могу себе представить, что пользователь может захотеть выйти из некоторых действительно ресурсоемких приложений. Возможно, ему следует просто уменьшить использование ресурсов, когда оно приостановлено, но это не всегда возможно
Casebash

1
Эти вопросы еще живы, я вижу, через 4 года после того, как поднял их =) Я действительно запустил их как службу в фоновом режиме, но я добавил кнопку выхода, так как я все еще чувствую - 4 года спустя - это необходимо и важно. И я вижу все больше и больше приложений, в которых это тоже есть (например, Skype).
Тед

19

Если вы не можете понять, как сделать ваши данные / соединения (и, следовательно, ваше «приложение») постоянными, то вы не сможете делать то, что вам «нужно», чтобы делать с Android.

Те, кто загружает эти милые маленькие App Killers, обычно обнаруживают, что они не помогают работать от батареи или использовать память, но мешают ОС эффективно управлять памятью ...

http://android-developers.blogspot.com/2010/04/multitasking-android-way.html


Пока мы говорим об убийцах задач, пару дней назад на Android reddit появился очень поучительный пост. Суть в том, что используйте убийц задач осторожно, иначе вы действительно можете повредить сроку
Neil Traft

@Neil Traft, я нашел комментарии к посту очень поучительными. Торговые представители в магазинах рекомендуют и устанавливают убийцы задач для своих клиентов :)
dipu

3
@ Дан, как вообще возможно, что я удаленно закрываю приложение, с которым я на неделю работал, мешая работе ОС Android? Так что больше свободной памяти. Это не может помешать Android! Впрочем, это может ускорить процесс позже! Если я знаю, что какое-то время закончил с приложением, оно абсолютно бесполезно. Это только занимает память, и рано или поздно я запустлю новое приложение, и у ОС будет дополнительная задержка, потому что она должна убить некоторые приложения, которые я знал НЕДЕЛЮ назад, с которыми я закончил.
Джесси Гордон

@Jesse Gordon, вы смотрели реальные процессы после того, как вы убили приложение? Они перезапускаются, ОС предполагает, что возникла проблема ... ОС будет убивать приложения, когда ей потребуется память. Ты вообще что-нибудь читал в статьях, упомянутых здесь?
Дан

@ Дэн, чтобы думать, что Android будет делать что-то вроде этого ... ему действительно нужно серьезное перевоспитание.
Pacerier

18

Я хотел бы прочитать «Разработка беспроводных приложений для Android», опубликованную Addison-Wesley. Я только заканчиваю это, и это ОЧЕНЬ тщательно.

Похоже, у вас есть некоторые фундаментальные недоразумения платформы Android. Сначала я тоже был немного разочарован жизненным циклом приложений для Android, но после более глубокого понимания я стал по-настоящему наслаждаться этим подходом. Эта книга ответит на все ваши вопросы и многое другое. Это действительно лучший ресурс, который я нашел для новых разработчиков Android.

Кроме того, я думаю, что вам нужно отпустить линейный порт существующего приложения. Для того, чтобы перенести ваше приложение на платформу Android, часть дизайна приложения изменится. Используемый жизненный цикл приложения необходим, поскольку мобильные устройства имеют очень ограниченные ресурсы по сравнению с настольными системами и позволяют устройствам Android запускать несколько приложений упорядоченно и с учетом ресурсов. Сделайте еще немного углубленного изучения платформы, и я думаю, вы поймете, что то, что вы хотите сделать, вполне осуществимо. Удачи.

Кстати, я никак не связан с Addison-Wesley или с каким-либо лицом или организацией, связанной с этой книгой. Перечитав мой пост, я чувствую, что немного оторвался от фанатов. Мне просто очень понравилось, и я нашел это чрезвычайно полезным. :)


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

Я слышу это. Вы должны предположить, что большинство пользователей не очень технологичны.
Энди

8
Я так устал от мантры о том, как мало «ресурсов» у мобильного устройства. Проснись, они работают на частоте более 500 МГц и имеют много памяти. У моего старого Dell Axim было 128 МБ оперативной памяти. Текущие устройства обычно имеют более 512RAM и работают на 1GHZ! Это в 10 раз больше, чем мой старый Pentium 90 МГц, и я не слышал, как люди говорили «очень ограниченные ресурсы», то и это. Пришло время проснуться и почувствовать запах кофе - сейчас 2010 год, а не 80-е.
Тед

16

Почти в 99% случаев нет необходимости, чтобы приложение Android брало свой жизненный цикл. В большинстве случаев все сводится к лучшему планированию или более разумному дизайну приложения. Например, лучше создать внутреннюю службу (не экспортированную) для обработки загрузок и т. Д., Либо разработать действия и задачи, связанные с рабочим процессом пользователя.

Но, как говорится, там, где есть воля, есть путь. Android предоставляет - через класс android.os.Process - намного лучший API, чем Java, для управления базовым процессом. И в отличие от Java, он не рассматривает разработчика как придурка, скрывая все это за простым вызовом java.lang.System.exit ().

Так как же попросить ваше приложение совершить самоубийство в Android? Ну, трюк прост:

Создайте свой собственный класс приложений Android, унаследовав его от стандартного класса android.app.Application (не забудьте объявить его в файле AndroidManifest.xml).

Переопределите метод onCreate () и сохраните идентификатор процесса, который запустил ваше приложение:

this.pid = android.os.Process.myPid(); // Save for later use.

Теперь, чтобы убить ваше приложение, предоставьте метод kill ():

android.os.Process.sendSignal(pid, android.os.Process.SIGNAL_KILL);

Теперь, когда вам нужно, чтобы ваше приложение совершило самоубийство, просто наберите контекст приложения и вызовите свой метод kill!

((MySuicidalApp) context.getApplicationContext()).kill()

Просто помните, что из-за политик управления процессами в Android, в частности связанных со службами, Android может просто перезапустить службу (см. Раздел «Не следует использовать средства убийцы задач на Android» ).


да, я пришел сюда только потому, что хотел закрыть свое приложение в одной ситуации, это имеет смысл, мой кэш данных OBB поврежден, и мне нужно перезапустить все приложение
Luiz Felipe

14

Когда я создаю приложение в Android, я вижу это так:

  • Вы работаете со своим приложением
  • Телефон зазвонил
  • Вы принимаете звонок
  • В конце разговора вы возвращаетесь к своей заявке в том же месте, где были

Для этого вам понадобится только Backкнопка или Homeкнопка вашего телефона (коротким или длинным нажатием) и панель уведомлений.

Когда я Backвыхожу из приложения, я использую кнопку только до тех пор, пока у меня не закончится или Homeкнопка.

Я думаю, что так задумано большинство приложений. Но если мне нужен какой-то сеанс или соединение, я дал понять пользователю с помощью кнопки входа / выхода и уведомления (строка заголовка или что-то еще). Это довольно другой стиль, нежели стиль приложения «выход».

На ПК у вас рабочий стол с несколькими графическими интерфейсами, а на Android вы, очевидно, имеете несколько задач, но вы отображаете только одно приложение за раз (я не рассматриваю здесь виджеты ^^). А на мобильном телефоне в любое время вы можете получить уведомление о чем-то более важном, чем то, что вы делаете.

Таким образом, вся концепция приложения основывается на чем-то ином, чем «вход в приложение - работа - выход из приложения».


12

Хммм ...

Я думаю, что вы просто не видите приложение для Android правильно. Вы можете легко сделать что-то вроде того, что хотите:

  • Сохраняйте / восстанавливайте состояние приложения, как это рекомендуется в документации разработчика.

  • Если на этапе восстановления требуется какой-либо логин (информация о логине / сеансе недоступна), сделайте это.

  • В конце концов добавьте кнопку / меню / тайм-аут, и в этом случае вы будете делать finish()без сохранения имени входа и другой информации о сеансе, неявно завершая сеанс приложения: так что, если приложение будет запущено / выведено на передний план, оно начнет новый сеанс.

Таким образом, вам все равно, действительно ли приложение удалено из памяти или нет.

Если вы действительно хотите удалить его из памяти (это не рекомендуется, и, кстати, с какой целью?), Вы можете уничтожить его условно в конце onDestroy()с java.lang.System.exit(0)(или, возможно restartPackage(..),?). Конечно, делайте это только в том случае, если вы хотите «действительно завершить приложение», потому что onDestroy()это часть обычного жизненного цикла действий, а не конец приложения вообще.


11

Поскольку приложение в контексте Android - это просто набор неопределенно связанных действий, выход из приложения на самом деле не имеет особого смысла. Вы можете завершить () действие, и будет отображено представление предыдущего действия в стеке действий.


2
Конечно, выход из приложения может иметь смысл в некоторых ситуациях. Если это программа, которую вы используете несколько раз в месяц в течение нескольких минут, есть бесспорная выгода для полного выхода из приложения. Это преимущество заключается в том, что ОС не потребуется время для выхода из этого приложения неделю спустя, когда в ней не хватает памяти, и ваш телефон звонит, и вы нажали кнопку ответа, и вы ожидаете, пока Android освободит часть памяти. так что вы можете ответить на ваш звонок, например. Или, возможно, вы получили электронное письмо и хотите его прочитать - любое приложение, которому требуется больше памяти, запустится быстрее, если ОС сначала его не освободит.
Джесси Гордон

3
То, что сказал @JesseGordon, и еще один аспект, объясняющий, почему выход имеет смысл: если я не выйду из этого ресурсоемкого приложения, я знаю, что не собираюсь использовать его снова в течение месяца, ОС иногда ошибочно убивает какое-то другое приложение когда ресурсов становится мало, оставляя это бесполезное приложение для поиска ресурсов работающим ... заставляя другое приложение возобновлять работу дольше, чем следовало бы.
Дон Хэтч

10

Я согласен с Тедом. Я понимаю, что выход из приложения - это не «путь Android», но, похоже, это не следует исключать. Вот три причины, по которым вам может потребоваться реальный выход из приложения (а не только действие):

  1. Пользователь может захотеть контролировать, какое приложение будет убито в случае нехватки памяти. Если важное приложение A работает в фоновом режиме, то вы можете выйти из приложения B, когда закончите с ним, чтобы приложение A не было убито операционной системой.

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

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


6
Как вы думаете, что представляет собой «приложение»? Если я открою приложение Facebook и установлю новую фотографию профиля - запустятся приложения «Камера» или «Галерея». Как пользователь, я все еще выполняю ту же задачу (используя Facebook). Если я затем решу закрыть Facebook, мои приложения «Камера» и «Галерея» тоже должны быть закрыты (поскольку они являются действиями, запущенными из Facebook) ... Что если бы я занимался редактированием некоторых других моих фотографий и намеревался только закрыть Facebook ? Вы бы перенесли проблему на потенциальную потерю данных.
seanhodges

Ну, я не думаю, что это может пойти до потери данных. Если у вас есть стороннее действие, выполняемое в той же задаче, что и ваше собственное действие, и ваше собственное действие - это действие с кнопкой выхода, то пользователь должен перейти finish()к стороннему действию, прежде чем он сможет нажать кнопку выхода. А сторонняя деятельность должна сохранять любую несохраненную информацию в это время. Я не думаю, что вы можете использовать переключатель приложений, чтобы вернуться к активности кнопки выхода, если он не запущен в отдельной задаче. И если это отдельная задача, это отдельный процесс, и поэтому она не будет уничтожена кнопкой выхода.
Нил Трафт

2
1. Я думаю, что 99,99% пользователей Android не должны беспокоиться о том, как ОС управляет приложениями за кулисами. Остальные гики и найдут передовые инструменты, которые заставят систему вести себя именно так, как они хотят. 2. Вы всегда можете выгрузить любые конфиденциальные данные, когда действие будет приостановлено или остановлено. 3. Как и выше, ресурсы могут быть освобождены в методах обратного вызова жизненного цикла. Когда действие возобновляется, ресурсы могут быть распределены снова.
Жолт Тёрёк

4
Я думаю, довольно интересно, что многие пользователи Android устанавливают «Advanced Task Killer», приложение, которое закрывает другие приложения, поскольку вы обычно не можете сделать это самостоятельно. Я использую это все время сам. Выход из приложения - это не то, без чего я могу обойтись.
Тед

2
@ ZsoltTörök, 99,99% людей имеют дело с медленными компьютерами / телефонами и вынуждены беспокоиться о том, как ОС управляет приложениями за кулисами.
Pacerier

10

Ядро Linux имеет функцию, называемую Убийца нехватки памяти (как упоминалось выше, политики настраиваются на уровне пользовательского пространства, а также ядро ​​не является оптимальным, но ни в коем случае не ненужным).

И это активно используется Android:

Некоторые приложения пользовательского пространства доступны, чтобы помочь с этими приложениями уничтожения, например:


9

Вы, очевидно, нашли нужный ответ в команде finish (). Это не удалит ваше приложение из памяти, но Android будет делать это всякий раз, когда ему понадобятся ресурсы, поэтому не имеет значения, что вы не будете делать это явно.

Я хотел бы только добавить, что для достижения полного эффекта, который обычно имеет выход из приложения, вам нужно сбросить состояние приложения до того состояния, в котором оно обычно находится в момент первого запуска после загрузки устройства, незадолго до для вызова финиша () во всех ваших действиях. Таким образом, если пользователь снова выберет ваше приложение, оно будет казаться «свежим», без какого-либо состояния, оставшегося от точки до симулированного «выхода».

Если есть некоторые специальные действия, которые должны произойти только при «выходе», такие как сохранение работы пользователя или чего-либо еще, вы также можете выполнить их до повторной инициализации части вышеприведенной процедуры.

Этот подход позволяет вам достичь своей цели, используя команду «выход», не нарушая философию Android, согласно которой управление ресурсами ОС, включая закрытие приложений, остается в руках операционной системы.

Лично я бы не стал использовать этот подход, потому что пользователи Android ожидают, что приложение сохранит свою непрерывность при повторном посещении, и поэтому они не привыкли к модальности «выхода» из приложения. Вместо этого я бы поддерживал «чистую» функцию, которую пользователь может вызывать для сброса приложения до некоторого начального состояния по умолчанию, без необходимости «оставлять» его в процессе.

Единственное исключение - когда пользователь нажимает кнопку «Назад» достаточное количество раз, чтобы приложение закрылось. В этой ситуации со стороны пользователя не ожидается, что состояние будет сохранено (и если в приложении есть несохраненное состояние, то вы, как разработчик, должны иметь код, обрабатывающий кнопку «назад», которая обнаруживает эти несохраненные данные, и предлагает пользователю сохранить его в SharedPreferences или в файл, или на другой энергонезависимый носитель).

Относительно system.exit (0):

Если вы решите использовать system.exit (0), чтобы закрыть приложение с грубой окончательностью (например, в результате последнего нажатия кнопки «назад»), то я бы предупредил вас, что хотя для меня это «работает», а в некоторых Случаи были единственным способом, которым я смог закрыть приложение без каких-либо следов его, есть один незначительный сбой, который происходит в Jelly Bean, когда вы используете этот подход.

В частности, если вы используете список «Недавние приложения», чтобы открыть свое приложение, а затем нажмите кнопку «Назад», чтобы закрыть приложение (с этим закрытием, реализованным с помощью system.exit (0)), список «Недавние приложения» снова станет видимым, так как он будет никогда не был закрыт. Если вы затем нажмете на запись своего приложения в этом списке, чтобы запустить ее во второй раз из того же, уже открытого списка недавних приложений, ответа не будет.

Я подозреваю, что причиной этого является то, что в списке «Последние приложения» содержится ссылка на ваше приложение, которое перестало работать из-за того, что вы закрыли приложение с помощью system.exit (0). Более цивилизованное закрытие вашего приложения с использованием finish () могло бы информировать ОС таким образом, чтобы оно могло обновить свой список недавних приложений, но system.exit (0), по-видимому, этого не делает.

Само по себе это не является большой проблемой, так как очень немногие люди откроют приложение из Недавних приложений, затем закроют его, а затем сразу же откроют снова из того же открытого списка Недавних приложений. И если они коснутся кнопки «Домой», а затем снова откроют список «Последние приложения», запись вашего приложения будет там, и она будет полностью функциональной. Но я думаю, что это показывает, что использование system.exit (0) может помешать правильной связи между вашим приложением и ОС, и это предполагает, что могут быть другие, более серьезные, возможно, тонкие последствия использования этого подхода.


Возможно, вы могли бы удалить недавнюю запись приложения перед вызовом finish ()? Это то, что я попробую, когда позволит время. У меня есть передний план Служба с небольшим лаунчером Activity. Поскольку активность очень мала, нет ничего страшного в том, что ее не убили и не похоронили, но имеет смысл сообщить Android, что она может взять эту доску раньше остальных, если это возможно.
nsandersen

9

Я надеюсь, что со временем все изменится. Пользователь должен иметь возможность убить приложение или процесс, если операционный процесс правильно помещен в «песочницу». Существует мнение, что приложения должны быть написаны идеально, иначе пользователь будет использовать только те приложения, которые соответствуют всем рекомендациям SDK. Я думаю, что это высокий заказ.


Я знаю. Продукты Apple хороши для некоторых потребителей. Они не хороши для разработчиков. Android OS обладает полным потенциалом стать «ОС Windows для ПК» для мобильных телефонов. может быть даже лучше. Он уже более открыт, чем Windows в мире ПК, за исключением того, что он не позволяет нам написать диспетчер задач.
Дипу

7

Существует (относительно) простая конструкция, которая позволит вам обойти головоломку «выхода». Сделайте так, чтобы ваше приложение имело «базовое» состояние (активность), которое является просто пустым экраном. В первом onCreate действия вы можете запустить другое действие, в котором находятся основные функциональные возможности вашего приложения. «Выход» может быть выполнен путем завершения () этого второго действия и возврата к основанию только пустого экрана. ОС может хранить этот пустой экран в памяти столько, сколько захочет ...

По сути, поскольку вы не можете выйти из ОС, вы просто превращаетесь в самосозданное ничто.


2
Хорошая идея. Однако даже завершение действия (или службы) не останавливает ОС. О нет, даже после того, как onDestroy был выполнен, все переменные и все еще есть. Я только что видел, что в Сервисе все одинаково, хотя он и назывался onDestroy ...
Тед,

2
... и таким образом System.exit (0) выручил =)
Тед

7

Без функции выхода для разработчика приложения, чтобы убить их собственное приложение, это очень плохой дизайн.

Мое приложение должно позволять пользователю динамически изменять данные в динамическом режиме во время выполнения, и пользователю необходимо перезапустить мое приложение, чтобы изменения вступили в силу, но Android не разрешил самому запуску моего приложения. Android OS имеет очень плохой дизайн жизненного цикла приложения.


9
public void appRestart () {Intent i = new Intent (getBaseContext (), MyActivity.class); i.addFlags (Intent.FLAG_ACTIVITY_CLEAR_TOP); startActivity (я); }
androidworkz

2
Код вышеупомянутого комментария действительно работает хорошо. По крайней мере, вы можете перейти к первому действию вместо полного выхода из приложения. :)
Harpreet

7

Для закрытия приложения в любой момент используйте FLAG_ACTIVITY_CLEAR_TOPфлаг Intent, а затемsystem.exit();

Или есть аналогичный способ, но без, system.exit()когда вы хотите выйти, вызовите этот метод:

public void exit() {
    startActivity(new Intent(this, HomeActivity.class).
    setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | IntentCompat.FLAG_ACTIVITY_CLEAR_TASK).putExtra(EXIT_FLAG, true));
}

В вашем HomeActivity.onCreate()добавьте следующий код

protected void onCreate(Bundle savedInstanceState) {
    if (getIntent().getBooleanExtra(EXIT_FLAG, false)) {
        if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) == 0) {
            finish();
        }
    }
......................

Это будет работать без нарушения жизненного цикла Android.


7

Прежде всего, никогда не используйте System.exit (0). Это как заставить человека спать, бить его по голове!

Второе: я сталкиваюсь с этой проблемой. Прежде чем поделиться своим решением, я хочу поделиться своими мыслями.

Я думаю, что «Кнопка выхода» глупа. Действительно действительно очень глупо. И я думаю, что пользователи (потребители), которые просят кнопку выхода для вашего приложения, тоже глупы. Они не понимают, как работает ОС и как управляет ресурсами (и она отлично работает).

Я думаю, что если вы напишите хороший кусок кода, который будет делать правильные вещи (обновления, сохранять и отправлять сообщения) в нужный момент и в определенных условиях и с использованием правильных вещей (Service и Receiver), он будет работать довольно хорошо, и никто не будет жаловаться ,

Но для этого вам нужно изучить и узнать, как все работает на Android. В любом случае, это мое решение предоставить пользователям «кнопку выхода».

Я создал меню опций, всегда видимое в каждом действии (у меня есть супер-активность, которая делает это).

Когда пользователь нажимает на эту кнопку, вот что происходит:

Intent intent = new Intent(this, DashBoardActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

SharedPreferences settings = getSharedPreferences(getString(PREF_ID), Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(FORCE_EXIT_APPLICATION, true);

  // Commit the edits!
editor.commit();
startActivity(intent);
finish();

Поэтому я сохраняю в SharedPreferences то, что хочу убить мое приложение, и запускаю Intent. Пожалуйста, посмотрите на эти флаги; они очистят весь мой backstack, вызвав мою активность DashBoard, которая является моей «домашней» деятельностью.

Таким образом, в моей деятельности Dashboard я запускаю этот метод в onResume:

private void checkIfForceKill() {

    // CHECK IF I NEED TO KILL THE APP

    // Restore preferences
    SharedPreferences settings = getSharedPreferences(
            getString(MXMSettingHolder.PREF_ID), Context.MODE_PRIVATE);
    boolean forceKill = settings.getBoolean(
            MusicSinglePaneActivity.FORCE_EXIT_APPLICATION, false);

    if (forceKill) {

        //CLEAR THE FORCE_EXIT SETTINGS
        SharedPreferences.Editor editor = settings.edit();
        editor.putBoolean(FORCE_EXIT_APPLICATION, false);

        // Commit the edits!
        editor.commit();

        //HERE STOP ALL YOUR SERVICES
        finish();
    }
}

И это будет работать довольно хорошо.

Единственное, что я не понимаю, почему это происходит, так это то, что, когда я делаю последний финиш (и я проверил: он выполняет весь правильный поток onPause → onStop → onDestroy), приложение все еще находится в недавнем действии (но это пусто).

Похоже, что последнее намерение (которое запустило DashboardActivity) все еще находится в системе.

Я должен копать больше, чтобы также удалить его.


8
Не многие потребители знают, что такое ОС, не говоря уже о том, как она работает, это не делает их глупыми. Желание кнопки выхода / выхода / выключения делает их нормальными. Когда вы выходите из комнаты, вы выключаете свет, что более важно, выходя из дома, вы закрываете дверь, и именно здесь я вижу проблему с невозможностью правильно выйти из программы. Оставлять программу в фоновом режиме - большая угроза безопасности.
Squiggles

4
«Я думаю, что« кнопка выхода »глупа». Большинство программных приложений предоставляют кнопку выхода.
Игорь Ганапольский

Вы сказали «// ЗДЕСЬ ОСТАНОВИТЕ ВСЕ СВОИ УСЛУГИ», а затем использовали finish (). Сервисы Android не имеют метода finish (). У них есть unbindService (mConnection);
Игорь Ганапольский

@ Squiggles Если у вас есть комната, которая автоматически выключает все свои огни и закрывает дверь, когда вы уходите, вам не нужно об этом заботиться.
Сешу Винай

7

Жизненный цикл приложения Android предназначен для пользователей мобильных телефонов, а не пользователей компьютеров.

Жизненный цикл приложения - это чрезвычайно упрощенная парадигма, необходимая для превращения сервера Linux в потребительское устройство.

Android - это Java поверх Linux, настоящая кроссплатформенная серверная ОС. Вот как это распространилось так быстро. Жизненный цикл приложения инкапсулирует основную реальность ОС.

Для мобильных пользователей приложения просто установлены или не установлены. Нет концепции бега или выхода. Фактически, процессы приложения должны запускаться до тех пор, пока ОС не выпустит их для своих удерживаемых ресурсов.

Поскольку это переполнение стека, любой, кто читает это, является пользователем компьютера и должен отключить 90% своих знаний, чтобы понять жизненный цикл мобильного приложения.


Я не следую вашему прыжку: «Пользователи компьютеров должны отключить 90% своих знаний». Да, так говорит Ромен Гай, но от этого не получается. Мне кажется, что раздел «Дополнительные параметры для пользователей компьютеров» с кнопкой «Выйти» мог бы удовлетворить потребности каждого.
Дон Хэтч

Я понятия не имею, кто этот «Ромэн Гай» или почему он цитирует меня. Закрытие последних задач приведет к выходу из приложения, равно как и к остановке из информации о приложении. ADB обеспечивает доступ к оболочке для опытных пользователей.
Доминик Черизано

6

Мне потребовалось больше времени, чтобы прочитать эти вопросы и ответы, чем на самом деле реализовать полу-правильный жизненный цикл приложения Android.

Это приложение GPS, которое опрашивает точки и отправляет текущее местоположение в веб-сервис каждые несколько секунд, используя поток ... Это может быть опрос каждые 5 минут в случае Теда для обновления, тогда onStop может просто запустить операцию обновления, которую Тед был так обеспокоен тем, найдется ли кто-нибудь (асинхронный Тед, не пишите код, как программист Windows, иначе ваши программы будут работать как программы Windows ... например, это не так сложно).

Я сделал некоторый начальный код в onCreate, чтобы настроить вещи на время жизни действия, включая checkUpdate.start();:

...

@Override
public void onStart() {
    super.onStart();
    isRemote = true;
    checkUpdate.resume();

    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 0, luh);
}

@Override
public void onPause() {
    isRemote = false;
    checkUpdate.suspend();
    locationManager.removeUpdates(luh);
    super.onStop();
}

Этот код может быть полностью неверным, но он работает. Это одно из моих первых приложений для Android.

Вуаля, приложение, которое не использует ЦП, когда оно находится в фоновом режиме, но мгновенно готово к открытию, потому что оно находится в ОЗУ (хотя не удерживает ОЗУ, как жизненный цикл Android) ... приложение всегда готово, это телефон , ребята / девочки. Если приложение должно было использовать всю оперативную память и не могло быть закрыто ОС, то это могло бы перестать звонить = P. Вот почему ОС должна иметь возможность закрыть ваше приложение, когда оно находится в фоновом режиме (если ваше приложение не работает). не ресурс, он не будет закрыт, кстати, так что давайте просто напишем лучшие приложения.


Вы не должны вызывать super.onStop из метода onPause. Похоже, что это в основном испортит ситуацию.
Мэтт Вульф

1
После прочтения примерно 20 философских ответов, которые просто уклоняются от вопроса .... +1 за наличие некоторого кода.
Pacerier

6

Каждый раз, когда вы переходите к следующей странице через намерение, используйте:

`YourActivityname.this.finish()`;

Пример:

Intent intent = new Intent(getApplicationContext(), SMS.class);

startActivity(intent);
MainActivity.this.finish();

Чтобы никакие действия не выполнялись в фоновом режиме, а когда вы хотите выйти из приложения, используйте:

MainActivity.this.finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
getParent().finish();

Этот выход работал для меня как очарование :)


1
Он не выходит из приложения, а приходит в Mainactivity.
Шарат

1
Но будьте осторожны - onPause () НЕ вызывается в случае killProcess и System.exit. У нас были некоторые проблемы с этим.
Павел Бирюков

4

В любом случае, если вы хотите прекратить действие вашей заявки, вы всегда можете позвонить System.exit(0);.


5
System.exit()НЕ убивает ваше приложение, если у вас есть более одного действия в стеке. Разработчик Android, который использует его, не понимает основной жизненный цикл приложения Android. Прочитайте этот ответ .
Dheeraj Vepakomma

Полное решение с System.exit(0); stackoverflow.com/questions/2033914/…
Сохаил Захид

2
На самом деле, System.exit () действительно убивает ваше приложение. Однако, если System.exit () был вызван не из основного действия, а из другого места, android перезапустит приложение с одним действием в стеке. Мне это кажется нелепым ответом на чистый преднамеренный выход System.exit. Я имею в виду, если бы это был div0 или какой-то непреднамеренный сбой, возможно, было бы вежливо перезапустить. Но они даже не вызывают автоматический перезапуск, насколько я помню. Но в любом случае, приложение будет убит. Он может быть перезапущен, но это не значит, что он не был убит.
Джесси Гордон

3

Если у вас работает 10,20 .. несколько Активностей, и вы хотите завершить все и выйти из системы.

Создать статический массив в application classилиconstants class.

Константы

public class Constants {

public static ArrayList<Activity> activities = new ArrayList<Activity>();

}

MainActivity Добавить ссылку на текущую активность в этот массив

activity = MainActivity.this; Constants.activities.add(activity);

public class MainActivity extends Activity {

    private ImageView imageButton;
    private Activity activity;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        activity = MainActivity.this;
        Constants.activities.add(activity);

        imageButton = (ImageView) findViewById(R.id.camera);
        imageButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                // existing app.
                if (Constants.activities != null) {
                    for (int i = 0; i < Constants.activities.size(); i++) {
                        Activity s = Constants.activities.get(i);
                        s.finish();
                    }
                }
                //super.finish();
                finish();
                android.os.Process.killProcess(android.os.Process.myPid());
                System.exit(1);
            }
        });
    }
}

1
Это может привести к сбою вашего приложения, когда пользователи дважды нажимают на кнопку, особенно когда система по какой-либо причине находится под большой нагрузкой. Этого можно избежать, удалив действия из массива.
Надеюсь, что вы
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.