Программирование Android Класс Activity Sat, June 24 2017  

Поделиться

нашли опечатку?

Пожалуйста, сообщите об этом - просто выделите ошибочное слово или фразу и нажмите Shift Enter.


Класс Activity Печать
Добавил(а) microsin   

Класс Activity - пожалуй самый важный класс, из которого строится приложение Android. Этот класс представляет визуальную активность приложения, и определяет действия, которые может производить пользователь. В Java-приложении должен быть как минимум один класс, который был расширен (extends) от родительского класса Activity. Поэтому важно знать и уметь применять методы класса Activity. В этой статье приведен перевод документации Google [1].

Класс Activity произошел (extends) от класса ContextThemeWrapper, и реализовал (implements) методы ComponentCallbacks2, KeyEvent.Callback, LayoutInflater.Factory2, View.OnCreateContextMenuListener, Window.Callback.

Иерархия классов, от которой произошел класс Activity: java.lang.Object -> android.content.Context -> android.content.ContextWrapper -> android.view.ContextThemeWrapper -> android.app.Activity.

Известные прямые наследники Activity (Direct Subclasses): AccountAuthenticatorActivity, ActivityGroup, AliasActivity, ExpandableListActivity, FragmentActivity, ListActivity, NativeActivity.

Известные непрямые наследники Activity (Indirect Subclasses): ActionBarActivity, LauncherActivity, PreferenceActivity, TabActivity.

[Обзор класса Activity]

Activity переводится как действие. Это некая сущность, олицетворяющая все, что может делать пользователь. Почти все экземпляры и разновидности activitу напрямую взаимодействуют с пользователем, так что класс Activity отвечает за создание окна, в котором Вы можете разместить свой визуальный интерфейс GUI вызовом setContentView(View). В то время как activitу часто представлены пользователю как окна, развернутые во весь экран, activitу может быть также использована и по-другому: как плавающее окно (с темой, где установлено свойство windowIsFloating), или activitу может быть встроена в другое activity (с использованием ActivityGroup). Каждое приложение, которое создается на Java, создает как минимум один подкласс, расширенный от класса Activity:

package com.mypack;
import android.os.Bundle; import android.app.Activity; import android.view.Menu;
public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); }
@Override public boolean onCreateOptionsMenu(Menu menu) { // Встраивание меню; это действие добавляет элементы в action bar,
        //  если оно имеется.
getMenuInflater().inflate(R.menu.main, menu); return true; } }

При этом в подклассе, произведенном от Activity обычно будет реализовано 2 метода:

onCreate(Bundle) здесь Вы инициализируете activity. Самое главное здесь вызвать setContentView(int), где int идентификатор ресурса, определяющего интерфейс пользователя (GUI), и использовать вызовы findViewById(int) для получения доступа к виджетам (контролам), с которыми нужно работать программно.
onPause() здесь Вы обрабатываете ситуацию, когда пользователь оставил работу с этим activity. Самое главное здесь - зафиксировать (запомнить) любые изменения, сделанные пользователем (обычно данные содержит в себе ContentProvider).

Чтобы можно было использовать activity вместе с Context.startActivity(), все классы activity classes должны иметь соответствующие описания - декларацию < activity > в файле AndroidManifest.xml пакета приложения.

В этой статье будут рассмотрены следующие темы:

1. Фрагменты (Fragments).
2. Жизненный цикл activity.
3. Изменения конфигурации.
4. Запуск Activitу и получение результатов.
5. Сохранение определенного состояния (Persistent State).
6. Разрешения (Permissions).
7. Жизненный цикл процесса.

Класс Activity является важной частью приложения в любой момент жизни приложения, и метод запуска экземпляров activity и их комбинирования является фундаментальной основой модели приложения платформы Android. Чтобы подробно рассмотреть перспективу и структуру приложения и как при этом ведут себя активности, пожалуйста прочитайте руководства разработчика "Application Fundamentals" (основы приложения) и "Tasks and Back Stack" (задачи и обратный стек). Вы также можете найти детальное обсуждение вопросов создания активностей в документации по использованию Activity.

[Фрагменты]

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

[Жизненный цикл activity (Activity Lifecycle)]

Активности в системе обрабатываются как стек активностей. Когда запущена новая активность, она помещается наверх стека и становиться работающей активностью (running activity) - при этом предыдущая активность остаются всегда ниже в стеке, и не переходит в снова верхнее положение пока существует новая активность.

У активность по существу есть 4 состояния:

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

На следующей диаграмме показано, какие важные состояния проходит Activity и в каком порядке. Серые прямоугольники показывают методы обратного вызова (callback methods), которые Вы можете реализовать для выполнения операций, когда Activity переходит между состояниями. Цветные овалы представляют основные состояния Activity, в которых она может находиться.

Android-activity lifecycle

Есть три ключевых цикла, которые интересны в отслеживании состояния активности:

entire lifetime (полное время жизни) activity отсчитывается с момента первого вызова onCreate(Bundle) до последнего одиночного вызова onDestroy(). Активность делает все настройки своего "глобального" состояния в теле onCreate(), и освобождает все занятые ресурсы в теле onDestroy(). Например, если в фоне запущен поток, который загружает данные по сети, то этот поток может быть создан в теле onCreate() и остановлен в теле onDestroy().
visible lifetime (видимое время) activity отсчитывается между вызовом onStart() до соответствующего вызова onStop(). В течение этого времени пользователь может видеть работу активности на экране, хотя это может быть не на переднем плане и во взаимодействии с пользователем. Между этими двумя методами Вы можете удерживать ресурсы, которые нужны для отображения активности для пользователя. Например, Вы может зарегистрировать BroadcastReceiver в теле onStart() для отслеживания изменений, которые происходят в графическом интерфейсе пользователя, и дерегистрировать его в onStop(), когда пользователь больше не видит отображение активности. Методы onStart() и onStop() могут быть вызваны несколько раз, как только активность становиться видимой и невидимой для пользователя.
foreground lifetime (время верхнего состояния) происходит между вызовом onResume() до соответствующего вызова onPause(). В течение этого времени активность находится на верхнем уровне (поверх всех других активностей), и может взаимодействовать с пользователем. Активность может часто переходить между состоянием продолжения работы в состоянием паузы - например, когда устройство переходит в состояния сна, когда доставлен результат работы активности, кода поставлен новый intent is delivered - так что код в этих методах должен быть довольно простым и нересурсоемким.

Полный жизненный цикл активности определяется следующими методами класса Activity. Все эти хуки могут быть перезаданы (override), чтобы они делали нужную работу при изменении состояния активности. Все активности будут реализовывать onCreate(Bundle) для выполнения своей первоначальной настройки; часто также нужно реализовать onPause(), чтобы принять изменения данных или в другом случает подготовиться к остановке взаимодействия с пользователем. Вы должны всегда вызвать свой суперкласс (класс-родитель), когда реализуете эти методы.

public class Activity extends ApplicationContext
{
     protected void onCreate(Bundle savedInstanceState);
     protected void onStart();
     protected void onRestart();
     protected void onResume();
     protected void onPause();
     protected void onStop();
     protected void onDestroy();
}

Обычно перемещения жизненного цикла активности выглядят так:

МетодОписаниеKillable
(может быть
убито
системой)?
Следующее
состояние
onCreate() Будет вызвано, когда активность создается в первый раз. В этом месте Вам нужно сделать все начальные статические настройки: создание видов (view), привязать данные к спискам, и т. д. Этот метод также предоставляется Вам вместе с Bundle, содержащим предыдущее замороженное (сохраненное) состояние активности, если оно было. За этим методом обязательно последует вызов onStart(). Нет onStart()
onRestart() Вызывается после того, как Ваша активность была остановлена перед тем, как запустить её снова. За этим методом обязательно последует вызовonStart() Нет onStart()
onStart() Вызывается, когда активность становится видимой для пользователя. Сопровождается вызовом onResume(), если активность перешла на передний план (foreground), или onStop(), если становится скрытой. Нет onResume()
или
onStop()
onResume() Вызывается, когда активность начала взаимодействовать с пользователем. В этой точке Ваша активность находится на вершине стека активностей, и пользователь что-то вводит на ней. За этим методом всегда следует вызовonPause(). Нет onPause()
onPause() Вызывается, когда система намеревается возобновление работы предыдущей активности. Этот метод обычно используется для сохранения всех изменений в постоянные данные (persistent data), остановки анимаций и других вещей, которые требуют вычислительных ресурсов CPU, и т. д. Реализации этого метода должны отрабатывать очень быстро, потому что следующая активность не будет возобновлена, пока не произойдет выход из этого метода. За вызовом этого метода последует либо onResume(), если активность возвращается на передний план, или onStop(), если она становится невидимой для пользователя. До
HONEYCOMB
onResume()
или
onStop()
onStop() Вызывается, когда активность больше невидима для пользователя, потому что возобновила работу другая активность, и закрыла собой эту. Такое может случиться либо потому что запущена новая активность, либо потом что уже запущенная активность снова получает фокус, или когда эта активность уничтожается. За этим методом последует либо onRestart(), если активность возвращается к взаимодействию с пользователем, или onDestroy(), если активность умирает. Да onRestart()
или
onDestroy()
onDestroy() Завершающий вызов перед тем, как активность будет уничтожена. Это может произойти либо по причине завершения активности (в ней может быть вызван метод finish(), или потому что система временно уничтожает этот экземпляр активности, чтобы освободить память. Вы можете отличать эти два случая друг от друга с помощью метода isFinishing(). Да нет ничего

Обратите внимание на столбец Killable в этой таблице - для тех методов, которые помечены прибиваемыми, после того как этот метод завершился, то процесс, принадлежащий активности, может быть убит системой в любое время без какого-нибудь дополнительного выполнения кода. Поэтому Вы должны использовать метод onPause(), чтобы записать определенные данные (такие например, которые редактирует пользователь) в хранилище. Дополнительно метод onSaveInstanceState(Bundle) вызывается перед помещением активности в такое фоновое состояние, что позволяет Вам сохранить любое динамическое состояние Вашей активности в указанный Bundle, чтобы позднее принять в onCreate(Bundle), если активность должна быть создана заново. См. секцию "Жизненный цикл процесса" для получения дополнительной информации, как жизненный цикл процесса привязан к активности. Имейте в виду, что важно сохранять имеющиеся данные (persistent data) в onPause() вместо onSaveInstanceState(Bundle), потому что последний не является частью функций обратного вызова жизненного цикла, так что не будет вызван в каждой ситуации, как отписано в её документации.

Примечание: имейте в виду, что эти семантики незначительно изменяются между приложениями, которые предназначаются для платформ, начиная с HONEYCOMB, и более ранними платформами. Начиная с Honeycomb приложения не могут быть завершены пока не закончиться работа onStop(). Это влияет, когда может быть вызван onSaveInstanceState(Bundle) (он может быть безопасно вызван после onPause() и позволяет приложению безопасно ожидать, пока onStop() сохранит постоянное состояние (persistent state).

Для методов, которые не помечены как убиваемые, процесс активности не будет прибит системой от момента вызова метода до продолжения после возврата. Таким образом, активность не находится в том состоянии, когда её можно убить, например от момента после onPause() до старта onResume().

[Изменения конфигурации]

Если конфигурация устройства (как задано классом Resources.Configuration) изменилась, то все, что показывается в интерфейсе пользователя должно быть обновлено, чтобы соответствовать этой новой конфигурации. Поскольку Activity является главным механизмом для организации интерфейса с пользователем, в нем имеется специальная поддержка обработки ситуаций изменения конфигурации.

Если Вы не задали это иначе, изменение конфигурации (такие как изменение ориентации экрана, языка, устройств ввода и т. д.) приведут к уничтожению текущей активности с проходом всех процессов жизненного цикла активности onPause(), onStop() и onDestroy(), как и положено. Если активность была на верхнем уровне (в состоянии работы) или видима для пользователя, как только вызван onDestroy() в том экземпляре активности, то будет создан новый экземпляр активности, с любым savedInstanceState, ранее сгенерированным из onSaveInstanceState(Bundle).

Так происходит потому, что любой ресурс приложения, включая файлы разметки интерфейса (layout files), могут быть изменены на основании любого значения конфигурации. Таким образом, единственный безопасный способ обработать изменение конфигурации состоит в том, чтобы повторно получить все ресурсы, включая разметки (layouts), изображения (drawables) и строки (strings). Поскольку активности должны уже знать, как сохранить свое состояние и заново воссоздать себя из этого состояния, это удобный способ, чтобы активность перезапустила самого себя с новой конфигурацией.

В некоторых особых случаях Вы можете захотеть пропустить перезапуск активности на основании одного или нескольких типов изменения конфигурации. Это делается через атрибут android:configChanges в манифесте. Для любого типа изменения конфигурации Вы там указываете, что будете делать отдельную обработку, и вместо перезапуска активности будете получать вызов метода onConfigurationChanged(Configuration). Если изменение конфигурации вовлекает что-то, что Вы не обрабатываете, то все-таки активность будет перезапущена, и метод onConfigurationChanged(Configuration) не будет вызван.

[Запуск Activitу и получение результатов]

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

Иногда Вам понадобится получить результат от дочерней активности, когда она завершит работу. Например, Вы можете запустить активность, которая позволяет выбрать человека из списка контактов; когда эта активность завершится, она возвратит в родительскую активность выбранную персону. Чтобы сделать это, вызовите версию метода startActivityForResult(Intent, int), где второй параметр идентифицирует вызов. Результат будет получен через вызов метода onActivityResult(int, int, Intent).

Когда дочерняя активность завершается, она должна вызвать setResult(int), чтобы вернуть данные в код, который её вызвал (в код родителя). Всегда должен быть предоставлен код результата, который может быть стандартными результатами RESULT_CANCELED, RESULT_OK, или это могут быть любые пользовательские значения, начинающиеся с RESULT_FIRST_USER. Дополнительно обратно может быть возвращен Intent, содержащий добавочные данные, если это требуется. Вся эта информация возвращается обратно в родительский метод Activity.onActivityResult() вместе с первоначально предоставленным (при вызове активности) целочисленным идентификатором.

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

public class MyActivity extends Activity
{
    ...
static final int PICK_CONTACT_REQUEST = 0;
protected boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) { // Когда пользователь нажмет в центре, позволить ему выбрать контакт. startActivityForResult( new Intent(Intent.ACTION_PICK, new Uri("content://contacts")), PICK_CONTACT_REQUEST); return true; } return false; }
protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == PICK_CONTACT_REQUEST) { if (resultCode == RESULT_OK) { // Контакт выбран. Здесь он будет просто отображен // для пользователя. startActivity(new Intent(Intent.ACTION_VIEW, data)); } } } }

[Сохранение определенного состояния (Persistent State)]

Прим. переводчика: термин Persistent State решил не переводить как "определенное состояние" или "постоянное состояние" (потому что смысл теряется и звучит не по-русски), и оставить как есть; под этими словами подразумеваются некоторые рабочие данные, которые нужно сохранить.

Есть обычно два вида Persistent State, с которыми активность имеет дело: совместно используемые данные наподобие редактируемого документа (обычно сохраняются в базе данных SQLite с использованием провайдера контента content provider), и некое внутреннее состояние, такое как пользовательские настройки.

Для данных провайдера контента (content provider) рекомендуется использовать активностью модели пользователя "edit in place" (редактирование на месте). Это означает, что любое сделанное пользователем редактирование приводится в действие немедленно, без дополнительного шага подтверждения (прим. переводчика: непривычная с точки зрения пользователя PC модель, который привык к набившим оскомину кнопкам OK, Cancel, Apply). Поддержка этой модели изменения настроек (или документа) обычно проста, если следовать двум правилам:

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

Эта модель редактирования и сохранения данных разработана, чтобы предотвратить потерю данных, когда пользователь переходит от одной активности к другой, и позволяет системе безопасно убивать активность (потому что системные ресурсы не безграничны, и могут понадобиться для других целей) в любое время, как только активность приостановлена. Имейте в виду, что это подразумевает, что когда пользователь нажимает BACK (назад, выход) из Вашей активности, то это не означает "cancel" (отменить) - это означает покинуть активность с её текущим состоянием, которое должно быть сохранено. Отмена сделанных в активности изменений должна быть предоставлена неким другим механизмом, как например явный откат (revert) или опции отменить (undo).

См. content package для дополнительной информации про контент-провайдеров (content provider). Это ключевой аспект того, как активности вовлекаются в работу и обмениваются данными друг с другом и с самими собой.

Класс Activity также предоставляет API для управления внутренним persistent state, который связан с активностью. Это может использоваться, например, чтобы запомнить понравившийся стартовый экран в календаре (вид по дням или вид по неделям), или страничку по умолчанию в or the user's default home page in a web browser.

Persistent state активности управляется с помощью метода getPreferences(int), что позволяет Вам получить и модифицировать набор пар name/value, связанных с активностью. Чтобы использовать свойства (preferences), которые являются общими между несколькими компонентами приложения (activities, receivers, services, providers), Вы можете использовать нижележащий метод Context.getSharedPreferences(), чтобы получить свойства объекта, сохраненного по специфическому имени. Имейте в виду, что невозможно сделать общими данные настроек между пакетами приложения - для этого нужен контент-провайдер (content provider).

Имеется исключение для активности календаря (calendar activity), которая сохраняет выбранный пользователем вид в его persistent settings:

public class CalendarActivity extends Activity
{
    ...
    static final int DAY_VIEW_MODE = 0;
    static final int WEEK_VIEW_MODE = 1;
    private SharedPreferences mPrefs;
    private int mCurViewMode;
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        SharedPreferences mPrefs = getSharedPreferences();
        mCurViewMode = mPrefs.getInt("view_mode", DAY_VIEW_MODE);
    }
    protected void onPause()
    {
        super.onPause();
        SharedPreferences.Editor ed = mPrefs.edit();
        ed.putInt("view_mode", mCurViewMode);
        ed.commit();
    }
}

[Права на доступ (Permissions)]

Возможность запустить определенное Activity будет осуществлена, если в её файле манифеста декларирован тег < activity >. При этом другие приложения должны декларировать соответствующий элемент < uses-permission > в своем собственном манифесте, чтобы они могли запустить это activity.

Когда запускаете Activity, Вы можете установить Intent.FLAG_GRANT_READ_URI_PERMISSION и/или Intent.FLAG_GRANT_WRITE_URI_PERMISSION в объекте Intent. Это предоставит для Activity доступ к специфическим URI в Intent. Доступ будет оставаться активным, пока Activity не завершится (это остается, пока не будет убит хост-процесс, или другое временное разрушение). Начиная с версии GINGERBREAD, если Activity было уже создано и новый Intent передан в onNewIntent(Intent), любые недавно предоставленные URI permissions будут добавлены к уже существующим и предоставленным. Подробности см. в документе "Security and Permissions".

[Жизненный цикл процесса (Process Lifecycle)]

Система Android пытается сохранить процесс приложения рабочим настолько долго, как только это возможно, однако бывает нужно удалить старые процессы из памяти, когда кончается оперативная память. Как было описано в разделе "Жизненный цикл activity (Activity Lifecycle)" решение об удалении каждого конкретного процесса принимается на основании состояния взаимодействия пользователя с ним. В целом есть 4 состояния, в котором находится процесс, и эти состояния определяются на основе действий, работающих в нем. Ниже эти состояния перечислены в порядке уменьшения их важности. Система в первую очередь будет убивать наименее важные процессы (последние в списке), прежде чем удалить те, которые находятся в списке важности выше.

1. Foreground activity (активность, которая находится на переднем плане экрана, и с которой работает пользователь) считается наиболее важной. Этот процесс будет уничтожен только в последнюю очередь, если он будет больше памяти, чем доступно в устройстве Android. Если удаление все-таки произошло, то в этот момент устройство получило чрезмерно фрагментированную память, так что удаление процесса требуется, чтобы сохранить быструю работу интерфейса с пользователем.
2. Visible activity (активность, которая видима для пользователя, но она не находится в состоянии foreground, например окно находится внизу, под окошком foreground диалога) считается очень важной, и она не будет убита, пока это не потребуется для сохранения работоспособности foreground-активности.
3. Background activity (активность, которая не видна на экране для пользователя, и находится в состоянии паузы) больше не является критичной, так что система может её безопасно прибить, чтобы освободить память для других более важных процессов. Если процесс этой активности нужно убить, то когда пользователь возвращается обратно к этой активности (снова делает его видимым на экране), будет вызван его метод onCreate(Bundle) с savedInstanceState, ранее предоставленным в onSaveInstanceState(Bundle), так что активность может быть перезапущена в том же самом состоянии, в каком её оставил пользователь.
4. Empty process (пустой процесс), который не хостит активностей или другие компоненты приложения (такие как классы Service или BroadcastReceiver). Они будут убиты очень быстро, как только остается мало памяти. Поэтому любая фоновая работа, которую Вы выполняете за пределами активности, должна выполняться в контексте активности BroadcastReceiver или Service, чтобы обеспечить, что система знает о необходимости иметь в наличии Ваш процесс.

Иногда Activity может нуждаться в длительно запущенных операциях, которые существуют независимо от жизненного цикла активности как таковой. Например приложение камеры, которая выгружает картинку на web-сайт. Выгрузка может занять продолжительное время, и приложение должно предоставить пользователю возможность покинуть приложение, пока оно все еще работает. Чтобы выполнить это, Ваша Activity должно запустить Service, в которой как раз будет происходить выгрузка. Это позволяет системе правильно приоритизировать Ваш процесс (рассмотреть, какой процесс более важен среди невидимых приложений) в течение выгрузки, независимо от того, была ли оригинальная активность на паузе, остановлена или завершена.

[Общее описание констант, полей и методов]

Константы
int DEFAULT_KEYS_DIALER Используется с setDefaultKeyMode(int) для запуска набирателя номера (dialer) во время обработки клавиши по умолчанию.
int DEFAULT_KEYS_DISABLE Используется с setDefaultKeyMode(int) для выключения обработки клавиш по умолчанию.
int DEFAULT_KEYS_SEARCH_GLOBAL Используется с setDefaultKeyMode(int) чтобы указать, что необработанные нажатия запустят глобальный поиск (обычно это поиск в Интернете, но некоторые платформы могут задать альтернативные методы глобального поиска). Подробнее см. android.app.SearchManager.
int DEFAULT_KEYS_SEARCH_LOCAL Используется с setDefaultKeyMode(int) чтобы указать, что необработанные нажатия запустят поиск, заданный приложением.
int DEFAULT_KEYS_SHORTCUT Используется с setDefaultKeyMode(int) для запуска шортката меню при обработке клавиш по умолчанию.
int RESULT_CANCELED Стандартный результат, возвращаемый activity: operation canceled (действие отменено).
int RESULT_FIRST_USER Начальное значение диапазона возвращаемых значений activity, заданных пользователем.
int RESULT_OK Стандартный результат, возвращаемый activity: operation succeeded (успешное завершение).
Унаследованные константы (Inherited Constants)
Из класса android.content.Context
Из класса android.content.ComponentCallbacks2
Поля (Fields)
protected static final int[] FOCUSED_STATE_SET
Общедоступные конструкторы (Public Constructors)
Activity()
Общедоступные методы (Public Methods)
void addContentView(View view, ViewGroup.LayoutParams params)
Добавляет к активности дополнительный вид содержимого (content view.
void closeContextMenu()
Программно закрывает последнее открытое контекстное меню, если оно сейчас отображается.
void closeOptionsMenu()
Progammatically closes the options menu.
PendingIntent createPendingResult(int requestCode, Intent data, int flags)
Создает новый объект PendingIntent, который Вы можете передать другим из них, чтобы отправить данные результата обратно в Вашу функцию обратного вызова (callback) onActivityResult(int, int, Intent).
final void dismissDialog(int id)
Этот метод устарел (deprecated) в API level 13. Используйте вместо него новый класс DialogFragment с FragmentManager; это также доступно на старых платформах благодаря пакету совместимости (Android compatibility package).
boolean dispatchGenericMotionEvent(MotionEvent ev)
Вызывается для обработки стандартных событий жестов (generic motion events).
boolean dispatchKeyEvent(KeyEvent event)
Вызывается для обработки событий клавиш.
boolean dispatchKeyShortcutEvent(KeyEvent event)
Вызывается для обработки клавиши ярлыка (key shortcut event).
boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event)
Вызывается для обработки распространений AccessibilityEvent.
boolean dispatchTouchEvent(MotionEvent ev)
Вызывается для обработки событий касания к сенсорному экрану (touch screen events).
boolean dispatchTrackballEvent(MotionEvent ev)
Вызывается для обработки событий трекбола (trackball events).
void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args)
Print the Activity's state into the given stream.
View findViewById(int id)
Находит представление активности (View), идентифицируемый по атрибуту id из XML, который был обработан в onCreate(Bundle).
void finish()
Вызовите, когда Ваша активность завершила работу и должна быть закрыта.
void finishActivity(int requestCode)
Принуждает завершить другую активность, которую Вы раньше запустили вызовом startActivityForResult(Intent, int).
void finishActivityFromChild(Activity child, int requestCode)
Вызывается, когда дочерняя активность от этой вызвала свой метод finishActivity().
void finishAffinity()
Завершает эту активность, как и все активности, находящиеся ниже, которые имеют с ней родственную связь (same affinity).
void finishFromChild(Activity child)
Вызывается, когда дочерняя от этой активность вызвала свой метод finish().
ActionBar getActionBar()
Запрашивает ссылку к ActionBar этой активности.
final Application getApplication()
Возвращает приложение, которое является владельцем активности.
ComponentName getCallingActivity()
Возвращает имя активности, которая вызвала эту активность.
String getCallingPackage()
Возвращает имя пакета, который был вызван этой активностью.
int getChangingConfigurations()
Если эта активность была удалена, потому что не смогла обработать изменившийся параметр конфигурации (и таким образом метод активности onConfigurationChanged(Configuration) не был вызван), то Вы можете использовать этот метод, чтобы определить набор изменений, которые произошли при разрушении процесса.
ComponentName getComponentName()
Возвращает полное имя компонента (component name) этой активности.
View getCurrentFocus()
Вызывает getCurrentFocus() на окне этой Activity для возврата к текущему представлению (currently focused view).
FragmentManager getFragmentManager()
Возвращает FragmentManager для взаимодействия с фрагментами, связанными с этой activity.
Intent getIntent()
Возвращает intent, запущенный этой activity.
Object getLastNonConfigurationInstance()
Этот метод устарел в API level 13. Вместо него используйте новый Fragment API setRetainInstance(boolean); благодаря пакету совместимости это работает и на старых платформах Android.
LayoutInflater getLayoutInflater()
Удобная обертка для вызова getLayoutInflater().
LoaderManager getLoaderManager()
Возвращает LoaderManager для этого фрагмента, с созданием его при необходимости.
String getLocalClassName()
Возвращает имя класса для этой активности с удаленным префиксом пакета.
MenuInflater getMenuInflater()
Возвращает enuInflater для этого контекста.
final Activity getParent()
Возвращает родительскую activity, если представление (view) встроено как дочернее.
Intent getParentActivityIntent()
Получает Intent, который будет запустит явную целевую активность (explicit target activity), определенную логическим родителем этой активности.
SharedPreferences getPreferences(int mode)
Запрашивает объект SharedPreferences для доступа к свойствам (preferences), которые являются частными (private) для этой activity.
int getRequestedOrientation()
Возвращает текущую запрошенную ориентацию activity.
Object getSystemService(String name)
Возвращает handle к службе уровня системы, найденной по имени.
int getTaskId()
Возвращает идентификатор задачи (task), в которой находится эта activity.
final CharSequence getTitle()
final int getTitleColor()
final int getVolumeControlStream()
Получает предложенный аудиопоток, громкость которого должна быть изменена аппаратными регуляторами громкости.
Window getWindow()
Запрашивает текущее окно Window для activity.
WindowManager getWindowManager()
Запрашивает менеджер окна, чтобы отобразить специально сконфигурированные пользователем окна (custom windows).
boolean hasWindowFocus()
Возвратит true, если главное окно активности получило сейчас фокус.
void invalidateOptionsMenu()
Декларирует, что если меню опций было изменено, то должно быть создано заново.
boolean isChangingConfigurations()
Проверка чтобы определить принадлежит ли активность удаляемому процессу, чтобы нужно было создать активность заново с новой конфигурацией.
final boolean isChild()
Эта активность встроена в другую?
boolean isDestroyed()
Возвращает true, если для активности был сделан финальный вызов onDestroy(), так что этот экземпляр убит.
boolean isFinishing()
Проверка, чтобы определить, находится ли активность в процессе завершения либо потому что Вы вызвали на ней finish(), либо нечто запросило её завершение.
boolean isImmersive()
Бит, показывающий, что эта активность является иммерсивной (immersive) и не должна быть по возможности прервана оповещениями.
boolean isTaskRoot()
Возвращает true, если активность является главной (root) для задачи (tas)k.
final Cursor managedQuery(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)
Этот метод устарел в API level 11. Вместо него используйте CursorLoader.
boolean moveTaskToBack(boolean nonRoot)
Перемещение задачи, содержащей это действие, на дно стека активностей.
boolean navigateUpTo(Intent upIntent)
Перемещения от этой активности к активности, указанной через upIntent, с завершением в этой активности в процессе.
boolean navigateUpToFromChild(Activity child, Intent upIntent)
Этот метод вызывается, когда дочерняя активность от этой вызывает свой метод navigateUpTo(Intent).
void onActionModeFinished(ActionMode mode)
Уведомляет активность, что режим действия (action mode) завершился.
void onActionModeStarted(ActionMode mode)
Уведомляет активность, что начался режим действия (action mode).
void onAttachFragment(Fragment fragment)
Вызывается, когда Fragment был присоединен  к этой активности, сразу после вызова его метода Fragment.onAttach() и перед Fragment.onCreate().
void onAttachedToWindow()
Вызывается, когда главное окно, связанное с активностью, подсоединено к менеджеру окон.
void onBackPressed()
Вызывается, когда активность детектировала нажатие пользователем кнопки "Назад" (back key).
void onConfigurationChanged(Configuration newConfig)
Вызывается системой, когда устройство изменило конфигурацию, когда Ваша активность работает.
void onContentChanged()
Этот хук вызывается всякий раз, когда содержимое вида экрана изменяется (из-за обращения к Window.setContentView или Window.addContentView).
boolean onContextItemSelected(MenuItem item)
Этот хук вызывается всякий раз, когда выбран пункт в контекстном меню.
void onContextMenuClosed(Menu menu)
Этот хук вызывается всякий раз, когда закрывается контекстное меню (либо когда пользователь делает отмену в меню кнопкой back/menu, либо когда выбран элемент меню).
void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo)
Вызывается, когда отображается контекстное меню для view.
CharSequence onCreateDescription()
Генерирует новое описание для этой активности.
void onCreateNavigateUpTaskStack(TaskStackBuilder builder)
Определение синтетического стека задач, который будет сгенерирован при переходе от другой задачи.
boolean onCreateOptionsMenu(Menu menu)
Инициализирует содержимое стандартное меню опций Activity.
boolean onCreatePanelMenu(int featureId, Menu menu)
Реализация по умолчанию onCreatePanelMenu(int, Menu) для активностей.
View onCreatePanelView(int featureId)
Реализация по умолчанию onCreatePanelView(int) для активностей.
boolean onCreateThumbnail(Bitmap outBitmap, Canvas canvas)
Генерирует новую иконку (thumbnail) для этой активности.
View onCreateView(View parent, String name, Context context, AttributeSet attrs)
Стандартная реализация onCreateView(View, String, Context, AttributeSet), используется когда делается inflating с LayoutInflater, возвращаемый getSystemService(String).
View onCreateView(String name, Context context, AttributeSet attrs)
Стандартная реализация onCreateView(String, Context, AttributeSet), используется когда делается inflating с LayoutInflater, возвращаемый getSystemService(String).
void onDetachedFromWindow()
Вызывается, когда главное окно, связанное с activity, отсоединяется от менеджера окон.
boolean onGenericMotionEvent(MotionEvent event)
Вызывается, когда стандартное событие жестов (generic motion event) не было обработано любым из представлений внутри активности.
boolean onKeyDown(int keyCode, KeyEvent event)
Вызывается, когда была нажата клавиша и не это событие не было обработано любым из представлений внутри активности.
boolean onKeyLongPress(int keyCode, KeyEvent event)
Реализация по умолчанию KeyEvent.Callback.onKeyLongPress(): всегда возвращает false (обработка события не производится).
boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event)
Реализация по умолчанию KeyEvent.Callback.onKeyMultiple(): всегда возвращает false (обработка события не производится).
boolean onKeyShortcut(int keyCode, KeyEvent event)
Вызывается, когда клавишное событие ярлыка (key shortcut event) не обработано любым представлением в Activity.
boolean onKeyUp(int keyCode, KeyEvent event)
Вызывается, когда клавиша была отпущена, и это не было обработано любым предоставлением внутри активности.
void onLowMemory()
Вызывается, когда вся система работает в условиях недостатка памяти, и в этом случае активные работающие процессы должны урезать свое использование памяти.
boolean onMenuItemSelected(int featureId, MenuItem item)
Реализация по умолчанию onMenuItemSelected(int, MenuItem) для активностей.
boolean onMenuOpened(int featureId, Menu menu)
Вызывается, когда меню панели открыто пользователем.
boolean onNavigateUp()
Этот метод вызывается всегда, когда пользователь делает выбор переместиться вверх от action bar при навигации в активности Вашего приложения.
boolean onNavigateUpFromChild(Activity child)
Вызывается, когда дочерняя активность от этой делает попытку перемещения вверх.
boolean onOptionsItemSelected(MenuItem item)
Этот хук вызывается всегда, когда выбран пункт в Вашем меню опций.
void onOptionsMenuClosed(Menu menu)
Этот хук вызывается всегда, когда меню опций закрыто (либо при отмене пользователем, либо когда выбран пункт в меню).
void onPanelClosed(int featureId, Menu menu)
Реализация по умолчанию onPanelClosed(int, Menu) для активностей.
void onPrepareNavigateUpTaskStack(TaskStackBuilder builder)
Подготовка ситетического стека задач, который будет сгенерирован при переходе вверх из другой задачи.
boolean onPrepareOptionsMenu(Menu menu)
Подготовка отображения стандартного меню опций экрана.
boolean onPreparePanel(int featureId, View view, Menu menu)
Реализация по умолчанию onPreparePanel(int, View, Menu) для активностей.
void onProvideAssistData(Bundle data)
Вызывается, когда пользователь запрашивает помощь (assist), чтобы построить полный ACTION_ASSIST Intent со всем контекстом текущего приложения.
Object onRetainNonConfigurationInstance()
Этот метод устарел в API level 13. Используйте вместо него новый Fragment API setRetainInstance(boolean); он также будет доступен и на старых версиях платформ благодаря пакету совместимости Android.
boolean onSearchRequested()
Этот хук вызывается, когда пользователь сигнализирует о желании запустить поиск.
boolean onTouchEvent(MotionEvent event)
Вызывается, когда событие сенсорного экрана не было обработано любым представлением на нем.
boolean onTrackballEvent(MotionEvent event)
Вызывается, когда трекбол был перемещен и это не было обработано любчм представлением внутри активности.
void onTrimMemory(int level)
Вызывается, когда операционная система определила, что сейчас хороший момент для урезания ненужной памяти в этом процессе.
void onUserInteraction()
Вызывается всякий раз, когда события клавиш, тачскрина, трекбола диспетчеризированы (переданы) в активность.
void onWindowAttributesChanged(WindowManager.LayoutParams params)
Вызывается всякий раз, когда изменены атрибуты текущего окна.
void onWindowFocusChanged(boolean hasFocus)
Вызывается, когда текущее окно Window активности получает или теряет фокус.
ActionMode onWindowStartingActionMode(ActionMode.Callback callback)
Дает для Activity шанс управлять UI (User Interface, интерфейс пользователя) для action mode, запрошенного системой.
void openContextMenu(View view)
Программно открывает контекстное меню для частного представления view.
void openOptionsMenu()
Программно открывает меню опций.
void overridePendingTransition(int enterAnim, int exitAnim)
Вызывается немедленно после одной из разновидностей startActivity(Intent) или finish(), чтобы указать явную анимацию перехода для выполнения next.
void recreate()
Приводит к пересозданию Activity в новом экземпляре (new instance).
void registerForContextMenu(View view)
Регистрирует контекстное меню для отображения в указанном представлении view (несколько предоставлений могут показать контекстное меню).
final void removeDialog(int id)
Этот метод устарел в API level 13. Используйте вместо него новый класс DialogFragment с FragmentManager; это будет работать и на старых платформах благодаря пакету совместимости Android.
void reportFullyDrawn()
Сообщает системе, что Ваше приложение сейчас полностью нарисовано, просто в диагностических целях (вызов никак не повлияет на видимое поведение активности).
final boolean requestWindowFeature(int featureId)
Разрешает расширенные фичи окна.
final void runOnUiThread(Runnable action)
Запускает указанное action в потоке UI (поток интерфейса пользователя).
void setContentView(int layoutResID)
Устанавливает содержимое activity из ресурса layout.
void setContentView(View view)
Устанавливает содержимое активности из явного представления.
void setContentView(View view, ViewGroup.LayoutParams params)
Устанавливает содержимое активности в явное представление (view).
final void setDefaultKeyMode(int mode)
Выбор обработки клавиш по умолчанию для этой активности.
final void setFeatureDrawable(int featureId, Drawable drawable)
Удобная обертка для вызова setFeatureDrawable(int, Drawable).
final void setFeatureDrawableAlpha(int featureId, int alpha)
Удобная обертка для вызова setFeatureDrawableAlpha(int, int).
final void setFeatureDrawableResource(int featureId, int resId)
Удобная обертка для вызова setFeatureDrawableResource(int, int).
final void setFeatureDrawableUri(int featureId, Uri uri)
Удобная обертка для вызова setFeatureDrawableUri(int, Uri).
void setFinishOnTouchOutside(boolean finish)
Устанавливает, что эта активность будет завершена при касании вне пределов её окна.
void setImmersive(boolean i)
Настраивает установки текущего режима иммерсии.
void setIntent(Intent newIntent)
Изменяет intent, возвращенный getIntent().
final void setProgress(int progress)
Устанавливает прогресс для индикаторов процесса выполнения (progress bars) в заголовке.
final void setProgressBarIndeterminate(boolean indeterminate)
Sets whether the horizontal progress bar in the title should be indeterminate (the circular is always indeterminate).
final void setProgressBarIndeterminateVisibility(boolean visible)
Устанавливает видимость неопределенного progress bar в заголовке.
final void setProgressBarVisibility(boolean visible)
Sets the visibility of the progress bar in the title.
void setRequestedOrientation(int requestedOrientation)
Изменяет ориентацию экрана этой активности на нужную.
final void setResult(int resultCode)
Вызовите это, чтобы установить результат, который Ваша активность вернет в вызвавший её код.
final void setResult(int resultCode, Intent data)
Вызовите это, чтобы установить результат, который Ваша активность вернет в вызвавший её код.
final void setSecondaryProgress(int secondaryProgress)
Sets the secondary progress for the progress bar in the title.
void setTitle(int titleId)
Изменяет заголовок, связанный с этой активностью.
void setTitle(CharSequence title)
Изменяет заголовок, связанный с этой активностью.
void setTitleColor(int textColor)
void setVisible(boolean visible)
Управляет состоянием видимости главного окна этой активности.
final void setVolumeControlStream(int streamType)
Предлагает аудиопоток, громкость которого должна быть изменена аппаратными регуляторами громкости.
boolean shouldUpRecreateTask(Intent targetIntent)
Возвращает true, если приложение должно пересоздать задачу, когда происходит навигация 'вверх' от этой активности с использованием targetIntent.
final boolean showDialog(int id, Bundle args)
Этот метод устарел в API level 13. Use the new DialogFragment class with FragmentManager instead; это также будет работать и на старых платформах благодаря пакету совместимости Android.
final void showDialog(int id)
Этот метод устарел в API level 13. Используйте вместо него новый класс DialogFragment с FragmentManager; это также будет работать и на старых платформах благодаря пакету совместимости Android.
ActionMode startActionMode(ActionMode.Callback callback)
Начинает режим действия (action mode).
void startActivities(Intent[] intents, Bundle options)
Запускает новую activity.
void startActivities(Intent[] intents)
То же, что и startActivities(Intent[], Bundle), но без указания опций.
void startActivity(Intent intent)
То же самое, что и startActivity(Intent, Bundle), но без указания опций.
void startActivity(Intent intent, Bundle options)
Запускает новую activity.
void startActivityForResult(Intent intent, int requestCode)
То же самое, что и вызов startActivityForResult(Intent, int, Bundle), но без опций.
void startActivityForResult(Intent intent, int requestCode, Bundle options)
Запускает активность, для которой нужен результат при её завершении.
void startActivityFromChild(Activity child, Intent intent, int requestCode, Bundle options)
Этот метод вызывается, когда дочерняя активность от этой вызывает свой метод startActivity(Intent) или startActivityForResult(Intent, int).
void startActivityFromChild(Activity child, Intent intent, int requestCode)
То же самое, что и вызов startActivityFromChild(Activity, Intent, int, Bundle), но без опций.
void startActivityFromFragment(Fragment fragment, Intent intent, int requestCode, Bundle options)
Этот метод вызывается, когда Fragment в этой активности вызывает свой метод startActivity(Intent) или startActivityForResult(Intent, int).
void startActivityFromFragment(Fragment fragment, Intent intent, int requestCode)
То же самое, что и вызов startActivityFromFragment(Fragment, Intent, int, Bundle), но без опций.
boolean startActivityIfNeeded(Intent intent, int requestCode, Bundle options)
Специальная разновидность запуска активности, только если новый экземпляр активности нуждается в обработке указанного Intent.
boolean startActivityIfNeeded(Intent intent, int requestCode)
То же самое, что и вызов startActivityIfNeeded(Intent, int, Bundle), но без опций.
void startIntentSender(IntentSender intent, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options)
Наподобие startActivity(Intent, Bundle), но для запуска получает IntentSender; для дополнительной информации см. startIntentSenderForResult(IntentSender, int, Intent, int, int, int, Bundle).
void startIntentSender(IntentSender intent, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags)
То же самое, что и вызов startIntentSender(IntentSender, Intent, int, int, int, Bundle), но без опций.
void startIntentSenderForResult(IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options)
Наподобие startActivityForResult(Intent, int), но позволяет Вам использовать IntentSender для описания запускаемой активности.
void startIntentSenderForResult(IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags)
То же самое, что и вызов startIntentSenderForResult(IntentSender, int, Intent, int, int, int, Bundle), но без опций.
void startIntentSenderFromChild(Activity child, IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags)
То же самое, что и вызов startIntentSenderFromChild(Activity, IntentSender, int, Intent, int, int, int, Bundle), но без опций.
void startIntentSenderFromChild(Activity child, IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options)
Наподобие startActivityFromChild(Activity, Intent, int), но принимает IntentSender; для дополнительной информации см. startIntentSenderForResult(IntentSender, int, Intent, int, int, int).
void startManagingCursor(Cursor c)
Этот метод устарел в API level 11. Используйте вместо него новый класс CursorLoader с LoaderManager; это также будет работать и на старых платформах благодаря пакету совместимости Android.
boolean startNextMatchingActivity(Intent intent)
То же самое, что и вызов startNextMatchingActivity(Intent, Bundle), но без опций.
boolean startNextMatchingActivity(Intent intent, Bundle options)
Специальная версия запуска активности, для использования когда Вы заменяете другие компоненты активности.
void startSearch(String initialQuery, boolean selectInitialQuery, Bundle appSearchData, boolean globalSearch)
Этот хук вызывается для запуска интерфейса поиска (search UI).
void stopManagingCursor(Cursor c)
Этот метод устарел в API level 11. Use the new CursorLoader class with LoaderManager; это также будет работать и на старых платформах благодаря пакету совместимости Android.
void takeKeyEvents(boolean get)
Запрос генерации события клавиши для этой активности.
void triggerSearch(String query, Bundle appSearchData)
То же самое, что и startSearch(String, boolean, Bundle, boolean), но фактически исчерпывает поисковый запрос после вызова диалога поиска.
void unregisterForContextMenu(View view)
Предотвращает от показа контекстного меню для указанного представления view.
Защищенные методы, доступные только в методах класса (Protected Methods)
void onActivityResult(int requestCode, int resultCode, Intent data)
Вызывается, когда запущенная Вами активность завершает работу, давая Вам requestCode, с которым Вы её запустили, и получая возвращенный ей resultCode и любые дополнительные данные.
void onApplyThemeResource(Resources.Theme theme, int resid, boolean first)
Вызывается из setTheme(int) и getTheme() для применения ресурса темы текущему объекту темы (Theme object).
void onChildTitleChanged(Activity childActivity, CharSequence title)
void onCreate(Bundle savedInstanceState)
Вызывается, когда запускается активность.
Dialog onCreateDialog(int id)
Этот метод устарел в API level 8. Старая версия без аргументов метода onCreateDialog(int, Bundle).
Dialog onCreateDialog(int id, Bundle args)
Этот метод устарел в API level 13. Вместо него используйте новый класс DialogFragment вместе с FragmentManager; это также работает на старых платформах благодаря пакету совместимости Android.
void onDestroy()
Выполняет любую завершающую очистку перед тем, как активность будет уничтожена.
void onNewIntent(Intent intent)
Этот метод вызывается для активностей, которые установили launchMode в значение "singleTop" ("один сверху") в своем пакете, или если клиент использует флаг FLAG_ACTIVITY_SINGLE_TOP при вызове startActivity(Intent).
void onPause()
Вызывается как часть жизненного цикла активности, когда активность уходит на задний план, но еще (пока) не уничтожена.
void onPostCreate(Bundle savedInstanceState)
Вызывается, когда процедура запуска активности завершена (после onStart() и вызова onRestoreInstanceState(Bundle)).
void onPostResume()
Вызывается, когда выполнено возобновление работы активности (после вызова onResume()).
void onPrepareDialog(int id, Dialog dialog)
Этот метод устарел в API level 8. Старая версия без аргументов метода onPrepareDialog(int, Dialog, Bundle).
void onPrepareDialog(int id, Dialog dialog, Bundle args)
Этот метод устарел в API level 13. Вместо него используйте новый класс DialogFragment вместе с FragmentManager; это будет работать и на старых платформах благодаря пакету совместимости Android.
void onRestart()
Вызывается после onStop(), когда текущая активность заново отображена для пользователя (пользователь снова перешел к ней).
void onRestoreInstanceState(Bundle savedInstanceState)
Этот метод вызывается после onStart(), когда активность была переинициализирована из предыдущего сохраненного состояния, указанного здесь в savedInstanceState.
void onResume()
Вызывается для Вашей активности после onRestoreInstanceState(Bundle)onRestart(), или onPause(), для начала интерактивной работы с пользователем.
void onSaveInstanceState(Bundle outState)
Вызывается, чтобы получить состояние экземпляра от активности, перед тем как она будет убита, так чтобы это состояние могло быть восстановлено впоследствии в onCreate(Bundle) или onRestoreInstanceState(Bundle) (Bundle, заполненный этим методом, будет передан обоим).
void onStart()
Вызывается после onCreate(Bundle) или после onRestart(), когда активность была остановлена, но теперь снова отображена для пользователя.
void onStop()
Вызывается, когда активность больше не видна для пользователя.
void onTitleChanged(CharSequence title, int color)
void onUserLeaveHint()
Вызывается как часть жизненного цикла активности, когда активность собирается уйти в фоновое состояние (background) в результате выбора пользователя.
Унаследованные методы (Inherited Methods)
От класса android.view.ContextThemeWrapper 
От класса android.content.ContextWrapper 
От класса android.content.Context 
От класса java.lang.Object 
От интерфейса android.content.ComponentCallbacks 
От интерфейса android.content.ComponentCallbacks2 
От интерфейса android.view.KeyEvent.Callback 
От интерфейса android.view.LayoutInflater.Factory 
От интерфейса android.view.LayoutInflater.Factory2 
От интерфейса android.view.View.OnCreateContextMenuListener 
От интерфейса android.view.Window.Callback

Подробное описание констант, методов класса Activity см. в [1].

[Ссылки]

1. Activity site:developer.android.com.

 

Добавить комментарий


Защитный код
Обновить

Top of Page