page.title=Запуск операции
page.tags=жизненный цикл операции
helpoutsWidget=true

trainingnavtop=true

@jd:body


<div id="tb-wrapper">
  <div id="tb">
    
    <h2>Содержание этого урока</h2>
<ol>
  <li><a href="#lifecycle-states">Изучение обратных вызовов жизненного цикла</a></li>
  <li><a href="#launching-activity">Указание операции, запускающей приложение</a></li>
  <li><a href="#Create">Создание нового экземпляра</a></li>
  <li><a href="#Destroy">Уничтожение операции</a></li>
</ol>
    
    <h2>См. также:</h2>
    <ul>
      <li><a href="{@docRoot}guide/components/activities.html">Операции</a></li>
    </ul>

<h2>Попробуйте сами</h2>

<div class="download-box">
 <a href="http://developer.android.com/shareables/training/ActivityLifecycle.zip" class="button">Загрузить демонстрацию</a>
 <p class="filename">ActivityLifecycle.zip</p>
</div>

  </div>
</div>

<p>В отличие от других парадигм программирования, где приложения запускаются с использованием метода {@code main()}, система
Android запускает код в {@link android.app.Activity}экземпляре посредством активации определенных 
методов обратного вызова, соответствующих определенным этапам его
жизненного цикла. Существует последовательность методов обратного вызова, которые запускают операцию и последовательность
методов обратного вызова, уничтожающих операцию.</p>

<p>В этом уроке рассматриваются наиболее важные методы жизненного цикла и демонстрируется, как
обработать первый обратный вызов жизненного цикла, создающий новый экземпляр операции.</p>


<h2 id="lifecycle-states">Изучение обратных вызовов жизненного цикла</h2>

<p>В течение цикла существования операции система вызывает базовый набор методов жизненного цикла в
последовательности, сходной с многоступенчатой пирамидой. Таким образом, каждый этап
жизненного цикла операции представляет собой отдельную ступень пирамиды. Когда система создает новый экземпляр операции,
каждый метод обратного вызова перемещает состояние действия на одну ступень вверх. Вершина пирамиды представляет собой
точку, в которой операция выполняется в экранном режиме, и пользователь может с ней взаимодействовать.</p>

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


<img src="{@docRoot}images/training/basics/basic-lifecycle.png" />
<p class="img-caption"><strong>Рисунок 1</strong>. Упрощенная иллюстрация жизненного цикла операции
в виде многоступенчатой пирамиды. На рисунке показано, что для каждого обратного вызова,
поднимающего операцию на одну ступень к состоянию возобновления на вершине пирамиды,
существует обратный вызов, опускающий операцию на одну ступень вниз. Возобновление операции также может производиться из состояний
паузы и остановки.</p>


<p>В зависимости от сложности операции, некоторые
методы жизненного цикла могут не требоваться. Однако очень важно понимать все методы и реализовать их так, чтобы
приложение работало так, как этого ожидают пользователи. Правильная реализация методов жизненного цикла операции
обеспечивает нормальную работу приложения в нескольких аспектах, в том числе:</p>
<ul>
  <li>Не прекращает работу, если пользователь получает телефонный звонок или переключается на другое приложение
во время использования вашего приложения.</li>
  <li>Не потребляет ценные системные ресурсы, когда пользователь не использует
его активно.</li>
  <li>Сохраняет состояние приложения, если пользователь выходит из него и возвращается
позднее.</li>
  <li>Не закрывается с ошибкой и не теряет данные пользователя при повороте экрана (смене ориентации между книжной
и альбомной.</li>
</ul>

<!--
<p class="table-caption"><strong>Table 1.</strong> Activity lifecycle state pairs and callback 
methods.</p>
<table>
  <tr>
    <th scope="col">Lifecycle State</th>
    <th scope="col">Startup Method</th>
    <th scope="col">Teardown Method</th>
  </tr>
  <tr>
    <td>Created / Destroyed</td>
    <td>{@link android.app.Activity#onCreate onCreate()}</td>
    <td>{@link android.app.Activity#onDestroy()}</td>
  </tr>
  <tr>
    <td>Started / Stopped</td>
    <td>{@link android.app.Activity#onStart()}</td>
    <td>{@link android.app.Activity#onStop()}</td>
  </tr>
  <tr>
    <td>Resumed / Resumed</td>
    <td>{@link android.app.Activity#onResume()}</td>
    <td>{@link android.app.Activity#onPause()}</td>
  </tr>
</table>
-->

<p>Как вы узнаете на следующих уроках, в некоторых ситуациях операция
переключается между разными состояниями, как показано на рисунке 1. Однако только три
из этих состояний могут быть статичными. Это означает, что операция может существовать относительно длительное
время только в одном из этих трех состояний.</p>
<dl>
  <dt>Возобновление</dt>
    <dd>В этом состоянии операция выполняется в экранном режиме, и пользователь может с ней взаимодействовать.
Иногда это состояние также называется рабочим состоянием.</dd>
  <dt>Приостановка</dt>
    <dd>В этом состоянии операция частично закрывается другой операцией &mdash; в экранном режиме
эта другая операция или является полупрозрачной, или не закрывает экран целиком. Приостановленная операция
не получает команд пользователя и не может выполнять код.
  <dt>Остановка</dt>
    <dd>В этом состоянии операция полностью скрыта и невидима для пользователя. Она считается находящейся в
фоновом режиме. В состоянии остановки сохраняется экземпляр операции и вся его информация
о состоянии, например, переменных, однако операция не может выполнять код.</dd>
</dl>

<p>Другие состояния (создание и запуск) являются переходными, и система быстро переходит от них
к следующим состояниям посредством вызова следующего метода обратного вызова в жизненном цикле. Таким образом, после вызова
{@link android.app.Activity#onCreate onCreate()} система быстро вызывает {@link
android.app.Activity#onStart()}, а затем сразу же вызывает {@link
android.app.Activity#onResume()}.</p>

<p>Так выглядит базовый жизненный цикл операции. Теперь рассмотрим определенные виды
поведения в жизненном цикле.</p>


<h2 id="launching-activity">Указание операции, запускающей приложение</h2> 

<p>Когда пользователь выбирает значок приложения на главном экране, система вызывает метод {@link
android.app.Activity#onCreate onCreate()} для {@link android.app.Activity} в вашем приложении
в соответствии с тем, какую операцию вы задекларировали как операцию запуска (или основную операцию). Эта операция выступает
основной точкой входа в пользовательский интерфейс вашего приложения.</p>

<p>Для определения основной операции вы можете использовать файл манифеста Android <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">{@code AndroidManifest.xml}</a>,
который находится в корневом каталоге вашего проекта.</p>

<p>Основная операция приложения должна декларироваться в манифесте с помощью фильтра <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
&lt;intent-filter&gt;}</a>, включающего действие {@link
android.content.Intent#ACTION_MAIN MAIN} и категорию
{@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER}. Например:</p> 

<pre>
&lt;activity android:name=".MainActivity" android:label="&#64;string/app_name">
    &lt;intent-filter>
        &lt;action android:name="android.intent.action.MAIN" />
        &lt;category android:name="android.intent.category.LAUNCHER" />
    &lt;/intent-filter>
&lt;/activity>
</pre>

<p class="note"><strong>Примечание.</strong> При создании нового проекта Android с помощью инструментов
Android SDK файлы проекта по умолчанию включают класс {@link android.app.Activity}, который декларируется в
манифесте с помощью этого фильтра.</p>

<p>Если для одной из операций не декларировано действие {@link android.content.Intent#ACTION_MAIN MAIN} или категория
{@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER}, значок
приложения не будет отображатья в списке приложений на главном экране.</p>


<h2 id="Create">Создание нового экземпляра</h2>

<p>Большинство приложений содержат различные операции, позволяющие пользователю выполнять различные действия.
Как для основных операций, создаваемых при нажатии на значок приложения, так
и для других операций, которыми приложение реагирует на действия пользователя, система создает
каждый новый экземпляр {@link android.app.Activity} посредством вызова его метода {@link
android.app.Activity#onCreate onCreate()}.</p>

<p>Вы должны реализовать метод {@link android.app.Activity#onCreate onCreate()} для выполнения базовой
логики запуска приложения, которое должно производиться только один раз для всего срока существования операции. Например,
ваша реализация {@link android.app.Activity#onCreate onCreate()} должна содержать определение пользовательского
интерфейса и возможно создавать экземпляры некоторых переменных уровня класса.</p>

<p>Например, в следующем примере метода {@link android.app.Activity#onCreate onCreate()}
показан код, выполняющий фундаментальную настройку операции, включая
декларирование пользовательского интерфейса (определен в файле макета XML), определение составных переменных
и частичную настройку пользовательского интерфейса.</p>

<pre>
TextView mTextView; // Member variable for text view in the layout

&#64;Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Set the user interface layout for this Activity
    // The layout file is defined in the project res/layout/main_activity.xml file
    setContentView(R.layout.main_activity);
    
    // Initialize member TextView so we can manipulate it later
    mTextView = (TextView) findViewById(R.id.text_message);
    
    // Make sure we're running on Honeycomb or higher to use ActionBar APIs
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        // For the main activity, make sure the app icon in the action bar
        // does not behave as a button
        ActionBar actionBar = getActionBar();
        actionBar.setHomeButtonEnabled(false);
    }
}
</pre>

<p class="caution"><strong>Внимание!</strong> Использование {@link android.os.Build.VERSION#SDK_INT} для
предотвращения запуска новых API-интерфейсов на старых системах поддерживается только в Android версии 2.0 (API-интерфейсы уровня
5) и более поздних версиях. В старых версиях возникнет ошибка времени исполнения.</p>

<p>После завершения выполнения {@link android.app.Activity#onCreate onCreate()} система
быстро вызывает методы {@link android.app.Activity#onStart()} и {@link android.app.Activity#onResume()} по
очереди. Операция никогда не остается в состоянии создания или запуска. Технически
операция становится видимой для пользователя при вызове {@link android.app.Activity#onStart()}, однако затем сразу же происходит 
{@link android.app.Activity#onResume()} и операция остается в состоянии возобновления,
пока что-то не произойдет, например пока не поступит телефонный звонок, пользователь не переключится
на другую операцию или экран устройства не выключится.</p>

<p>На последующих уроках вы увидите, как можно с пользой использовать другие методы запуска, {@link
android.app.Activity#onStart()} и {@link android.app.Activity#onResume()}, в жизненном цикле операции
при возобновлении работы после паузы или остановки.</p>

<p class="note"><strong>Примечание.</strong> Метод {@link android.app.Activity#onCreate onCreate()}
включает параметр <code>savedInstanceState</code>, о котором будет рассказано на
уроке <a href="recreating.html">Воссоздание операции</a>.</p>


<img src="{@docRoot}images/training/basics/basic-lifecycle-create.png" />
<p class="img-caption"><strong>Рисунок 2.</strong> Еще один пример структуры жизненного
цикла операции, где основное внимание трем главным обратным вызовам, которые система выполняет по очереди при создании
нового экземпляра операции: {@link android.app.Activity#onCreate onCreate()}, {@link
android.app.Activity#onStart()} и {@link android.app.Activity#onResume()}. После завершения этой серии
обратных вызовов операция переходит в состояние возобновления, где пользователи могут
взаимодействовать с операцией до тех пор, пока не переключатся на другую операцию.</p>


<h2 id="Destroy">Уничтожение операции</h2>

<p>Первым обратным вызовом жизненного цикла операции является {@link android.app.Activity#onCreate
onCreate()}, а последним – {@link android.app.Activity#onDestroy}. Система вызывает
этот метод для операции, подавая окончательный сигнал
о том, что экземпляр операции полностью удаляется из системной памяти.</p>

<p>Большинству приложений не требуется реализация этого метода, потому что ссылки локальных классов уничтожаются
вместе с операцией, а основные задачи по освобождению ресурсов операция выполняет в состояниях {@link
android.app.Activity#onPause} и {@link android.app.Activity#onStop}. Однако если ваша
операция содержит фоновые потоки, созданные во время выполнения {@link
android.app.Activity#onCreate onCreate()}, или в течение длительного времени использует другие ресурсы, могущие
вызывать утечку памяти при неправильном закрытии, их нужно уничтожить с помощью метода {@link
android.app.Activity#onDestroy}.</p>

<pre>
&#64;Override
public void onDestroy() {
    super.onDestroy();  // Always call the superclass
    
    // Stop method tracing that the activity started during onCreate()
    android.os.Debug.stopMethodTracing();
}
</pre>

<p class="note"><strong>Примечание.</strong> Система вызывает {@link android.app.Activity#onDestroy}
после вызова {@link android.app.Activity#onPause} и {@link
android.app.Activity#onStop} во всех случаях, кроме ситуации, когда вы вызываете {@link
android.app.Activity#finish()} из метода {@link android.app.Activity#onCreate onCreate()}
. В некоторых случаях, например когда ваша операция временно отвечает за принятие решения о запуске
другой операции, вы можете вызвать {@link android.app.Activity#finish()} из метода {@link
android.app.Activity#onCreate onCreate()} для уничтожения операции. В этом случае система
сразу же вызывает {@link android.app.Activity#onDestroy}, не вызывая другие методы жизненного
цикла.</p>