• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1page.title=Задачи и стек переходов назад
2parent.title=Операции
3parent.link=activities.html
4@jd:body
5
6<div id="qv-wrapper">
7<div id="qv">
8
9<h2>Содержание документа</h2>
10<ol>
11<li><a href="#ActivityState">Сохранение состояния операции</a></li></li>
12<li><a href="#ManagingTasks">Управление задачами</a>
13  <ol>
14    <li><a href="#TaskLaunchModes">Определение режимов запуска</a></li>
15    <li><a href="#Affinities">Обработка привязок</a></li>
16    <li><a href="#Clearing">Очистка стека переходов назад</a></li>
17    <li><a href="#Starting">Запуск задачи</a></li>
18  </ol>
19</li>
20</ol>
21
22<h2>Статьи</h2>
23<ol>
24  <li><a href="http://android-developers.blogspot.com/2010/04/multitasking-android-way.html">
25Многозадачность в системе Android</a></li>
26</ol>
27
28<h2>См. также:</h2>
29<ol>
30  <li><a href="{@docRoot}design/patterns/navigation.html">Дизайн Android:
31навигация</a></li>
32  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html">Элемент манифеста
33{@code &lt;activity&gt;}</a></li>
34  <li><a href="{@docRoot}guide/components/recents.html">Экран обзора</a></li>
35</ol>
36</div>
37</div>
38
39
40<p>Обычно приложение содержит несколько <a href="{@docRoot}guide/components/activities.html">операций</a>. Каждая операция
41должна разрабатываться в связи с действием определенного типа, которое пользователь может выполнять, и может запускать другие
42операции. Например, приложение электронной почты может содержать одну операцию для отображения списка новых сообщений.
43Когда пользователь выбирает сообщение, открывается новая операция для просмотра этого сообщения.</p>
44
45<p>Операция может даже запускать операции, существующие в других приложениях на устройстве. Например,
46если ваше приложение хочет отправить сообщение электронной почты, вы можете определить намерение для выполнения
47действия «отправить» и включить в него некоторые данные, например, адрес электронной почты и текст сообщения. После этого открывается операция из другого
48приложения, которая объявила, что она обрабатывает намерения такого типа. В этом случае намерение состоит в том, чтобы
49отправить сообщение электронной почты, поэтому в приложении электронной почты запускается операция «составить сообщение» (если одно намерение
50может обрабатываться несколькими операциями, система предлагает пользователю выбрать, какую из операций использовать). После отправки сообщения электронной почты
51ваша операция возобновляет работу, и все выглядит так, будто операция отправки электронной почты является частью вашего приложения. Хотя
52операции могут быть частями разных приложений, система Android поддерживает удобство работы
53пользователя, сохраняя обе операции в одной <em>задаче</em>.</p>
54
55<p>Задача — это коллекция операций, с которыми взаимодействует пользователь
56при выполнении определенного задания. Операции упорядочены в виде стека (<em>стека переходов назад</em>), в том
57порядке, в котором открывались операции.</p>
58
59<!-- SAVE FOR WHEN THE FRAGMENT DOC IS ADDED
60<div class="sidebox-wrapper">
61<div class="sidebox">
62<h3>Adding fragments to a task's back stack</h3>
63
64<p>Your activity can also include {@link android.app.Fragment}s to the back stack. For example,
65suppose you have a two-pane layout using fragments, one of which is a list view (fragment A) and the
66other being a layout to display an item from the list (fragment B). When the user selects an item
67from the list, fragment B is replaced by a new fragment (fragment C). In this case, it might be
68desireable for the user to navigate back to reveal fragment B, using the <em>Back</em> button.</p>
69<p>In order to add fragment B to the back stack so that this is possible, you must call {@link
70android.app.FragmentTransaction#addToBackStack addToBackStack()} before you {@link
71android.app.FragmentTransaction#commit()} the transaction that replaces fragment B with fragment
72C.</p>
73<p>For more information about using fragments and adding them to the back stack, see the {@link
74android.app.Fragment} class documentation.</p>
75
76</div>
77</div>
78-->
79
80<p>Начальным местом для большинства задач является главный экран устройства. Когда пользователь касается значка в средстве
81запуска
82приложений (или ярлыка на главном экране), эта задача приложения переходит на передний план. Если для
83приложения нет задач (приложение не использовалось в последнее время), тогда создается новая задача
84и открывается «основная» операция для этого приложения в качестве корневой операции в стеке.</p>
85
86<p>Когда текущая операция запускает другую, новая операция помещается в вершину стека
87и получает фокус. Предыдущая операция остается в стеке, но ее выполнение останавливается. Когда операция останавливается
88, система сохраняет текущее состояние ее пользовательского интерфейса. Когда пользователь нажимает кнопку
89<em>Назад</em>,
90текущая операция удаляется из вершины стека (операция уничтожается) и возобновляется
91работа предыдущей операции (восстанавливается предыдущее состояние ее пользовательского интерфейса). Операции в стеке
92никогда не переупорядочиваются, только добавляются в стек и удаляются из него — добавляются в стек при запуске текущей операцией
93и удаляются, когда пользователь выходит из нее с помощью кнопки <em>Назад</em>. По существу,
94стек
95переходов назад работает по принципу «последним вошел — первым вышел». На рисунке 1 это поведение
96показано на временной шкале: состояние операций и текущее состояние стека переходов назад
97 показано в каждый момент времени.</p>
98
99<img src="{@docRoot}images/fundamentals/diagram_backstack.png" alt="" />
100<p class="img-caption"><strong>Рисунок 1.</strong> Иллюстрация того, как каждая новая операция в задаче
101добавляет элемент в стек переходов назад. Когда пользователь нажимает кнопку<em>Назад</em>, текущая
102операция
103уничтожается, и возобновляется работа предыдущей операции.</p>
104
105
106<p>Если пользователь продолжает нажимать кнопку <em>Назад</em>, операции поочередно удаляются из стека,
107открывая
108предыдущую операцию, пока пользователь не вернется на главный экран (или в операцию, которая была запущена
109в начале выполнения задачи). Когда все операции удалены из стека, задача прекращает существование.</p>
110
111<div class="figure" style="width:287px">
112<img src="{@docRoot}images/fundamentals/diagram_multitasking.png" alt="" /> <p
113class="img-caption"><strong>Рисунок 2.</strong> Две задачи: Задача B взаимодействует с пользователем
114на переднем плане, тогда как Задача A находится в фоновом режиме, ожидая возобновления.</p>
115</div>
116<div class="figure" style="width:215px">
117  <img src="{@docRoot}images/fundamentals/diagram_multiple_instances.png" alt="" /> <p
118class="img-caption"><strong>Рисунок 3.</strong> Создается несколько экземпляров одной операции.</p>
119</div>
120
121<p>Задача — это связанный блок, который может переходить в фоновый режим, когда пользователи начинают новую задачу или переходят
122на главный экран с помощью кнопки <em>Домой</em>. В фоновом режиме все операции
123задачи
124остановлены, но стек обратного вызова для задачи остается неизменным. Задача просто потеряла фокус во время
125выполнения другой задачи, как показано на рисунке 2. Затем задача может вернуться на передний план, так что пользователи
126могут продолжить ее с прерванного места. Предположим, например, что текущая задача (Задача A) содержит три операции
127в своем стеке — две операции под текущей операцией. Пользователь нажимает кнопку <em>Домой</em>,
128 затем запускает
129новое приложение из средства запуска приложений. Когда появляется главный экран, Задача A переходит
130в фоновый режим. Когда запускается новое приложение, система запускает задачу для этого приложения
131(Задачу B) со своим собственным стеком операций. После взаимодействия с этим
132приложением пользователь снова возвращается на главный экран и выбирает изначально запущенную
133Задачу A. Теперь Задача A переходит на передний
134план — все три операции ее стека остались неизменными, и возобновляется операция, находящаяся на
135вершине стека. В этот
136момент пользователь может также переключиться обратно на Задачу B, перейдя на главный экран и выбрав значок приложения,
137которое запустило эту задачу (или выбрав задачу приложения на
138<a href="{@docRoot}guide/components/recents.html">экране обзора</a>).
139Это пример многозадачности в системе Android.</p>
140
141<p class="note"><strong>Примечание.</strong> В фоновом режиме может находиться несколько задач одновременно.
142Однако, если пользователь запускает много фоновых задач одновременно, система может начать
143уничтожение фоновых операций для освобождения памяти, что приведет к потере состояния задач.
144См. следующий раздел <a href="#ActivityState">Состояние операции</a>.</p>
145
146<p>Поскольку операции в стеке никогда не переупорядочиваются, если ваше приложение позволяет
147пользователям запускать определенную операцию из нескольких операций, новый экземпляр
148такой операции создается и помещается в стек (вместо помещения любого из предыдущих экземпляров
149операции на вершину стека). По существу, для одной операции вашего приложения может быть создано несколько
150экземпляров (даже из разных задач), как показано на рисунке 3. Поэтому, если пользователь переходит назад с помощью
151кнопки <em>Назад</em>, каждый экземпляр операции появляется в том порядке, в котором они
152были открыты (каждый
153со своим состоянием пользовательского интерфейса). Однако вы можете изменить это поведение, если вы не хотите, чтобы создавалось несколько
154экземпляров операции. Это описано в разделе <a href="#ManagingTasks">Управление задачами</a> ниже.</p>
155
156
157<p>Подведем итоги поведения операций и задач:</p>
158
159<ul>
160  <li>Когда Операция A запускает Операцию B, Операция A останавливается, но система сохраняет ее состояние
161(например, положение прокрутки и текст, введенный в формы).
162Если пользователь нажимает кнопку <em>Назад</em> в Операции B, Операция A возобновляет работу
163из сохраненного состояния.</li>
164  <li>Когда пользователь выходит из задачи нажатием кнопки <em>Домой</em>, текущая операция
165останавливается и
166ее задача переводится в фоновый режим. Система сохраняет состояние каждой операции в задаче. Если
167пользователь впоследствии возобновляет задачу, выбирая значок запуска задачи, она переводится
168на передний план и возобновляет операцию на вершине стека.</li>
169  <li>Если пользователь нажимает кнопку <em>Назад</em>, текущая операция удаляется из стека
170и
171уничтожается. Возобновляется предыдущая операция в стеке. Когда операция уничтожается, система
172<em>не</em> сохраняет состояние операции.</li>
173  <li>Можно создавать несколько экземпляров операции, даже из других задач.</li>
174</ul>
175
176
177<div class="note design">
178<p><strong>Дизайн навигации</strong></p>
179  <p>Для получения дополнительной информации о работе навигации в приложении Android, прочитайте раздел <a href="{@docRoot}design/patterns/navigation.html">Навигация</a> руководства «Дизайн для Android».</p>
180</div>
181
182
183<h2 id="ActivityState">Сохранение состояния операции</h2>
184
185<p>Как говорилось выше, система по умолчанию сохраняет состояние операции, когда она
186останавливается. Таким образом, когда пользователи возвращаются обратно в предыдущую операцию, восстанавливается ее пользовательский интерфейс
187в момент остановки. Однако вы можете — и <strong>должны</strong> — с упреждением сохранять
188состояние ваших операций посредством методов обратного вызова на случай уничтожения операции и необходимости ее
189повторного создания.</p>
190
191<p>Когда система останавливает одну из ваших операций (например, когда запускается новая операция или задача
192перемещается в фоновый режим), система может полностью уничтожить эту операцию, если необходимо восстановить
193память системы. Когда это происходит, информация о состоянии операции теряется. Если это происходит,
194система
195знает, что операция находится в стеке переходов назад, но когда операция переходит
196на вершину стека, система должна создать ее повторно (а не возобновить ее). Чтобы избежать
197потери работы пользователя, вы должны с упреждением сохранять ее путем реализации методов
198обратного вызова {@link android.app.Activity#onSaveInstanceState onSaveInstanceState()}
199в вашей операции.</p>
200
201<p>Дополнительную информацию о сохранении состояния вашей операции см. в документе
202<a href="{@docRoot}guide/components/activities.html#SavingActivityState">Операции</a>.</p>
203
204
205
206<h2 id="ManagingTasks">Управление задачами</h2>
207
208<p>Для большинства приложений способ, которым Android управляет задачами и стеком переходов назад, описанный выше, — помещение всех
209операций последовательно в одну задачу в стек «последним вошёл — первым вышел», —
210работает хорошо, и вы не должны беспокоиться о связи ваших операций с задачами
211или об их существовании в стеке переходов назад. Однако вы можете решить, что вы хотите прервать
212обычное поведение. Возможно, вы хотите, чтобы операция в вашем приложении начинала новую задачу
213при запуске (вместо помещения в текущую задачу), или при запуске операции вы хотите
214перенести на передний план ее существующий экземпляр (вместо создания нового
215экземпляра на вершине стека переходов назад), или вы хотите чтобы при выходе пользователя из задачи из вашего стек переходов удалялись все
216операции, кроме корневой операции.</p>
217
218<p>Вы можете совершать эти и многие другие действия с помощью атрибутов в элементе манифеста
219<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
220и с помощью флагов в намерении, которое вы передаете в
221{@link android.app.Activity#startActivity startActivity()}.</p>
222
223<p>В этом смысле главными атрибутами <a href="{@docRoot}guide/topics/manifest/activity-element.html">
224{@code &lt;activity&gt;}</a>, которые вы можете использовать, являются следующие:</p>
225
226<ul class="nolist">
227  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#aff">
228  {@code taskAffinity}</a></li>
229  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">
230  {@code launchMode}</a></li>
231  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#reparent">
232  {@code allowTaskReparenting}</a></li>
233  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#clear">
234  {@code clearTaskOnLaunch}</a></li>
235  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#always">
236  {@code alwaysRetainTaskState}</a></li>
237  <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#finish">
238  {@code finishOnTaskLaunch}</a></li>
239</ul>
240
241<p>А главными флагами намерений, которые вы можете использовать, являются следующие:</p>
242
243<ul class="nolist">
244  <li>{@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK}</li>
245  <li>{@link android.content.Intent#FLAG_ACTIVITY_CLEAR_TOP}</li>
246  <li>{@link android.content.Intent#FLAG_ACTIVITY_SINGLE_TOP}</li>
247</ul>
248
249<p>В следующих разделах показано, как можно использовать эти атрибуты манифеста и флаги
250намерений для определения связи операций с задачами и их поведения в стеке переходов назад.</p>
251
252<p>Кроме того, отдельно обсуждаются рекомендации о представлении задач и операций и управлении ими
253на экране обзора. Дополнительную информацию см. в разделе
254<a href="{@docRoot}guide/components/recents.html">Экран обзора</a>. Обычно следует разрешить системе определить способ представления вашей задачи и
255операций на экране обзора. Вам не нужно менять это поведение.</p>
256
257<p class="caution"><strong>Внимание!</strong> В большинстве приложений не следует прерывать поведение
258операций и задач по умолчанию. Если вы обнаружили, что вашей операции необходимо изменить
259поведение по умолчанию, будьте внимательны и протестируйте удобство работы с операцией во время
260запуска и при обратной навигации к ней из других операций и задач с помощью кнопки <em>Назад</em>.
261Обязательно протестируйте поведение навигации, которое может противоречить поведению, ожидаемому пользователем.</p>
262
263
264<h3 id="TaskLaunchModes">Определение режимов запуска</h3>
265
266<p>Режимы запуска позволяют вам определять связь нового экземпляра операции
267с текущей задачей. Вы можете задавать различные режимы запуска двумя способами:</p>
268<ul class="nolist">
269  <li><a href="#ManifestForTasks">Использование файла манифеста</a>
270    <p>Когда вы объявляете операцию в вашем файле манифеста, вы можете указать, как операция
271должна связываться с задачами при ее запуске.</li>
272  <li><a href="#IntentFlagsForTasks">Использование флагов намерений</a>
273    <p>Когда вы вызываете {@link android.app.Activity#startActivity startActivity()},
274вы можете включить флаг в {@link android.content.Intent}, который объявляет, как должна быть связана
275новая операция с текущей задачей (и должна ли).</p></li>
276</ul>
277
278<p>По существу, если Операция A запускает Операцию B, Операция B может определить в своем манифесте, как она
279должна быть связана с текущей задачей (если вообще должна), а Операция A может также запросить, как Операция B
280должна быть связана с текущей задачей. Если обе операции определяют, как Операция B
281должна быть связана с задачей, тогда запрос Операции A (как определено в намерении) обрабатывается через
282запрос Операции B (как определено в ее манифесте).</p>
283
284<p class="note"><strong>Примечание.</strong> Некоторые режимы запуска, доступные для файла манифеста,
285недоступны в виде флагов для намерения и, аналогичным образом, некоторые режимы запуска, доступные в виде флагов
286для намерения, не могут быть определены в манифесте.</p>
287
288
289<h4 id="ManifestForTasks">Использование файла манифеста</h4>
290
291<p>При объявлении операции в вашем файле манифеста вы можете указать, как операция должна
292быть связана с задачей посредством атрибута <a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code
293launchMode}</a>
294элемента <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>.</p>
295
296<p>Атрибут <a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code
297launchMode}</a> указывает инструкцию по запуску операции в
298задаче. Существует четыре различных режима запуска,
299которые вы можете назначить атрибуту
300<code><a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">launchMode</a></code>:</p>
301
302<dl>
303<dt>{@code "standard"} (режим по умолчанию)</dt>
304  <dd>Режим по умолчанию. Система создает новый экземпляр операции в задаче, из
305которой она была запущена, и направляет ему намерение. Может быть создано несколько экземпляров операции,
306каждый экземпляр может принадлежать различным задачам, и одна задача может содержать несколько экземпляров.</dd>
307<dt>{@code "singleTop"}</dt>
308  <dd>Если экземпляр операции уже существует на вершине текущей задачи, система
309направляет намерение в этот экземпляр путем вызова его метода {@link
310android.app.Activity#onNewIntent onNewIntent()}, а не путем создания нового экземпляра
311операции. Может быть создано несколько экземпляров операции, каждый экземпляр может
312принадлежать различным задачам, и одна задача может содержать несколько экземпляров (но только если
313операция на вершине стека переходов назад <em>не</em> является существующим экземпляром операции).
314  <p>Предположим, что стек переходов назад задачи состоит из корневой операции A с операциями B, C
315и D на вершине (стек имеет вид A-B-C-D и D находится на вершине). Поступает намерение для операции типа D.
316Если D имеет режим запуска {@code "standard"} по умолчанию, запускается новый экземпляр класса и
317стек принимает вид A-B-C-D-D. Однако, если D имеет режим запуска {@code "singleTop"}, существующий экземпляр
318D получает намерение через {@link
319android.app.Activity#onNewIntent onNewIntent()}, так как этот экземпляр находится на вершине стека —
320стек сохраняет вид A-B-C-D. Однако, если поступает намерение для операции типа B, тогда в стек
321добавляется новый экземпляр B, даже если он имеет режим запуска {@code "singleTop"}.</p>
322  <p class="note"><strong>Примечание.</strong> Когда создается новый экземпляр операции,
323пользователь может нажать кнопку <em>Назад</em> для возврата к предыдущей операции. Но когда существующий
324экземпляр
325операции обрабатывает новое намерение, пользователь не может нажать кнопку <em>Назад</em> для возврата к
326состоянию
327операции до поступления нового намерения в {@link android.app.Activity#onNewIntent
328onNewIntent()}.</p>
329</dd>
330
331<dt>{@code "singleTask"}</dt>
332  <dd>Система создает новую задачу и создает экземпляр операции в корне новой задачи.
333Однако, если экземпляр операции уже существует в отдельной задаче, система направляет
334намерение в существующий экземпляр путем вызова его метода {@link
335android.app.Activity#onNewIntent onNewIntent()}, а не путем создания нового экземпляра. Одновременно
336может существовать только один экземпляр операции.
337  <p class="note"><strong>Примечание.</strong> Хотя операция запускает новую задачу, кнопка
338<em>Назад</em> возвращает пользователя к предыдущей операции.</p></dd>
339<dt>{@code "singleInstance"}.</dt>
340  <dd>То же, что и {@code "singleTask"}, но при этом система не запускает никаких других операций
341в задаче, содержащей этот экземпляр. Операция всегда является единственным членом своей задачи;
342любые операции, запущенные этой операцией, открываются в отдельной задаче.</dd>
343</dl>
344
345
346<p>В качестве другого примера: приложение Android Browser объявляет, что операция веб-браузера должна
347всегда открываться в своей собственной задаче — путем указания режима запуска {@code singleTask} в элементе <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>.
348Это означает, что если ваше приложение выдает
349намерение открыть Android Browser, его операция <em>не</em> помещается в ту же
350задачу, что и ваше приложение. Вместо этого, либо для браузера запускается новая задача, либо, если браузер уже
351имеет задачу, работающую в фоновом режиме, эта задача переводится на передний план для обработки нового
352намерения.</p>
353
354<p>И при запуске операции в новой задаче, и при запуске операции в существующей задаче,
355 кнопка <em>Назад</em> всегда возвращает пользователя к предыдущей операции. Однако, если вы
356запускаете операцию, которая указывает режим запуска {@code singleTask}, вся задача переводится на передний план, если экземпляр
357этой операции существует в фоновой задаче. В этот момент
358стек переходов назад помещает все операции из задачи, переведенной на передний план, на вершину
359стека. Рисунок 4 иллюстрирует сценарий этого типа.</p>
360
361<img src="{@docRoot}images/fundamentals/diagram_backstack_singletask_multiactivity.png" alt="" />
362<p class="img-caption"><strong>Рисунок 4.</strong> Представление того, как операция с режимом
363запуска singleTask добавляется в стек переходов назад. Если операция уже является частью
364фоновой задачи со своим собственным стеком переходов назад, то весь стек переходов назад также переносится вверх,
365на вершину текущей задачи.</p>
366
367<p>Дополнительную информацию об использовании режимов запуска в файле манифеста см. в документации элемента
368<code><a href="{@docRoot}guide/topics/manifest/activity-element.html">&lt;activity&gt;</a></code>,
369 где более подробно обсуждаются атрибут {@code launchMode}
370и принимаемые значения.</p>
371
372<p class="note"><strong>Примечание.</strong> Поведение, которое вы указываете для вашей операции с помощью атрибута <a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code launchMode}</a>,
373может быть переопределено флагами, включенными в намерение, которое запускает вашу операцию, как описано
374в следующем разделе.</p>
375
376
377
378<h4 id="#IntentFlagsForTasks">Использование флагов намерений</h4>
379
380<p>При запуске операции вы можете изменить связывание операции с ее задачей по умолчанию
381путем включения флагов в намерение, которое доставляется в {@link
382android.app.Activity#startActivity startActivity()}. Для изменения поведения по умолчанию
383вы можете использовать следующие флаги:</p>
384
385<p>
386  <dt>{@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK}</dt>
387    <dd>Запуск операции в новой задаче. Если задача уже работает для операции, которую вы запускаете
388сейчас, эта задача переводится на передний план, ее последнее состояние восстанавливается, и операция получает
389новое намерение в {@link android.app.Activity#onNewIntent onNewIntent()}.
390    <p>Это приводит к тому же поведению, что и значение <a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code launchMode}</a> в режиме {@code "singleTask"},
391как описано в предыдущем разделе.</p></dd>
392  <dt>{@link android.content.Intent#FLAG_ACTIVITY_SINGLE_TOP}</dt>
393    <dd>Если запускаемая операция является текущей операцией (находится на вершине стека переходов назад), тогда
394вызов в {@link android.app.Activity#onNewIntent onNewIntent()} получает существующий экземпляр,
395 без создания нового экземпляра операции.
396    <p>Это приводит к тому же поведению, что и значение <a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code launchMode}</a> в режиме {@code "singleTop"},
397как описано в предыдущем разделе.</p></dd>
398  <dt>{@link android.content.Intent#FLAG_ACTIVITY_CLEAR_TOP}</dt>
399    <dd>Если запускаемая операция уже работает в текущей задаче, тогда вместо
400запуска нового экземпляра этой операции уничтожаются все другие операции, расположенные в стеке выше нее
401, и это намерение доставляется в возобновленный экземпляр этой операции (которая теперь находится на вершине стека)
402посредством {@link android.app.Activity#onNewIntent onNewIntent()}).
403    <p>Для формирования такого поведения не существует значения для атрибута
404<a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code launchMode}</a>.</p>
405    <p>Флаг {@code FLAG_ACTIVITY_CLEAR_TOP} чаще всего используется совместно с
406флагом {@code FLAG_ACTIVITY_NEW_TASK}.
407При использовании вместе эти флаги позволяют найти существующую операцию
408в другой задаче и поместить ее в положение, где она сможет реагировать на намерение. </p>
409    <p class="note"><strong>Примечание.</strong> Если для назначенной операции установлен режим запуска
410{@code "standard"},
411она также удаляется из стека и на ее месте запускается новый экземпляр, чтобы обработать
412входящее намерение.  Именно поэтому в режиме запуска {@code "standard"} всегда создается новый
413экземпляр для нового намерения. </p>
414</dd>
415</dl>
416
417
418
419
420
421<h3 id="Affinities">Обработка привязок</h3>
422
423<p><em>Привязка</em> указывает предпочтительную принадлежность операции к задаче. По умолчанию все
424операции из одного приложения имеют привязку друг к другу. Поэтому по умолчанию все
425операции одного приложения предпочитают находиться в одной задаче. Однако вы можете изменить
426привязку по умолчанию для операции. Операции, определенные
427в разных приложениях, могут совместно использовать одну привязку; таким же образом операции, определенные в одном приложении, могут получить
428привязки к разным задачам.</p>
429
430<p>Вы можете изменить привязку любой данный операции с помощью
431атрибута <a href="{@docRoot}guide/topics/manifest/activity-element.html#aff">{@code taskAffinity}</a>
432элемента <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>.</p>
433
434<p>Атрибут <a href="{@docRoot}guide/topics/manifest/activity-element.html#aff">{@code taskAffinity}</a>
435принимает строковое значение, которое должно отличаться от имени пакета по умолчанию,
436объявленного в элементе <a href="{@docRoot}guide/topics/manifest/manifest-element.html">
437{@code &lt;manifest&gt;}
438</a>, поскольку система использует это имя для идентификации привязки задачи по умолчанию
439для приложения.</p>
440
441<p>Привязка вступает в игру в двух случаях:</p>
442<ul>
443  <li>Когда намерение, запускающее
444операцию, содержит флаг
445{@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK}.
446
447<p>Новая операция по умолчанию запускается в задаче той операции,
448которая вызвала {@link android.app.Activity#startActivity startActivity()}. Она помещается в тот же
449стек переходов назад, что и вызывающая операция.  Однако, если намерение, переданное
450в {@link android.app.Activity#startActivity startActivity()},
451содержит флаг {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK},
452 система ищет другую задачу для помещения новой операции. Часто это новая задача.
453Но необязательно.  Если уже существует задача с той же привязкой, что
454и у новой операции, операция запускается в этой задаче.  Если нет, операция начинает новую задачу.</p>
455
456<p>Если этот флаг приводит к тому, что операция начинает новую задачу, и пользователь нажимает кнопку <em>Домой</em>
457для выхода из нее,
458должен существовать способ, позволяющий пользователю вернуться к задаче. Некоторые объекты (такие как
459диспетчер уведомлений) всегда запускают операции во внешней задаче, а не в составе собственной, поэтому
460они всегда помещают флаг {@code FLAG_ACTIVITY_NEW_TASK} в намерения, которые они передают
461в {@link android.app.Activity#startActivity startActivity()}.
462Если у вас есть операция, которую можно вызвать
463внешним объектом, использующим этот флаг, позаботьтесь о том, чтобы у пользователя был независимый способ
464вернуться в запущенную задачу, например, с помощью значка запуска (корневая операция задачи
465содержит фильтр намерений {@link android.content.Intent#CATEGORY_LAUNCHER}; см. раздел <a href="#Starting">Запуск задачи</a> ниже).</p>
466</li>
467
468  <li>Если для атрибута <a href="{@docRoot}guide/topics/manifest/activity-element.html#reparent">
469{@code allowTaskReparenting}</a> операции установлено значение {@code "true"}.
470  <p>В этом случае операция может переместиться из запустившей ее задачи в задачу, к которой у операции есть привязка,
471когда эта задача переходит на передний план.</p>
472  <p>Предположим, что операция, которая сообщает о погодных условиях в выбранных городах,
473определена в составе приложения для путешественников.  Она имеет ту же привязку, что и другие операции в том же
474приложении (привязка приложения по умолчанию), и допускает переподчинение с этим атрибутом.
475Когда одна из ваших операций запускает операцию прогноза погоды, она изначально принадлежит той же
476задаче, что и ваша операция. Однако, когда задача из приложения для путешественников переходит на передний план,
477операция прогноза погоды переназначается этой задаче и отображается внутри нее.</p>
478</li>
479</ul>
480
481<p class="note"><strong>Совет.</strong> Если файл {@code .apk} содержит более одного «приложения»
482с точки зрения пользователя, вы, вероятно, захотите использовать атрибут <a href="{@docRoot}guide/topics/manifest/activity-element.html#aff">{@code taskAffinity}</a>
483для назначения разных привязок операциям, связанным с каждым «приложением».</p>
484
485
486
487<h3 id="Clearing">Очистка стека переходов назад</h3>
488
489<p>Если пользователь выходит из задачи на длительное время, система удаляет из задачи все операции, кроме
490корневой операции.  Когда пользователь возвращается в задачу, восстанавливается только корневая операция.
491Система ведет себя таким образом, так как после продолжительного времени пользователи обычно уже забросили то,
492чем они занимались ранее, и возвращаются в задачу, чтобы начать что-то новое. </p>
493
494<p>Для изменения такого поведения предусмотрено несколько атрибутов операции, которыми вы можете воспользоваться: </p>
495
496<dl>
497<dt><code><a
498href="{@docRoot}guide/topics/manifest/activity-element.html#always">alwaysRetainTaskState</a></code>
499</dt>
500<dd>Если для этого атрибута установлено значение {@code "true"} в корневой операции задачи,
501описанное выше поведение по умолчанию не происходит.
502Задача восстанавливает все операции в своем стеке даже по истечении длительного периода времени.</dd>
503
504<dt><code><a
505href="{@docRoot}guide/topics/manifest/activity-element.html#clear">clearTaskOnLaunch</a></code></dt>
506<dd>Если для этого атрибута установлено значение {@code "true"} в корневой операции задачи,
507стек очищается до корневой операции каждый раз, когда пользователь выходит из задачи
508и возвращается в нее.  Другими словами, этот атрибут противоположен атрибуту
509<a href="{@docRoot}guide/topics/manifest/activity-element.html#always">
510{@code alwaysRetainTaskState}</a>. Пользователь всегда возвращается в задачу в ее
511исходном состоянии, даже после кратковременного выхода из нее.</dd>
512
513<dt><code><a
514href="{@docRoot}guide/topics/manifest/activity-element.html#finish">finishOnTaskLaunch</a></code>
515</dt>
516<dd>Этот атрибут похож на <a href="{@docRoot}guide/topics/manifest/activity-element.html#clear">{@code clearTaskOnLaunch}</a>,
517но он действует на
518одну операцию, а не на всю задачу.  Он также может приводить к удалению любой операции,
519включая корневую операцию.  Когда для него установлено значение {@code "true"},
520операция остается частью задачи только для текущего сеанса.  Если пользователь
521выходит из задачи, а затем возвращается в нее, операция уже отсутствует.</dd>
522</dl>
523
524
525
526
527<h3 id="Starting">Запуск задачи</h3>
528
529<p>Вы можете сделать операцию точкой входа, назначая ей фильтр намерений со значением
530{@code "android.intent.action.MAIN"} в качестве указанного действия и
531{@code "android.intent.category.LAUNCHER"}
532в качестве указанной категории. Например:</p>
533
534<pre>
535&lt;activity ... &gt;
536    &lt;intent-filter ... &gt;
537        &lt;action android:name="android.intent.action.MAIN" /&gt;
538        &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
539    &lt;/intent-filter&gt;
540    ...
541&lt;/activity&gt;
542</pre>
543
544<p>Фильтр намерений такого типа приводит к тому, что в средстве запуска приложения отображаются значок и метка для
545операции, что позволяет пользователю запускать операцию
546и возвращаться в создавшую ее задачу в любой момент после ее запуска.
547</p>
548
549<p>Эта вторая возможность очень важна: пользователи должны иметь возможность выходить из задачи и затем возвращаться в нее
550с помощью этого средства запуска операции. Поэтому два <a href="#LaunchModes">режима
551запуска</a>, которые отмечают, что операции всегда инициируют задачу, {@code "singleTask"} и
552{@code "singleInstance"}, должны использоваться только в тех случаях, когда операция содержит
553{@link android.content.Intent#ACTION_MAIN}
554и фильтр {@link android.content.Intent#CATEGORY_LAUNCHER}. Представьте, например, что может произойти,
555если фильтр отсутствует: намерение запускает операцию {@code "singleTask"}, которая инициирует
556новую задачу, и пользователь некоторое время работает в этой задаче. Затем пользователь нажимает кнопку
557<em>Домой</em>. Задача переводится в фоновый режим и не отображается. Теперь у пользователя нет возможности вернуться
558к задаче, так как она отсутствует в средстве запуска приложения.</p>
559
560<p>Для таких случаев, когда вы не хотите, чтобы пользователь мог вернуться к операции, установите для атрибута
561<a href="{@docRoot}guide/topics/manifest/activity-element.html#finish">{@code finishOnTaskLaunch}</a>
562элемента
563<code><a href="{@docRoot}guide/topics/manifest/activity-element.html">&lt;activity&gt;</a></code>
564значение {@code "true"} (см. раздел <a href="#Clearing">Очистка стека</a>).</p>
565
566<p>Дополнительную информацию о представлении задач и операций и управлении ими
567на экране обзора см. в разделе <a href="{@docRoot}guide/components/recents.html">
568Экран обзора</a>.</p>
569
570<!--
571<h2>Beginner's Path</h2>
572
573<p>For more information about how to use intents to
574activate other application components and publish the intents to which your components
575respond, continue with the <b><a
576href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
577Filters</a></b> document.</p>
578-->
579