Что такое "контекст" на Android?
В программировании Android, что именно Context класс и для чего он используется?
Я читал об этом на сайте разработчика, но не могу понять это ясно.
37 ответов
Проще говоря:
Как следует из названия, это контекст текущего состояния приложения / объекта. Это позволяет вновь созданным объектам понять, что происходит. Как правило, вы звоните, чтобы получить информацию о другой части вашей программы (деятельность и пакет / приложение).
Вы можете получить контекст, вызвав getApplicationContext(), getContext(), getBaseContext() или же this (когда в классе, который простирается от Contextтакие как классы Application, Activity, Service и IntentService).
Типичное использование контекста:
Создание новых объектов: создание новых видов, адаптеров, слушателей:
TextView tv = new TextView(getContext()); ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);Доступ к стандартным общим ресурсам: такие службы, как LAYOUT_INFLATER_SERVICE, SharedPreferences:
context.getSystemService(LAYOUT_INFLATER_SERVICE) getApplicationContext().getSharedPreferences(*name*, *mode*);Неявный доступ к компонентам: относительно поставщиков контента, трансляций, намерений
getApplicationContext().getContentResolver().query(uri, ...);
Определение контекста
- Контекст представляет данные среды
- Предоставляет доступ к таким вещам, как базы данных
Более простые термины (пример 1)
Представьте себе, что Person-X является генеральным директором начинающей софтверной компании.
В компании присутствует ведущий архитектор, этот ведущий архитектор выполняет всю работу в компании, такую как базы данных, пользовательский интерфейс и т. Д.
Теперь генеральный директор нанимает нового разработчика.
Именно архитектор сообщает об ответственности вновь нанятого человека, основываясь на навыках нового человека, независимо от того, будет ли он работать над базой данных, пользовательским интерфейсом и т. Д.
Более простые термины (пример 2)
Это похоже на доступ активности Android к ресурсу приложения.
Это похоже на то, когда вы посещаете отель, вы хотите завтракать, обедать и ужинать в подходящее время, верно?
Есть много других вещей, которые вам нравятся во время пребывания. Как вы получаете эти вещи?
Вы просите служащего по обслуживанию номеров принести эти вещи для вас.
Здесь обслуживающий персонал - это контекст, считающий, что вы - единственное занятие, а отель - ваше приложение, и, наконец, завтрак, обед и ужин должны быть ресурсами.
Вещи, которые включают контекст:
- Загрузка ресурса.
- Запуск новой активности.
- Создание просмотров.
- получение системного сервиса.
Контекст - это базовый класс для Activity, Service, Application и т. Д.
Еще один способ описать это: Рассматривать контекст как удаленный от телевидения, а каналы в телевизоре - это ресурсы, услуги, использование намерений и т. Д. - - - Здесь удаленный доступ действует как доступ для получения доступа ко всем различным ресурсам на переднем плане.
Таким образом, Remote имеет доступ к таким каналам, как ресурсы, услуги, использование намерений и т. Д.
Аналогично... Тот, кто имеет доступ к удаленному, естественно, имеет доступ ко всем вещам, таким как ресурсы, услуги, использование намерений и т. Д.
Различные методы, с помощью которых вы можете получить контекст
getApplicationContext()getContext()getBaseContext()- или же
this(когда в классе деятельности)
Пример:
TextView TV=new TextView(this);
this -> относится к контексту текущей деятельности.
Тема "Контекст в Android" многих сбивает с толку. Люди просто знают, что Context необходим довольно часто, чтобы делать основные вещи в Android. Люди иногда впадают в панику, потому что они пытаются выполнить какую-то операцию, которая требует контекста, и они не знают, как "получить" правильный контекст. Я собираюсь попытаться демистифицировать идею контекста в Android. Полное рассмотрение проблемы выходит за рамки этого поста, но я постараюсь дать общий обзор, чтобы у вас было представление о том, что такое контекст и как его использовать. Чтобы понять, что такое контекст, давайте взглянем на исходный код:
Что именно является контекстом?
Ну, сама документация дает довольно простое объяснение: класс Context - это "Интерфейс для глобальной информации о среде приложения".
Сам класс Context объявлен как абстрактный класс, реализация которого обеспечивается ОС Android. В документации также указывается, что Контекст "… разрешает доступ к ресурсам и классам, относящимся к конкретному приложению, а также к дополнительным вызовам для операций на уровне приложений, таких как запуск, широковещание и получение и т. Д.".
Теперь вы можете очень хорошо понять, почему имя называется Context. Это потому, что это просто так. Контекст предоставляет ссылку или ловушку, если хотите, для Действия, Сервиса или любого другого компонента, тем самым связывая его с системой, обеспечивая доступ к глобальной среде приложения. Другими словами: контекст дает ответ на вопрос о компонентах "где, черт возьми, я по отношению к приложению в целом и как я могу получить доступ к общему приложению и общаться с ним?". Если все это немного сбивает с толку, быстро Посмотрите на методы, предоставляемые классом Context, вы получите некоторые дополнительные сведения о его истинной природе.
Вот случайная выборка этих методов:
getAssets()getResources()getPackageManager()getString()getSharedPrefsFile()
Что общего у всех этих методов? Все они позволяют любому, кто имеет доступ к контексту, иметь доступ к ресурсам всего приложения.
Иными словами, контекст подключает компонент, имеющий ссылку на него, к остальной части среды приложения. Например, ресурсы (например, папка "/ assets" в вашем проекте) доступны по всему приложению при условии, что Activity, Сервис или кто-либо еще знает, как получить доступ к этим ресурсам. То же самое касается getResources() который позволяет делать такие вещи, как getResources().getColor() который зацепит вас в colors.xml ресурс (не говоря уже о том, что aapt обеспечивает доступ к ресурсам через код Java, это отдельная проблема).
Результатом является то, что Context это то, что обеспечивает доступ к системным ресурсам, и то, что подключает компоненты к "большему приложению". Давайте посмотрим на подклассы Context, классы, обеспечивающие реализацию абстрактного Context учебный класс. Наиболее очевидным классом является Activity учебный класс. Activity наследуется от ContextThemeWrapper, который наследует от ContextWrapper, который наследует от Context сам. Эти классы полезны, чтобы понять вещи на более глубоком уровне, но пока достаточно знать, что ContextThemeWrapper а также ContextWrapper в значительной степени, как они звучат. Они реализуют абстрактные элементы Context классифицируйте себя, "оборачивая" контекст (действительный контекст) и делегируя эти функции этому контексту. Пример полезен - в ContextWrapper класс, абстрактный метод getAssets от Context Класс реализован следующим образом:
@Override
public AssetManager getAssets() {
return mBase.getAssets();
}
mBase это просто поле, установленное конструктором для определенного контекста. Таким образом, контекст обернут и ContextWrapper делегирует свою реализацию метода getAssets этому контексту. Давайте вернемся к рассмотрению Activity класс, который в конечном итоге наследует от Context чтобы увидеть, как все это работает.
Вы, наверное, знаете, что такое "Активность", но для проверки - это "единственная вещь, которую может сделать пользователь. Он заботится о предоставлении окна для размещения пользовательского интерфейса, с которым взаимодействует пользователь ". Разработчики, знакомые с другими API и даже не разработчики, могли бы воспринимать его как "экран". Это технически неточно, но для наших целей это не имеет значения. Так как же Activity а также Context взаимодействовать и что именно происходит в их наследственных отношениях?
Опять же, полезно взглянуть на конкретные примеры. Мы все знаем, как начать деятельность. Если у вас есть "контекст", из которого вы начинаете действие, вы просто звоните startActivity(intent)где Intent описывает контекст, из которого вы запускаете Activity, и Activity, которую вы хотите начать. Это знакомый startActivity(this, SomeOtherActivity.class),
И что this? this ваша деятельность, потому что Activity класс наследует от Context, Полный совок выглядит так: Когда вы звоните startActivityв конечном итоге Activity класс выполняет что-то вроде этого:
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);
Таким образом, он использует execStartActivity от Instrumentation класс (на самом деле из внутреннего класса в Instrumentation называется ActivityResult).
В этот момент мы начинаем изучать внутреннюю систему.
Это где ОС на самом деле обрабатывает все. Так как же Инструментарий точно запускает Активность? Ну, парам this в execStartActivity Метод выше - это ваша активность, то есть контекст, а execStartActivity использует этот контекст.
Обзор 30000 заключается в следующем: класс Instrumentation отслеживает список операций, которые он отслеживает, чтобы выполнить свою работу. Этот список используется для координации всех действий и обеспечения бесперебойной работы потока операций.
Есть некоторые операции, которые я не полностью изучил, для координации потоков и проблем процесса. В конечном итоге, ActivityResult использует нативную операцию - ActivityManagerNative.getDefault().startActivity() который использует Context что вы прошли, когда вы позвонили startActivity, Контекст, который вы передали, используется для помощи в "намеренном разрешении", если это необходимо. Умышленное разрешение - это процесс, с помощью которого система может определить цель намерения, если оно не предоставлено. (Проверьте руководство здесь для более подробной информации).
И для того, чтобы Android это сделал, ему нужен доступ к информации, предоставленной Context, В частности, система должна иметь доступ к ContentResolver так что он может "определить MIME-тип данных намерения". Весь этот бит о том, как startActivity использование контекста было немного сложным, и я не до конца понимаю внутренности. Моя основная цель состояла в том, чтобы просто показать, как нужно обращаться к ресурсам всего приложения, чтобы выполнять многие операции, которые важны для приложения. Context это то, что обеспечивает доступ к этим ресурсам. Более простой пример может быть Views. Мы все знаем, что вы создаете пользовательский вид, расширяя RelativeLayout или какой-то другой View класс, вы должны предоставить конструктор, который принимает Context в качестве аргумента. Когда вы создаете экземпляр своего пользовательского представления, вы переходите в контекст. Зачем? Потому что представление должно иметь доступ к темам, ресурсам и другим деталям конфигурации представления. Просмотр конфигурации на самом деле отличный пример. Каждый контекст имеет различные параметры (поля в Contextреализации), которые устанавливаются самой ОС для таких вещей, как размер или плотность дисплея. Легко понять, почему эта информация важна для настройки представлений и т. Д.
Последнее слово: по какой-то причине люди, плохо знакомые с Android (и даже не новички), похоже, полностью забывают об объектно-ориентированном программировании, когда речь заходит об Android. По какой-то причине люди пытаются склонить свои разработки под Android к заранее продуманным парадигмам или изученному поведению.
У Android есть своя собственная парадигма и определенная схема, которая на самом деле вполне последовательна, если отпустить ваши заранее продуманные представления и просто прочитать документацию и руководство разработчика. Моя реальная точка зрения, однако, хотя "получение правильного контекста" может иногда быть хитрым, люди неоправданно паникуют, потому что сталкиваются с ситуацией, когда им нужен контекст, и думают, что его нет. Еще раз, Java является объектно-ориентированным языком с дизайном наследования.
Вы только "имеете" контекст внутри своей Деятельности, потому что ваша деятельность сама наследуется от Контекста. В этом нет ничего волшебного (кроме всего того, что сама ОС делает для установки различных параметров и для правильной "настройки" вашего контекста). Таким образом, оставляя в стороне проблемы с памятью / производительностью (например, удерживая ссылки на контекст, когда вам это не нужно, или делая это таким образом, что это имеет негативные последствия для памяти и т. Д.), Context - это объект, подобный любому другому, и его можно передавать как и любой POJO (обычный старый объект Java). Иногда вам может потребоваться сделать что-то умное для извлечения этого контекста, но любой обычный Java-класс, который расширяется из ничего, кроме самого Object, может быть написан так, чтобы иметь доступ к контексту; просто предоставьте открытый метод, который принимает контекст, а затем используйте его в этом классе по мере необходимости. Это не было задумано как исчерпывающий подход к Context или внутренним компонентам Android, но я надеюсь, что это поможет немного демистифицировать Context.
Контекст - это дескриптор системы; он предоставляет такие услуги, как разрешение ресурсов, получение доступа к базам данных и настройкам и т. д. В приложении для Android есть действия. Контекст подобен дескриптору среды, в которой ваше приложение в данный момент выполняется. Объект действия наследует объект контекста.
Для получения дополнительной информации см. Введение в разработку Android с Android Studio - Учебное пособие.
Context является "интерфейсом" к глобальной информации о среде приложения. На практике, Context на самом деле абстрактный класс, реализация которого обеспечивается системой Android.
Он позволяет получить доступ к ресурсам и классам, относящимся к конкретному приложению, а также к дополнительным вызовам для операций на уровне приложения, таких как запуск, широковещание и получение и т. Д.
На следующем рисунке вы можете увидеть иерархию классов, где Context является корневым классом этой иерархии. В частности, стоит подчеркнуть, что Activity является потомком Context,
какой Context именно так?
Согласно справочной документации Android, это объект, который представляет различные данные среды. Он обеспечивает доступ к локальным файлам, базам данных, загрузчикам классов, связанным со средой, службам (включая службы системного уровня) и многим другим. В этой книге и в вашем повседневном кодировании с Android вы будете часто видеть контекст.
Из книги " Android на практике ", стр. 60.
Несколько API Android требуют Context как параметр
Если вы посмотрите на различные Android API, вы заметите, что многие из них занимают android.content.Context объект как параметр. Вы также увидите, что Деятельность или Сервис обычно используются как Context, Это работает, потому что оба эти класса простираются от Context,
Простой пример для понимания context в андроиде:
У каждого босса есть помощник, за которым нужно ухаживать, выполнять все менее важные и трудоемкие задачи. Если требуется файл или чашка кофе, помощник в бегах. Некоторые начальники почти не знают, что происходит в офисе, поэтому они спрашивают своих помощников об этом тоже. Они выполняют некоторую работу сами, но в большинстве других случаев им нужна помощь их помощников.
В этом сценарии
Босс - это приложение для Android
Помощник - это контекст
Файлы / Чашка кофе - это ресурсы
Обычно мы называем контекст, когда нам нужно получить информацию о различных частях нашего приложения, таких как "Действия", "Приложения" и т. Д.
Некоторые операции (вещи, где требуется помощник), где задействован контекст:
Загрузка общих ресурсов Создание динамических представлений Отображение сообщений Toast Запуск операций и т. Д. Различные способы получения контекста:
getContext()
getBaseContext()
getApplicationContext()
this
Контекст Android - это интерфейс (в общем смысле, а не в смысле Java; в Java Context на самом деле является абстрактным классом!), который обеспечивает доступ к конкретным ресурсам приложения, а также к классу и информации о среде приложения.
Если бы ваше приложение для Android было веб-приложением, ваш контекст был бы похож на ServletContext (Я не делаю точное сравнение здесь).
Ваша деятельность и услуги также расширяются Contextпоэтому они наследуют все эти методы для доступа к информации о среде, в которой работает приложение.
Contextпредставляет дескриптор для получения данных среды.ContextСам класс объявлен как абстрактный, реализация которого обеспечивается ОС Android.Contextэто как пульт от телевизора, а каналы в телевизоре - это ресурсы, услуги и т. д.
Что ты можешь сделать с этим?
- Загрузка ресурса.
- Запуск новой активности.
- Создание просмотров.
- Получение системного сервиса.
Способы получения контекста:
getApplicationContext()getContext()getBaseContext()
Просто выкладываю это для новичков;
Итак, сначала поймите Слово Контекст:
На английском-lib. это значит:
"Обстоятельства, которые формируют обстановку для события, утверждения или идеи, и с точки зрения которых они могут быть полностью поняты и оценены".
"Части чего-либо написанного или сказанного, которые непосредственно предшествуют и следуют за словом или отрывком и проясняют его значение".
Теперь отнеситесь к миру программирования с тем же пониманием:
контекст текущего состояния приложения / объекта. Это позволяет вновь созданным объектам понять, что происходит. Как правило, вы звоните, чтобы получить информацию о другой части вашей программы (деятельность, пакет / приложение)
Вы можете получить контекст, вызвав getApplicationContext(), getContext(), getBaseContext() или же this (когда в классе деятельности).
Для получения контекста Anywhere в приложении используйте следующий код:
Создать новый класс AppContext внутри вашего приложения для Android
public class AppContext extends Application {
private static Context context;
public void onCreate(){
super.onCreate();
AppContext.context = getApplicationContext();
}
public static Context getAppContext() {
return AppContext.context;
}
}
Теперь, когда вам нужен контекст приложения в неактивном классе, вызовите этот метод, и вы получите контекст приложения.
Надеюсь это поможет;)
Контекст является ссылкой на текущий объект, как это. Также контекст позволяет получить доступ к информации о среде приложения.
Думайте об этом как о виртуальной машине, которая изолировала процесс, в котором выполняется приложение или служба. Изолированная среда имеет доступ к куче базовой информации о системе и определенных разрешенных ресурсов. Вам нужен этот контекст, чтобы получить эти услуги.
Класс android.content.Context обеспечивает подключение к системе Android и ресурсам проекта. Это интерфейс к глобальной информации о среде приложения.
Контекст также обеспечивает доступ к Сервисам Android, например, к Службе определения местоположения.
Деятельность и Услуги расширяют Context учебный класс.
Контекст - это дескриптор системы Android, который может предоставлять системную информацию, ресурсы, но также будет действовать как посредник, который склеивает различные части вашего приложения или компоненты других приложений или служб, которые могут обрабатывать ваши запросы. Он предоставляет все, что должно обрабатываться ОС, и не может быть обработано непосредственно вашим кодом.
В любом случае контекст - это всегда посредник ОС, который будет стоять между вашим кодом и системой Android , доставляя запросы в ОС, чтобы получить некоторую информацию или выполнить какое-либо действие самой системой Android.
Таким образом, в следующий раз, когда вы будете использовать «контекст» в вызове метода, вы будете знать, что это транспортное средство достигнет ОС и попросит ее выполнить или получить запрос вашего метода.
Я написал целую статью, в которой объясняется, как Контекст связывает ваше приложение с системой Android:
Контекст - это интерфейс к глобальной информации о среде приложения. Это абстрактный класс, реализация которого обеспечивается Android система.
Context обеспечивает доступ к ресурсам и классам приложений, а также к вызовам таких операций на уровне приложений, как launching activities, broadcasting and receiving intents, etc.
Вот пример
public class MyActivity extends Activity {
public void Testing() {
Context actContext = this; /*returns the Activity Context since Activity extends Context.*/
Context appContext = getApplicationContext(); /*returns the context of the single, global Application object of the current process. */
Button BtnShowAct1 = (Button) findViewById(R.id.btnGoToAct1);
Context BtnContext = BtnShowAct1.getContext(); /*returns the context of the View. */
Для получения более подробной информации вы можете посетить http://developer.android.com/reference/android/content/Context.html
Context is Экземпляры класса android.content.Context обеспечивают соединение с системой Android, которая выполняет приложение. Например, вы можете проверить размер отображения текущего устройства через контекст.
Это также дает доступ к ресурсам проекта. Это интерфейс к глобальной информации о среде приложения.
Класс Context также предоставляет доступ к службам Android, например, диспетчеру аварийных сигналов для запуска событий, основанных на времени.
Действия и сервисы расширяют класс Context. Поэтому они могут быть непосредственно использованы для доступа к контексту.
Контекст в основном предназначен для доступа к ресурсам и получения сведений о среде приложения (для контекста приложения) или действия (для контекста действия) или любого другого...
Чтобы избежать утечки памяти, вы должны использовать контекст приложения для всех компонентов, которым нужен объект контекста.... для более подробной информации нажмите здесь
Контекст - это контекст текущего состояния приложения / объекта. Это объект, который представляет различные данные среды. Контекст помогает текущей деятельности взаимодействовать с внешней средой Android, такой как локальные файлы, базы данных, загрузчики классов, связанные с этой средой, службы, включая службы системного уровня, и многое другое.
Контекст - это дескриптор системы. Он предоставляет такие услуги, как разрешение ресурсов, получение доступа к базам данных и настройкам и т. Д. У приложения для Android есть действия. Это похоже на дескриптор среды, в которой ваше приложение в данный момент выполняется. Объект действия наследует объект Context.
Различные методы вызова, с помощью которых вы можете получить контекст 1. getApplicationContext(), 2. getContext(), 3. getBaseContext() 4. или this (в классе активности).
Выкладываю просто, андроиды Context это беспорядок, который вы не полюбите, пока не перестанете беспокоиться.
Android Contextэто:
Бог-объекты.
То, что вы хотите передать всем своим приложениям, когда начинаете разработку для Android, но избегаете этого, когда вы немного приблизитесь к программированию, тестированию и самому Android.
Непонятная зависимость.
Общий источник утечек памяти.
PITA для тестирования.
Фактический контекст, используемый системой Android для отправки разрешений, ресурсов, предпочтений, сервисов, трансляций, стилей, отображения диалогов и раздувания макета. А тебе нужны разные
Contextэкземпляры для некоторых отдельных вещей (очевидно, вы не можете показать диалог из контекста приложения или сервиса; макеты, накачанные из контекста приложения и действия, могут отличаться).
Контекст означает, что Android узнает, в какую деятельность я должен пойти или в которой я буду действовать.
1 - Toast.makeText (контекст, "Введите все данные", Toast.LENGTH_SHORT).show(); это используется в этом. Контекстный контекст = ActivityName.this;
2 -startActivity (новое намерение (контекст,LoginActivity.class));
в этом контексте означает, из какой деятельности вы хотите перейти к другой деятельности. context или ActivityName.this быстрее, getContext и getApplicatinContext.
Босс Помощник Аналогия
Давайте проведем небольшую аналогию, прежде чем углубиться в технические аспекты контекста.
У каждого босса есть помощник или кто-то (мальчик на побегушках), который делает для него менее важные и более трудоемкие вещи. Например, если им нужен файл или кофе, помощник будет в бегах. Босс не будет знать, что происходит в фоновом режиме, но файл или задание будет доставлено
Так вот
Босс - приложение для Android
Помощник - Контекст
Файл или чашка кофе - Ресурс
Что официальный сайт разработчика Android говорит о контексте
Контекст - это ваша точка доступа к ресурсам, связанным с приложением
Давайте посмотрим на некоторые из таких ресурсов или задач
Запуск деятельности.
Получение абсолютного пути к каталогу кэша приложения в файловой системе.
Определение того, разрешено ли данное разрешение для определенного процесса, и идентификатор пользователя, работающий в системе.
Проверка того, было ли вам предоставлено конкретное разрешение.
И так далее.
Так что, если приложение Android хочет начать действие, оно идет прямо к Context (Точка доступа) и Context класс возвращает ему ресурсы (намерение в этом случае).
Как и любой другой класс Context У класса тоже есть поля и методы.
Вы можете узнать больше о Context в официальной документации он охватывает практически все, доступные методы, поля и даже то, как использовать поля с методами.
Context это то, что большинство из нас назвали бы Application. Он сделан системой Android и может делать только то, что умеет приложение. В Tomcat контекст также является тем, что я бы назвал приложением.
Существует один контекст, который содержит много действий, каждое действие может иметь много представлений.
Очевидно, что некоторые скажут, что это не подходит из-за того или иного, и, вероятно, они правы, но если вы скажете, что Context - это ваше текущее приложение, это поможет вам понять, что вы вводите в параметры метода.
Контекст является специфическим для Android API для каждой изолированной программной среды приложения, который обеспечивает доступ к личным данным приложения, таким как ресурсы, база данных, частные каталоги файлов, настройки, настройки...
Большинство приватных данных одинаковы для всех видов деятельности / услуг / широковещательных списков одного приложения.
Поскольку Application, Activity, Service реализуют интерфейс Context, их можно использовать там, где для вызова API требуется параметр Context.
Если вы хотите связать Context с другими знакомыми классами в Android, имейте в виду следующую структуру:
Context
Context
Context
Context
Context
Итак, все эти классы являются контекстами по-своему. Вы можете преобразовать Service и ListActivity в Context, если хотите. Но если вы присмотритесь, некоторые классы также наследуют тему. В упражнении или фрагменте вы хотели бы, чтобы они применялись к вашим представлениям, но вам не важно, например, класс обслуживания.
Я объясняю разницу в контекстах здесь.
Экземпляры класса android.content.Context обеспечивают соединение с системой Android, которая выполняет приложение. Например, вы можете проверить размер отображения текущего устройства через контекст.
Это также дает доступ к ресурсам проекта. Это интерфейс к глобальной информации о среде приложения.
Класс Context также предоставляет доступ к службам Android, например, диспетчеру аварийных сигналов для запуска событий, основанных на времени.
Действия и сервисы расширяют класс Context. Поэтому они могут быть непосредственно использованы для доступа к контексту.
Интерфейс для глобальной информации о среде приложения. Это абстрактный класс, реализация которого обеспечивается системой Android. Он позволяет получить доступ к ресурсам и классам, относящимся к конкретному приложению, а также к дополнительным вызовам для операций на уровне приложения, таких как запуск, широковещание и получение и т.д.
Context означает компонент (или приложение) в различный период времени. Если я ем много еды между 13:00 и 14:00, тогда мой контекст того времени используется для доступа ко всем методам (или ресурсам), которые я использую в течение этого времени. Контент является компонентом (приложением) на определенное время. Context количество компонентов приложения постоянно меняется в зависимости от базового жизненного цикла компонентов или приложения. Например, внутри onCreate() Activity,
getBaseContext() - дает context из Activity это устанавливается (создается) конструктором деятельности. getApplicationContext() - дает Context Настройка (создается) при создании приложения.
Замечания: <application> содержит все компоненты Android.
<application>
<activity> .. </activity>
<service> .. </service>
<receiver> .. </receiver>
<provider> .. </provider>
</application>
Это значит, когда вы звоните getApplicationContext() из любого компонента вы вызываете общий контекст всего приложения.
Context система постоянно изменяется в зависимости от жизненного цикла компонентов.
Что именно?
Согласно справочной документации Android, это объект, представляющий различные данные среды. Он обеспечивает доступ к локальным файлам, базам данных, загрузчикам классов, связанным со средой, службам (включая службы системного уровня) и многому другому. В этой книге и при повседневном кодировании для Android вы будете часто встречаться с контекстом.
Из книги « Андроид на практике », с.60.
Для некоторых Android API требуется параметр as
Если вы просмотрите различные API-интерфейсы Android, вы заметите, что многие из них занимают
android.content.Contextобъект в качестве параметра. Вы также увидите, что Activity или Service обычно используются как . Это работает, потому что оба этих класса расширяются от
Context.
Если вы посмотрите на комментарий /questions/37401006/chto-takoe-kontekst-na-android/37401015#37401015 , вы найдете комментарий user4837296
Хм, для меня все это звучит так же, как мы, старожилы, называли глобальные переменные, что вызывало неодобрение, когда на сцене появилась объектная ориентация.
Он прав. Контекст является альтернативой глобальной переменной.
Для простоты можно сказать, что:global variable ≈ context
Преимущество контекста над глобальной переменной заключается в том, что глобальные переменные делают невозможным создание двух независимых экземпляров одной и той же системы в одном и том же процессе, тогда как контекст позволяет нескольким экземплярам системы сосуществовать в одном процессе, каждый со своим собственным контекстом. .
Пожалуйста, ознакомьтесь с «Философией дизайна программного обеспечения» Джона Оустерхаута, 7.5 Переменные сквозного доступа.
глобальные переменные делают невозможным создание двух независимых экземпляров одной и той же системы в одном процессе, поскольку доступ к глобальным переменным будет конфликтовать.
...
Решение, которое я использую чаще всего, состоит в том, чтобы ввести объект контекста, как показано на рис. 7.2(d). Контекст хранит все глобальное состояние приложения (все, что в противном случае было бы сквозной переменной или глобальной переменной ). Большинство приложений имеют несколько переменных в своем глобальном состоянии, представляющих такие вещи, как параметры конфигурации, общие подсистемы и счетчики производительности. На каждый экземпляр системы приходится один объект контекста. Контекст позволяет нескольким экземплярам системы сосуществовать в одном процессе, каждый со своим собственным контекстом .
позже в разделе комментариев вы найдете еще один комментарий от user817044
Если вы просто выберете кодовую базу, вы увидите сотни различных вариантов getContext, getBaseContext, getBlaBlaContext.
Он также прав.
Чтобы уменьшить количество методов, которые должны учитывать контекст, ссылка на контекст содержится во многих основных объектах. Вот почему вы видите getContext, getBaseContext, getBlaBlaContext... во многих местах.
Ссылка: «Философия дизайна программного обеспечения» Джона Оустерхаута, 7.5 Сквозные переменные.
К сожалению, контекст, вероятно, понадобится во многих местах, поэтому потенциально он может стать сквозной переменной. Чтобы уменьшить количество методов, которые должны знать об этом, ссылка на контекст может быть сохранена в большинстве основных объектов системы . В примере на рис. 7.2(d) класс, содержащий m3, хранит ссылку на контекст как переменную экземпляра в своих объектах. Когда создается новый объект, создающий метод извлекает контекстную ссылку из своего объекта и передает ее конструктору нового объекта. При таком подходе контекст доступен везде, но появляется только как явный аргумент в конструкторах.
Подробнее о контексте читайте в этой статье. Я объясню это вкратце.
Если вы хотите знать, что такое контекст, вы должны знать, что он делает...
например, getContext() - один из методов, которые извлекают контекст. В getContext() Context привязан к Activity и ее жизненному циклу. Мы можем представить Context как слой, который стоит за Activity, и он будет жить, пока живет Activity. В момент смерти Activity исчезнет и Context. этот метод дает список функций для деятельности, например:
Load Resource Values,
Layout Inflation,
Start an Activity,
Show a Dialog,
Start a Service,
Bind to a Service,
Send a Broadcast,
Register BroadcastReceiver.
теперь представьте, что:
Контекст - это уровень (интерфейс), который стоит за его компонентом (Activity, Application…) и жизненным циклом компонента, который обеспечивает доступ к различным функциям, которые поддерживаются средой приложения и платформой Android.