Android — Создание неявного интента с использованием провайдера


Содержание

Неявный Intent

Вот тут написано: «При вызове метода startActivity() система анализирует все установленные приложения, чтобы определить, какие из них могут откликнуться на объект Intent этого вида. . Если объект Intent принимают несколько операций, система отображает диалоговое окно, в котором пользователь может выбрать приложение для выполнения данного действия.»

Возник вопрос — можно ли исключить из диалогового окна конкретное приложение, если оно установлено у пользователя?

23.03.2020, 21:50

Intent
Доброе утро. Помогите с одним вопросом. Как из модального окна, когда нажимаешь на кнопку.

Timer \ Intent
Доброй ночи. При запуске StartActivity через 3 сек должно открыться MainActivity, оно то работает.

Шаринг INTENT
Привет. можно ли зашарить таким способом, через Intent.

23.03.2020, 21:50

Intent в Canvas
в private void draw нужно использовать переменную T из соседнего класса я использую, строка с.

Intent в конструкторе
Как правильно создать Intent в конструкторе создаваемого обьекта. Идея в том, чтобы имя обьекта.

Завершить Intent Service
Друзья подскажите пожалуйста, задача такая работает Intent service когда выполняет задачу он.

Объекты Intent и фильтры объектов Intent

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

Компонент Activity представляет собой один экран в приложении. Для запуска нового экземпляра компонента Activity необходимо передать объект Intent методу startActivity() . Объект Intent описывает операцию, которую требуется запустить, а также содержит все остальные необходимые данные.

Если после завершения операции от нее требуется получить результат, вызовите метод startActivityForResult() . Ваша операция получит результат в виде отдельного объекта Intent в обратном вызове метода onActivityResult() операции. Подробные сведения см. в руководстве Операции.

Для запуска службы:

Service является компонентом, который выполняет действия в фоновом режиме без пользовательского интерфейса. Службу можно запустить для выполнения однократного действия (например, чтобы загрузить файл), передав объект Intent методу startService() . Объект Intent описывает службу, которую требуется запустить, а также содержит все остальные необходимые данные.

Если служба сконструирована с интерфейсом клиент-сервер, к ней можно установить привязку из другого компонента, передав объект Intent методу bindService() . Подробные сведения см. в руководстве Службы.

Для рассылки широковещательных сообщений:

Широковещательное сообщение ― это сообщение, которое может принять любое приложение. Система выдает различные широковещательные сообщения о системных событиях, например, когда система загружается или устройство начинает заряжаться. Для выдачи широковещательных сообщений другим приложениям необходимо передать объект Intent методу sendBroadcast() , sendOrderedBroadcast() или sendStickyBroadcast() .

Типы объектов Intent

Есть два типа объектов Intent:

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

Когда создан явный объект Intent для запуска операции или службы, система немедленно запускает компонент приложения, указанный в объекте Intent .

Рисунок 1. Схематическое изображение процесса передачи неявного объекта Intent по системе для запуска другой операции: [1] Операция А создает объект Intent с описанием действия и передает его методу startActivity() . [2] Система Android ищет во всех приложениях фильтры Intent, которые соответствуют данному объекту Intent. Когда приложение с подходящим фильтром найдено, [3] система запускает соответствующую операцию (Операция B), вызвав ее метод onCreate() и передав ему объект Intent .

Когда создан неявный объект Intent, система Android находит подходящий компонент путем сравнения содержимого объекта Intent с фильтрами Intent, объявленными в файлах манифеста других приложений, имеющихся на устройстве. Если объект Intent совпадает с фильтром Intent, система запускает этот компонент и передает ему объект Intent . Если подходящими оказываются несколько фильтров Intent, система выводит диалоговое окно, где пользователь может выбрать приложение для выполнения данного действия.

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

Внимание! В целях обеспечения безопасности приложения всегда используйте явный объект Intent при запуске Service и не объявляйте фильтры Intent для своих служб. Запуск служб с помощью неявных объектов Intent является рискованным с точки зрения безопасности, поскольку нельзя быть на абсолютно уверенным, какая служба отреагирует на такой объект Intent, а пользователь не может видеть, какая служба запускается. Начиная с Android 5.0 (уровень API 21) система вызывает исключение при вызове метода bindService() с помощью неявного объекта Intent.

Создание объекта Intent

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

Основные сведения, содержащиеся в объекте Intent :

Имя компонента Имя компонента, который требуется запустить.

Эта информация является необязательной, но именно она и делает объект Intent явным. Ее наличие означает, что объект Intent следует доставить только компоненту приложения, определенному по имени. При отсутствии имени компонента объект Intent является неявным, а система определяет, какой компонент получит этот объект Intent по другим сведениям, которые в нем содержатся (например, по действию, данным и категории — см. описание далее). Поэтому, если вам требуется запустить определенный компонент из своего приложения, следует указать его имя.

Примечание. При запуске Service следует всегда указывать имя компонента. В противном случае вы не сможете быть на абсолютно уверенным в том, какая служба отреагирует на объект Intent, а пользователь не может видеть, какая служба запускается.

Это поле объекта Intent представляет собой объект ComponentName , который можно указать с помощью полного имени класса целевого компонента, включая имя пакета приложения. Например, com.example.ExampleActivity . Задать имя компонента можно с помощью метода setComponent() , )»>setClass() , setClassName() или конструктора Intent .

Действие Строка, определяющая стандартное действие, которое требуется выполнить (например, view (просмотр) или pick (выбор)).

При выдаче объектов Intent с широковещательными сообщениями это действие, которое произошло и о котором сообщается. Действие в значительной степени определяет, каким образом структурирована остальная часть объекта Intent,—в частности, что именно содержится в разделе данных и дополнительных данных.

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

ACTION_VIEW Используйте это действие в объекте Intent с методом startActivity() , когда имеется определенная информация, которую операция может показать пользователю, например, фотография в приложении галереи или адрес для просмотра в картографическом приложении. ACTION_SEND Его еще называют объектом Intent «share» (намерение предоставить общий доступ). Это действие следует использовать в объекте Intent с методом startActivity() , при наличии определенных данных, доступ к которым пользователь может предоставить через другое приложение, например приложение для работы с электронной почтой или социальными сетями.

Другие константы, определяющие стандартные действия, см. в справочнике по классу Intent . Другие действия определяются в других частях платформы Android. Например, в Settings определяются действия, открывающие ряд экранов приложения настройки системы.

Действие можно указать для объекта Intent с методом setAction() или конструктором Intent .

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

Данные URI (объект Uri ), ссылающийся на данные, с которыми будет выполняться действие и/или тип MIME этих данных. Тип передаваемых данных обычно определяется действием объекта Intent. Например, если действием является ACTION_EDIT , в данных должен содержаться URI документа, который требуется отредактировать.

При создании объекта Intent, помимо URI, зачастую бывает важно указать тип данных (их тип MIME). Например, операция, которая может выводить на экран изображения, скорее всего, не сможет воспроизвести аудиофайл, даже если и у тех, и у других данных будут одинаковые форматы URI. Поэтому указание типа MIME данных помогает системе Android найти наиболее подходящий компонент для получения вашего объекта Intent. Однако тип MIME иногда можно унаследовать от URI — в частности, когда данные представляют собой content: URI, который указывает, что данные находятся на устройстве и ими управляет ContentProvider , а это дает возможность системе видеть тип MIME данных.

Чтобы задать только URI данных, вызовите setData() . Чтобы задать только тип MIME, вызовите setType() . При необходимости оба этих параметра можно в явном виде задать с помощью setDataAndType() .

Внимание! Если требуется задать и URI, и тип MIME, не вызывайте setData() и setType() , поскольку каждый из этих методов аннулирует результат выполнения другого. Чтобы задать URI и тип MIME всегда используйте метод setDataAndType() .

Категория Строка, содержащая прочие сведения о том, каким компонентом должна выполняться обработка этого объекта Intent. В объект Intent можно поместить любое количество описаний категорий, однако большинству объектов Intent категория не требуется. Вот некоторые стандартные категории: CATEGORY_BROWSABLE Целевая операция позволяет запускать себя веб-браузером для отображения данных, указанных по ссылке — например, изображения или сообщения электронной почты. CATEGORY_LAUNCHER Эта операция является начальной операцией задачи, она указана в средстве запуска приложений системы.

Полный список категорий см. в описании класса Intent .

Указать категорию можно с помощью addCategory() .

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

Однако в объекте Intent может быть приведена и другая информация, которая не влияет на то, каким образом определяется требуемый компонент приложения. Объект Intent также может содержать:

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

Добавлять дополнительные данные можно с помощью различных методов putExtra() , каждый из которых принимает два параметра: имя и значение ключа. Также можно создать объект Bundle со всеми дополнительными данными, затем вставить объект Bundle в объект Intent с помощью метода putExtras() .

Например, при создании объекта Intent для отправки сообщения электронной почты с методом ACTION_SEND можно указать получателя с помощью ключа EXTRA_EMAIL , а тему сообщения ― с помощью ключа EXTRA_SUBJECT .

Класс Intent указывает много констант EXTRA_* для стандартных типов данных. Если вам требуется объявить собственные дополнительные ключи (для объектов Intent, которые принимает ваше приложение), обязательно указывайте в качестве префикса имя пакета своего приложения. Например:


Флаги Флаги, определенные в классе Intent , которые действуют как метаданные для объекта Intent. Флаги должны указывать системе Android, каким образом следует запускать операцию (например, к какой задаче должна принадлежать операция ) и как с ней обращаться после запуска (например, будет ли она указана в списке последних операций).

Подробные сведения см. в документе, посвященном методу setFlags() .

Пример явного объекта Intent

Явные объекты Intent используются для запуска конкретных компонентов приложения, например определенной операции или службы. Чтобы создать явный объект Intent, задайте имя компонента для объекта Intent — все остальные свойства объекта Intent можно не задавать.

Например, если в своем приложении вы создали службу с именем DownloadService , предназначенную для загрузки файлов из Интернета, то для ее запуска можно использовать следующий код:

Конструктор )»>Intent(Context, Class) предоставляет Context приложению, а компоненту ― объект Class . Фактически этот объект Intent явно запускает класс DownloadService в приложении.

Подробные сведения о создании и запуске службы см. в руководстве Службы.

Пример неявного объекта Intent

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

Например, если у вас есть контент и вы хотите, чтобы пользователь поделился им с другими людьми, создайте объект Intent с действием ACTION_SEND и добавьте дополнительные данные, указывающие на контент, общий доступ к которому следует предоставить. Когда с помощью этого объекта Intent вы вызываете startActivity() , пользователь сможет выбрать приложение, посредством которого к контенту будет предоставлен общий доступ.

Внимание! Возможна ситуация, когда на устройстве пользователя не будетникакого приложения, которое может откликнуться на неявный объект Intent, отправленный вами методу startActivity() . В этом случае вызов закончится неудачей, а работа приложения аварийно завершится. Чтобы проверить, будет получен ли операцией объект Intent, вызовите метод resolveActivity() для своего объекта Intent . Если результатом будет значение, отличное от null, значит, имеется хотя бы одно приложение, которое способно откликнуться на объект Intent и можно вызывать startActivity() . Если же результатом будет значение null, объект Intent не следует использовать и по возможности следует отключить функцию, которая выдает этот объект Intent.

Примечание. В этом случае URI не используется, а вместо этого следует объявить тип данных объекта Intent, чтобы указать контент, содержащийся в дополнительных данных.

При вызове метода startActivity() система анализирует все установленные приложения, чтобы определить, какие из них могут откликнуться на объект Intent этого вида (объект Intent с действием ACTION_SEND и данными «text/plain» ). Если имеется только одно подходящее приложение, оно будет сразу же открыто и получит данный объект Intent. Если объект Intent принимают несколько операций, система отображает диалоговое окно, в котором пользователь может выбрать приложение для выполнения данного действия.

Рисунок 2. Диалоговое окно выбора.

Принудительное использование блока выбора приложения

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

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

Чтобы вывести на экран блок выбора приложения, создайте Intent с помощью createChooser() и передайте его startActivity() . Например:

В результате на экран будет выведено диалоговое окно со списком приложений, которые могут отреагировать на объект Intent, переданный методу createChooser() и используют указанный текст в качестве заголовка диалога.

Получение неявного объекта Intent

Чтобы указать, какие неявные объекты Intent может принимать ваше приложение, объявите один или несколько фильтров Intent для каждого компонента приложения с помощью элемента в файле манифеста. Каждый фильтр Intent указывает тип объектов Intent, которые принимает компонент на основании действия, данных и категории, заданных в объекте Intent. Система передаст неявный объект Intent вашему приложению, только если он может пройти через один из ваших фильтров Intent.

Примечание. Явный объект Intent всегда доставляется его целевому компоненту, без учета любых фильтров Intent, объявленных компонентом.

Компонент приложения должен объявлять отдельные фильтры для каждой уникальной работы, которую он может выполнить. Например, у операции из приложения для работы с галереей изображений может быть два фильтра: один фильтр для просмотра изображения, и второй для его редактирования. Когда операция запускается, она анализирует объект Intent и выбирает режим своей работы на основании информации, приведенной в Intent (например, показывать элементы управления редактора или нет).

Каждый фильтр Intent определяется элементом в файле манифеста приложения, указанном в объявлении соответствующего компонента приложения (например, в элементе ). Внутри элемента , можно указать тип объектов Intent, которые будут приниматься, с помощью одного или нескольких из следующих трех элементов:

Примечание. Для получения неявных объектов Intent необходимо включить категорию CATEGORY_DEFAULT в фильтр Intent. Методы startActivity() и startActivityForResult() обрабатывают все объекты Intent, как если бы они объявляли категорию CATEGORY_DEFAULT . Если вы не объявляете эту категорию в своем фильтре Intent, никакие неявные объекты Intent не будут переданы в вашу операцию.

В следующем примере объявлена операция с фильтром Intent, определяющим получение объекта Intent ACTION_SEND , когда данные относятся к типу text:

Когда требуется обрабатывать объекты Intent нескольких видов, но только в определенных сочетаниях действия, типа данных и категории, необходимо создать несколько фильтров Intent.

Ограничение доступа к компонентам

Использование фильтра Intent не является безопасным способом предотвращения запуска ваших компонентов другими приложениями. Несмотря на то, что после применения фильтров Intent компонент будет реагировать только на неявные объекты Intent определенного вида, другое приложение теоретически может запустить компонент вашего приложения с помощью явного объекта Intent, если разработчик определит имена ваших компонентов. Если важно, чтобы только ваше собственное приложение могло запускать один из ваших компонентов, задайте для атрибута exported этого компонента значение «false» .

Неявный объект Intent проверяется фильтром путем сравнения объекта Intent с каждым из этих трех элементов. Чтобы объект Intent был доставлен компоненту, он должен пройти все три теста. Если он не будет соответствовать хотя бы одному из них, система Android не доставит этот объект Intent компоненту. Однако, поскольку у компонента может быть несколько фильтров Intent, объект Intent, который не проходит через один из фильтров компонента, может пройти через другой фильтр. Подробные сведения о том, каким образом система принимает решения по поводу объектов Intent, см. в приведенном далее разделе Разрешение объектов Intent.

Внимание! Чтобы случайно не запустить Service другого приложения, всегда используйте явные объекты Intent для запуска собственных служб и не объявляйте для них фильтры Intent.

Цукерберг рекомендует:  Аутентификация через Одноклассники

Примечание. Фильтры Intent необходимо объявлять в файле манифеста для всех операций. Фильтры для приемников широковещательных сообщений можно регистрировать динамически путем вызова registerReceiver() . После этого регистрацию приемника широковещательных сообщений можно отменить с помощью unregisterReceiver() . В результате ваше приложение сможет воспринимать определенные объявления только в течение указанного периода времени в процессе работы приложения.

Примеры фильтров

Чтобы лучше понять различные режимы работы фильтров Intent, рассмотрите следующий фрагмент из файла манифеста приложения для работы с социальными сетями.

Первая операция ( MainActivity ) является основной точкой входа приложения — это операция, которая открывается, когда пользователь запускает приложение нажатием на его значок:

  • Действие ACTION_MAIN указывает на то, что это основная точка входа, и не ожидает никаких данных объекта Intent.
  • Категория CATEGORY_LAUNCHER указывает, что значок этой операции следует поместить в средство запуска приложений системы. Если элемент не содержит указаний на конкретный значок с помощью icon , то система воспользуется значком из элемента .

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

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

Примечание. Тип MIME ( application/vnd.google.panorama360+jpg ) является особым типом данных, указывающим на панорамные фотографии, с которыми можно работать с помощью API-интерфейсов Google panorama.

Использование ожидающего объекта Intent

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

Основные варианты использования ожидающего объекта Intent:

  • Объявление объекта Intent, который должен будет исполняться, когда пользователь выполняет действие с вашим уведомлением ( NotificationManager системы Android исполняет Intent ).
  • Объявление объекта Intent, который должен будет исполняться, когда пользователь выполняет действие с вашим виджетом приложения (приложение главного экрана исполняет Intent ).
  • Объявление объекта Intent, который должен будет исполняться в указанное время в будущем ( AlarmManager системы Android исполняет Intent ).

Поскольку каждый объект Intent предназначен для обработки компонентом приложения, который относится к определенному типу ( Activity , Service или BroadcastReceiver ), объект PendingIntent также следует создавать с учетом этого обстоятельства. При использовании ожидающего объекта Intent ваше приложение не будет исполнять объект Intent вызовом, например, startActivity() . Вместо этого вам необходимо будет объявить требуемый тип компонента при создании PendingIntent путем вызова соответствующего метода-создателя:

Если только ваше приложение не принимает ожидающие объекты Intent от других приложений, указанные выше методы создания PendingIntent являются единственными методами PendingIntent , которые вам когда-либо понадобятся.

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

Подробные сведения об использовании ожидающих объектов Intent приведены в документации по каждому из соответствующих вариантов использования, например, в руководствах, посвященным API-интерфейсам: Уведомления и Виджеты приложений.

Разрешение объектов Intent

Когда система получает неявный объект Intent для запуска операции, она выполняет поиск наиболее подходящей операции путем сравнения объекта Intent с фильтрами Intent по трем критериям:

  • действие объекта Intent;
  • данные объекта Intent (тип URI и данных);
  • категория объекта Intent.

В следующих разделах описывается, каким образом объекты Intent сопоставляются с соответствующими компонентами, а именно, как должен быть фильтр Intent объявлен в файле манифеста приложения.

Тестирование действия

Для указания принимаемых действий объекта Intent фильтр Intent может объявлять любое (в том числе нулевое) число элементов action> . Например:

Чтобы пройти через этот фильтр, действие, указанное в объекте Intent , должно соответствовать одному или нескольким действиям, перечисленным в фильтре.


Если в фильтре не перечислены какие-либо действия, объекту Intent будет нечему соответствовать, поэтому все объекты Intent не пройдут этот тест. Однако, если в объекте Intent не указано действие, он пройдет тест (если в фильтре содержится хотя бы одно действие).

Тестирование категории

Для указания принимаемых категорий объекта Intent фильтр Intent может объявлять любое (в том числе нулевое) число элементов . Например:

Чтобы объект Intent прошел тестирование категории, все категории, приведенные в объекте Intent , должны соответствовать категории из фильтра. Обратное не требуется — фильтр Intent может объявлять и другие категории, которых нет в объекте Intent , объект Intent при этом все равно пройдет тест. Поэтому объект Intent без категорий всегда пройдет этот тест, независимо от того, какие категории объявлены в фильтре.

Примечание. Система Android автоматически применяет категорию CATEGORY_DEFAULT ко всем неявным объектам Intent, которые передаются в startActivity() и startActivityForResult() . Поэтому, если вы хотите, чтобы ваша операция принимала неявные объекты Intent, в ее фильтрах Intent должна быть указана категория для «android.intent.category.DEFAULT» (как показано в предыдущем примере ).

Тестирование данных

Для указания принимаемых данных объекта Intent фильтр Intent может объявлять любое (в том числе нулевое) число элементов . Например:

Каждый элемент может конкретизировать структуру URI и тип данных (тип мультимедиа MIME). Имеются отдельные атрибуты — scheme , host , port и path — для каждой составной части URI:

В этом URI схема имеет вид content , узел ― com.example.project , порт ― 200 , а путь ― folder/subfolder/etc .

Каждый из этих атрибутов является необязательным в элементе , однако имеются линейные зависимости:

  • Если схема не указана, узел игнорируется.
  • Если узел не указан, порт игнорируется.
  • Если не указана ни схема, ни узел, путь игнорируется.

Когда URI, указанный в объекте Intent, сравнивается с URI из фильтра, сравнение выполняется только с теми составными частями URI, которые приведены в фильтре. Например:

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

Примечание. Путь может быть указан с подстановочным символом (*), чтобы потребовалось только частичное соответствие имени пути.

При выполнении тестирования данных сравнивается и URI, и тип MIME, указанные в объекте Intent, с URI и типом MIME из фильтра. Действуют следующие правила:

  1. Объект Intent, который не содержит ни URI, ни тип MIME, пройдет этот тест, только если в фильтре не указано никаких URI или типов MIME.
  2. Объект Intent, в котором имеется URI, но отсутствует тип MIME (ни явный, ни тот, который можно вывести из URI), пройдет этот тест, только если URI соответствует формату URI из фильтра , а в фильтре также не указан тип MIME.
  3. Объект Intent, в котором имеется тип MIME, но отсутствует URI, пройдет этот тест, только если в фильтре указан тот же тип MIME и не указан формат URI.
  4. Объект Intent, в котором имеется и URI, и тип MIME (явный или тот, который можно вывести из URI), пройдет только часть этого теста, проверяющую тип MIME, в том случае, если этот тип совпадает с типом, приведенным в фильтре. Он пройдет часть этого теста, которая проверяет URI, либо если его URI совпадает с URI из фильтра, либо если этот объект содержит URI content: или file: , а в фильтре URI не указан. Другими словами, предполагается, что компонент поддерживает данные content: и file: , если в его фильтре указан только тип MIME.

Это последнее правило (правило (d)) отражает ожидание того, что компоненты будут в состоянии получать локальные данные из файла или от поставщика контента. Поэтому их фильтры могут содержать только тип данных, а явно указывать схемы content: и file: не требуется. Это типичный случай. Например, такой элемент , как приведенный далее, сообщает системе Android, что компонент может получать данные изображений от поставщика контента и выводить их на экран:

Поскольку имеющиеся данные преимущественно распространяются поставщиками контента, фильтры, в которых указан тип данных и нет URI, вероятно, являются самыми распространенными.

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

Сопоставление объектов Intent

Объекты Intent сопоставляются с фильтрами Intent не только для определения целевого компонента, который требуется активировать, но также для выявления определенных сведений о наборе компонентов, имеющихся на устройстве. Например, приложение главного экрана заполняет средство запуска приложений путем поиска всех операций с фильтрами Intent, в которых указано действие ACTION_MAIN и категория CATEGORY_LAUNCHER .

Ваше приложение может использовать сопоставление объектов Intent таким же образом. В PackageManager имеется набор методов query. () , которые возвращают все компоненты, способные принять определенный объект, а также схожий набор методов resolve. () , которые определяют наиболее подходящий компонент, способный реагировать на объект Intent. Например, метод queryIntentActivities() возвращает передаваемый как аргумент список всех операций, которые могут выполнить объект Intent, а метод queryIntentServices() возвращает такой же список служб. Ни тот, ни другой метод не активирует компоненты; они просто перечисляют те из них, которые могут откликнуться. Имеется схожий метод для приемников широковещательных сообщений ( <@link android.content.pm.PackageManager#queryBroadcastReceivers ).

Content and code samples on this page are subject to the licenses described in the Content License. Java is a registered trademark of Oracle and/or its affiliates.

Намерения (Intents)

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

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

Оказывается, люди и Android не так уж и различны.

В данном уроке по намерениям вы используете весь функционал намерений для создания собственного генератора мемов. В процессе вы узнаете:

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

Начало работы

Начните с загрузки стартового проекта для этого урока.

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

Если у вас уже открыта Android Studio, нажмите File > New > Import project и выберите скачанный стартовый проект. Если нет, то запустите Android Studio и выберите Open an existing Android Studio project на стартовом экране и выберите скачанный стартовый проект.

Потратьте некоторое время, чтобы ознакомиться с проектом, прежде чем продолжить. TakePictureActivity содержит ImageView, на который вы можете нажать, чтобы сделать снимок с помощью камеры вашего устройства. Когда вы нажмёте кнопку «Сгенерировать мем!», вы передадите путь к файлу растрового изображения, находящегося в ImageView, в EnterTextActivity, где начинается настоящая забава, так как вы можете ввести свой текст, чтобы превратить фотографию в новый вирусный мем!

Создание вашего первого намерения

Соберите и запустите проект. Вы должны увидеть следующее:

В настоящий момент если вы коснётесь ImageView, то ничего не произойдёт!

Добавив следующий код, вы сделаете приложение более интересным.

Откройте TakePictureActivity.java и добавьте следующую константу в начале класса:

По ней вы определите ваше намерение, когда оно вернётся, — вы узнаете об этом позже в уроке.

Примечание: в этом уроке предполагается, что вы знакомы с обработкой предупреждений об импорте пакетов и будете явно указывать импорт пакета для добавления. Пакет — это специальный библиотечный модуль, содержащий группу классов, объединённых одним пространством имён. Пакеты импортируются для того, чтобы в будущем не было необходимости писать имя пакета целиком, а лишь указать имя класса. В качестве памятки, если вы не настроили импорт пакетов на лету, вы можете импортировать их, нажимая Alt+Enter, когда курсор находится на предупреждении об импорте.

Добавьте следующий код чуть ниже onClick() вместе с необходимыми импортированными пакетами:

В этом методе много чего происходит, поэтому посмотрим шаг за шагом.

Первый блок кода объявляет объект Intent. Что же такое Intent?

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

  • Действия (Actions) – это то, чего намерению необходимо достичь, например, набрать номер, открыть ссылку, передать данные. Действие является просто строковой константой.
  • Данные (Data) – это ресурсы, которыми оперирует намерение. Они выражаются как URI объекты в Android. Тип требуемых данных для намерения изменяется в зависимости от действия. Вы ведь не хотите, чтобы ваше намерения для набора номера пыталось получить номер из изображения.

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

Вернитесь назад к takePictureWithCamera() и вы увидите, что намерение, которое вы создали, используется действие ACTION_IMAGE_CAPTURE. Вы, наверное, уже догадались, что это намерение сделает для вас фото, которое и нужное генератору мемов!

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

Примечание: Вы можете заметить, что переменная selectedPhotoPath добавляет в строку .fileprovider. Провайдеры файлов – это особый способ предоставления файлов вашему приложению и обеспечения его безопасности и безопасного доступа. Если вы проверите манифест Android, вы увидите, что приложение использует его.

Изучение Extras

Третий блок кода в вашем методе добавляет дополнения (Extra) к вашему намерению.

Что это такое, спросите вы?


Extras – это одна из пар типа «ключ-значение», которая даёт вашему намерению дополнительную информацию. Точно также люди с большей вероятностью будут работать лучше, если они готовы к этому, тоже самое можно сказать о намерениях в Android. Хорошее намерение всегда подготовлено с дополнительными данными, которые ему нужны!

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

Хорошим примером является намерение с действием ACTION_WEB_SEARCH. Это действие принимает пару «ключ-значение», называемую QUERY, которая представляет собой строку запроса, который вы ищете. Ключ в Extras является строковой константой, потому что его имя не должно меняться. Запуская намерение с вышеуказанным действием и связанным с ним дополнением, вы увидите страницу поиска Google с результатами вашего запроса.

Вернитесь назад на строку captureIntent.putExtra(). EXTRA_OUTPUT указывает, где вы должны сохранить фотографию с камеры – в данном случае это расположение URI пустого файла, который вы создали ранее.

Ваше намерение в действии

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

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

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

Затем добавьте следующий код в onClick() внутри case R.id.picture_imageview перед break:

Этот код будет вызывать takePictureWithCamera(), когда вы касаетесь ImageView.

Время проверять плоды вашего труда! Соберите проект и запустите. Коснитесь ImageView, чтобы вызвать камеру:

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

Примечание: если вы запускаете приложение в эмуляторе, вам может потребоваться отредактировать настройки камеры на вашем AVD. Для этого выберите Tools > Android > AVD Manager и нажмите на зелёный карандаш справа на виртуального устройства, которое вы хотите отредактировать. Затем нажмите Show advanced settings в левом нижнем углу окна. В разделе Camera убедитесь, что для всех камер выставлено значение Emulated или Webcam0.

Неявные намерения

Если вы запускаете приложение на физическом устройстве с несколькими приложениями-камерами, вы можете увидеть нечто неожиданное:

Вам будет предложено выбрать, какое приложение будет обрабатывать намерение.

Когда вы создаёте намерение, оно может быть задано как явно, так и неявно, в зависимости от того, что намерение должно использовать для выполнения своих действий. ACTION_IMAGE_CAPTURE это прекрасный пример неявного намерения.

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

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

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

Вы можете предотвратить это, проверив результат, чтобы убедиться, что хотя бы одно приложение ответило на это действие, прежде чем пытаться его запустить, или же вы можете заявить, что приложение может быть установлено только на устройствах, у которых есть камера. Для того, чтобы добавить это требование, нужно добавить следующий код в AndroidManifest.xml:

Стартовый проект выбирает для устройства метод ограничения.

Таким образом, у вас есть неявное намерение, чтоб сделать снимок, но нет способа получить доступ к этой фотографии в вашем приложении. Ваш генератор мемов далеко не уйдёт без фотографии!

Добавьте следующий метод чуть ниже takePictureWithCamera() в TakePictureActivity:

Вышеуказанный метод выполняется только в том случае, когда метод startActivityForResult() в takePictureWithCamera() завершается и возвращает результат.

Оператор if проверяет возвращённое значение requestCode, которое должно соответствовать константе TAKE_PHOTO_REQUEST_CODE, чтобы убедиться, что это ваше намерение. Также проверяется, чтобы resultCode был равен RESULT_OK. Эта постоянная указывает на успешное выполнение.

Если всё будет хорошо, тогда вы можете предположить, что изображение готово к использованию, поэтому можно вызывать setImageViewWithImage().

Время определить этот метод!

Сначала в верхней части TakePictureActivity добавьте следующую переменную типа Boolean:

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

Затем добавьте следующий код после onActivityResult():

BitmapResizer – это вспомогательный класс в комплекте со стартовым проектом, чтобы убедиться, что Bitmap, который вы получаете от камеры, масштабируется до нужного размера для экрана вашего устройства. Хотя устройство может масштабировать изображение для вас, изменение размера таким образом более эффективно с точки зрения памяти.

Теперь, когда setImageViewWithImage() готов, раскомментируйте строку, которая вызывает этот метод в onActivityResult():

Соберите проект и запустите. Выберите своё любимое приложения для фото – при появлении запроса – и сделайте ещё одну фотографию.

На этот раз фотография должна масштабироваться и отображаться в ImageView:

Вы также увидите TextView под изображением, который поздравит вас с превосходными навыками фотографии. Всегда хорошо быть вежливым.

Явные намерения

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

Всё ещё в TakePictureActivity добавьте следующие константы в начало класса:

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

Теперь добавьте следующий метод в нижней части TakePictureActivity, добавив при необходимости импорты:

Здесь вы проверяете pictureTaken, чтобы узнать, сделано ли фото и есть ли в ImageView ваше растровое изображение с камеры. Если растрового изображения нет, тогда на активности появится всплывающее сообщение, в котором говорится, что вы должны сделать фото. Сообщение создаётся в классе Toaster, который делает их создание чуточку проще. Если pictureTaken равен true, то вы создаёте намерение для следующего действия и настраиваете необходимые дополнения, используя константы, которые вы только что объявили.

Затем добавьте вызов метода в onClick() в блок case R.id.enter_text_button перед break:

Соберите проект и запустите. Коснитесь «Сгенерировать мем!» без предварительно сделанной фотографии, и вы увидите всплывающее сообщение:

Если фотография сделана, то moveToNextScreen() переходит к созданию намерения для активности с вводом текста. Он также прикрепляет в качестве дополнений путь URI для растрового изображения, а также его высоту и ширину. Это пригодится в следующей активности.

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

Это намерение создаётся путём предоставления контекста, из которого было создано намерение (в данном случае this), вместе с классом, который должно запустить намерение (EnterTextActivity.class). Поскольку вы явно указали, как намерение переходит от точки А к точке Б, Android просто исполнит его. Пользователь не имеет контроля над тем, как завершится намерение:

Соберите проект и запустите. Повторите процесс съёмки, но на этот раз коснитесь «Сгенерировать мем!». Ваше явное намерение выполнит действие и запустит следующую активность:

В стартовом проекте эта активность уже создана и объявлена в AndroidManifest.xml, поэтому вам не нужно создавать её самостоятельно.

Обработка намерений

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

Добавьте следующие константы в начало класса EnterTextActivity:

Это просто тени тех констант, которые вы создали в предыдущей активности.

Затем добавьте следующий код в конец метода onCreate():

Когда вы создаёте активность, вы присваиваете URI, переданный из предыдущей активности, в pictureUri путём доступа к намерению через метод getIntent(). Когда у вас есть доступ к намерению, вы можете получить доступ к своим Extras.

Поскольку переменные и объекты приходят в разных формах, у вас есть несколько методов доступа к ним. Для доступа к URI выше, например, вам необходимо использовать getParcelableExtra(). Другие дополнения существуют для других переменных, таких как строки и примитивные типы данных.

getIntExtra(), аналогично другим методам, возвращающим примитивы, также позволяет вам определить значение по умолчанию. Они используются, когда значение не указано ключ отсутствует в Extras.


После того, как вы извлекли необходимые дополнения, создайте растровое изображение из URI с помощью значений размера BITMAP_WIDTH и BITMAP_HEIGHT, которые вы передали. Наконец, вы устанавливаете источник изображения ImageView в растровое изображение для отображения фотографии.

В дополнение к отображению ImageView этот экран содержит также два вида EditText, в которых пользователь может ввести свой текст мема. Стартовый проект делает за вас тяжёлую работу, принимая текст из этих компонент и комбинируя его с фотографией.

Единственное, что вам нужно сделать – это очистить onClick(). Добавьте следующую строку в блок case R.id.write_text_to_image_button перед break:

Барабанная дробь. Соберите проект и запустите. Повторите обычные шаги, чтобы сделать снимок, а затем введите свой невероятно остроумный текст мема на втором экране и нажмите «Сгенерировать мем!»:

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

Передача намерения

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

К счастью, стартовый проект уже сделал это для вас – вам осталось лишь связать все части вместе.

Добавьте следующий код в saveImageToGallery(), чуть ниже блока try перед вторым вызовом Toaster.show():

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

Действие ACTION_MEDIA_SCANNER_SCAN_FILE также требует, чтобы намерение имело прикрепленные данные в форме URI, которые поступают из объекта File, в котором хранится Bitmap.

Наконец, вы передаёте намерение через Android так, чтобы любые заинтересованные стороны – в данном случае, медиа-сканер – могли воздействовать на него. Поскольку медиа-сканер не имеет пользовательского интерфейса, вы не можете запустить его, чтобы просто транслировать намерение.

Теперь добавьте следующий код в onClick(), внутри блока case R.id.save_image_button перед break:

Когда пользователь нажимает «Сохранить изображение», вышеуказанный код проверяет разрешение WRITE_EXTERNAL_STORAGE. Если он не предоставляется на Android Marshmallow и выше, метод вежливо попросит пользователя предоставить его. В противном случае, если вам разрешено писать на внешнее хранилище, он просто передаёт управление методу saveImageToGallery().

Код в saveImageToGallery() выполняет некоторую обработку ошибок и, если всё хорошо, стартует с намерения.

Соберите проект и запустите. Сделайте фото, добавьте какой-нибудь потрясающий текст для мема, нажмите «Сгенерировать мем!», а затем нажмите «Сохранить изображение», как только ваш мем будет готов.

Теперь закройте приложение и откройте приложение «Фото». Если вы используете эмулятор, откройте приложение «Галерея». Там вы увидите своё новое изображение во всей красе.

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

Фильтрация намерений

К настоящему времени у вас должно быть хорошее представление о том, как правильно использовать намерение для работы. Тем не менее, есть ещё одна сторона истории правильного намерения: как дать приложению узнать, какие намерения требуют ответа, когда отправляется неявное намерение.

Откройте AndroidManifest.xml и в первой активности вы увидите следующее:

Ключевой момент здесь это Intent Filter. Фильтр намерений позволяет частям вашего приложения реагировать на неявные намерения.

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

Это похоже на онлайн-знакомства для намерений и приложений.

Чтобы убедить, что это подходящее приложение для намерения, фильтр намерений предоставляет следующие три вещи:

Действие намерения: действие, которое приложение может выполнить. Это похоже на то, как приложение камеры выполняет действие ACTION_IMAGE_CAPTURE для вашего приложения.

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

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

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

Добавьте следующий код непосредственно под первым фильтром намерений в файле AndroidManifest.xml:

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

Теперь откройте TakePictureActivity.java и добавьте следующий код в конец класса:

Здесь вы получаете намерение, которое запустило активность, и извлекли из него действие и тип. Затем вы сравниваете их с тем, что вы указали в своём фильтре намерений, источником данных которого является MIME-тип изображения.

Если всё совпадает, то вы получите URI изображения, запросив URI для Bitmap, используя вспомогательный метод, включенный в стартовый проект, и, наконец, запросите у ImageView отобразить извлечённый Bitmap.

Затем добавьте следующую строку в конец метода onCreate():

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

Соберите проект и запустите. Затем вернитесь на главный экран и перейдите в приложение «Фото» или «Галерея» если вы используете эмулятор. Выберите любую фотографию и коснитесь кнопки «Отправить». Вы должны увидеть генератор мемов среди представленных вариантов:

Генератор мемов готов и ждёт, чтобы получить вашу фотографию! Выберите генератор мемов и посмотрите, что произойдёт — генератор мемов запускается с выбранной фотографией, уже загруженной в ImageView.

Ваше приложение теперь получает намерения как босс!

Куда пойти дальше?

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

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

Объект намерения Intent

При рассмотрении жизненных циклов двух активностей был использован объект Intent. С помощью данного объекта выполнялся переход из одной активности в другую и обратно. В данной статье рассматривается объект намерений Intent.

Intent представляет собой объект описания операции, которую необходимо выполнить через систему Android. Т.е. необходимо сначала описать некоторую операцию в виде объекта Intent, после чего отправить её на выполнение в систему вызовом одного из методов активности Activity.

Объекты Intent в основном используются в трёх операциях :

1. Старт операции
В android-приложении один экран представлен компонентом Activity, описанном в файле манифеста. Если необходимо в приложении иметь несколько экранов (страниц/форм), то все они должны быть зарегистрированы в манифесте приложения. Переход от одной активности к другой выполняется с помощью объекта Intent, который передается методу startActivity(). Объект Intent наряду с описанием операции может дополнительно включать все необходимые данные для выполнения операции.

Если необходимо получить результат выполнения операции, то следует использовать метод startActivityForResult(), который вернет отдельный объект Intent в обратном вызове метода onActivityResult().

2. Запуск сервиса
Android-приложение может выполнять действия в фоновом режиме без пользовательского интерфейса с помощью определенного сервиса, в качестве которого используется компонент Service. Сервис можно стартовать для выполнения какого-либо действия, например, чтение файла. Для старта сервиса необходимо вызвать метод активности startService() и передать ему объект Intent.

Если сервис имеет интерфейс типа клиент-сервер, то можно с ним установить связь через вызов метода bindService(), с передачей ему в качестве параметра объекта Intent.

3. Рассылка широковещательных сообщений
Широковещательное сообщение может принимать любое приложение android. Система генерирует различные широковещательные сообщения о системных событиях, например, зарядка устройства. Широковещательные сообщения отправляются другим приложениям передачей объекта Intent методам sendBroadcast(), sendOrderedBroadcast() или sendStickyBroadcast().

Типы объектов Intent

Существует два типа объектов Intent : явные и неявные.

Явные объекты Intent

Явные объекты Intent , как правило, используются для запуска компонента из собственного приложения, где известно наименование запускаемых классов и сервисов. В примере рассмотрения жизненных циклов двух активностей был использован следующий вызов 2-ой активности :

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

Пример старта сервиса


Если в приложении был создан какой-либо сервис, например ServiceDownload для загрузки файлов из Интернета, то для запуска этого сервиса можно использовать следующий код :

Неявные объекты Intent

Неявные объекты Intent не содержат имени конкретного класса. Вместо этого они включают действие (action), которое требуется выполнить. Неявный Intent может включать дополнительно наименование категории (category) и тип данных (data). Такой набор параметров позволяют компоненту из другого приложения обработать этот запрос. Например, если необходимо пользователю показать место на карте, то с помощью неявного объекта Intent можно попросить это сделать другое приложение, в котором данная функция предусмотрена.

Когда android получает неявный объект Intent для выполнения, то система ищет подходящие компоненты путем сравнения содержимого Intent с фильтрами Intent других приложений, зарегистрированных в файлах манифестов. Если параметры объекта Intent совпадают с параметрами одного из фильтров Intent, то система запускает этот компонент и передает ему объект Intent. При наличии нескольких подходящих фильтров система открывает диалоговое окно, где пользователь может выбрать подходящее приложение.

Фильтр Intent представляет собой секцию в файле манифеста приложения, описывающее типы объектов Intent, которые компонент мог бы выполнить. Таким образом, наличие фильтра Intent в описании активности в манифесте позволяет другим приложениям напрямую запускать данную операцию с помощью некоторого объекта Intent. Если фильтр Intent не описан, то операцию можно будет запустить только с помощью явного объекта Intent.

Механизм использования неявных объектов Intent для вызова компонентов других приложений напоминает вызовы API. Основное отличие между вызовами компонентов и вызовами API заключается в том, что вызовы компонентов с помощью неявных Intent являются асинхронными, а API-вызовы являются синхронными. Привязка API-вызовов выполняется на этапе компиляции, тогда как вызовы неявных намерений являются привязкой ко время выполнения. Намерение, которое работает синхронно и имеет привязку к конкретной активности, становится явным.

В случае, если система не сможет выполнить неявное намерение при вызове метода startActivity или startActivityForResult, то приложение завершится с ошибкой. Чтобы не допустить этого следует использовать метод намерения resolveActivity для проверки возможности выполнения заданного действия. Пример использования метода resolveActivity рассмотрен на странице описания взаимодействия с AlarmClock.

Фильтры намерений Intent

В секциях фильтров намерений в файле манифеста можно объявить только три составляющих объекта Intent : действие, данные, категория. Рассмотрим пример описания фильтров намерений для приложения работы с социальными сетями.

Первая активность (MainActivity), открывающаяся при старте приложения, является главной точкой входа. Действие «android.intent.action.MAIN» говорит о том, что это основная точка входа в приложение и не требуется ожидания никаких объектов Intent. Категория «android.intent.category.LAUNCHER» указывает на то, что значок данной активности следует поместить в средство запуска приложений системы. Если элемент не содержит указаний на конкретный значок с помощью тега icon, то система воспользуется значком из элемента манифеста .

Вторая активность (ShareActivity) предназначена для упрощения обмена текстовым и мультимедийным контентом. Несмотря на то, что пользователи могут входить в эту активность из MainActivity, они также могут открыть ShareActivity напрямую из другого приложения, которое создаст неявный объект Intent, соответствующий одному из двух фильтров Intent.

Действие намерения, action

Действие action объекта Intent определяет, что нужно выполнить, например просмотр фото (view) или выбор фото (pick). В значительной степени действие определяет, каким образом описана остальная часть намерения Intent, в частности, что именно содержится в разделе данных. Действие для объекта Intent можно указать методом setAction() или определить в конструкторе Intent. Если Вы определяете собственные действия, то необходимо использовать наименование пакета приложения. Например :

Рассмотрим простой пример формирования неявного намерения для открытия определенной страницы сайта :

В данном примере создается намерение с действием ACTION_VIEW, означающим просмотр чего-либо. При вызове данного намерения текущая активность приостанавливает своё действие и переходит в фоновый режим. При нажатии пользователем кнопки Back исходная активность восстанавливется. Некоторые константные значения действий, используемые в java-коде, представлены в следующей таблице :

BROWSABLE Операция стартует веб-браузер для отображения данных, указанных по ссылке (url), например, изображение или сообщение электронной почты.
LAUNCHER Операция (активность) является начальной операцией задачи. Активность с данной категорией помещается в окно для запуска приложений.
DEFAULT Данная категория позволяет объявить компонент обработчиком по умолчанию для действия, выполняемого с указанным типом данных внутри фильтра намерений.
HOME Активность с данной категорией отображает главный экран (Home Screen), который открывается после включения устройства и загрузки системы, или когда нажимается клавиша HOME.

Константные наименования категории, используемые в java-коде, имеют префикс «CATEGORY_». С другими константными категориями можно познакомиться в справочнике Intent.

Данные намерения

При создании объекта Intent в некоторых случая необходимо определить данные (data). Например, для действия ACTION_EDIT, данные должны включать URI документа, который требуется отредактировать. Объект Uri ссылается на данные и/или тип этих данных MIME. Так, например, операция, которая выводит на экран изображения, скорее всего, не сможет воспроизвести аудио/видео файл, даже если и у тех, и у других данных будут одинаковые форматы URI. Поэтому указание типа данных MIME помогает системе Android найти наиболее подходящий компонент для выполнения объекта Intent.

Чтобы задать только URI данных, используйте метод setData(). Чтобы определить только тип MIME, вызовите setType(). При необходимости определения обоих параметров можно вызвать метод setDataAndType().

Примечание : чтобы определить URI и тип MIME следует использовать метод setDataAndType(). Не вызывайте методы setData() и setType() поочередно, поскольку каждый из этих методов аннулирует результат выполнения другого.

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

  • android:host – определение имени удалённого сервера, например, google.com;
  • android:port – определение порта удалённого сервера;
  • android:path – определение пути URI;
  • android:mimetype – определение типа данных, которые компонент может обрабатывать;
  • android:scheme – необходимо использовать конкретную схему (например, content или http).

В файле манифеста наряду с фильтрами намерений Intent настраиваются и другие параметры приложения. О том, как настроить атрибут configChanges, чтобы приложение реагировало на изменение ориентации устройста (portrait|landscape) или на изменение размера экрана можно прочитать здесь.

Дополнительные данные

Данные, содержащие дополнительную информацию, необходимую для выполнения запрошенного действия, определяются в виде пары «ключ-значение». Добавлять дополнительные данные можно с помощью различных методов putExtra(), каждый из которых принимает два параметра : имя и значение ключа. Также можно создать объект Bundle с дополнительными данными и вставить его в Intent с помощью метода putExtras(). Например, для отправки сообщения электронной почты адрес получателя можно указать с помощью ключа EXTRA_EMAIL, а тему сообщения ― с помощью ключа EXTRA_SUBJECT.

Класс Intent имеет несколько констант EXTRA_* для стандартных типов данных. Если необходимо использовать собственные дополнительные ключи для объектов Intent, которые принимает только ваше приложение, обязательно указывайте в качестве префикса имя пакета своего приложения. Например :

Определение намерения, запустившего активность

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

Методы getAction() и getData() позволяют определить действие и данные, связанные с намерением. Для получения дополнительной информации, хранящейся в параметре extras, используйте типизированные методы get Extra.

Delphi XE5: использование Intent (намерения) в Android

Одной из многочисленных фич операционной системы Android является использование намерений (Intent). По сути Intent представляет собой механизм описания одной операции, которую необходимо выполнить — выбрать изображение, отправить сообщение в Facebook, отправить письмо и т.д. Многие приложения используют Intent для своей работы. Наиболее часто используемой возможностью Intent является запуск в своем приложении другой активности (например, вызвать из своего приложения Dropbox для сохранения файла). Однако на этом возможности Intent не заканчиваются. Так, используя Intent мы можем:

  • выполнить какое-либо действие
  • запустить сервис
  • отправить уведомление о каком-либо событии.

В Delphi XE5 для работы с намерениями нам потребуется интерфейс JIntent о котором я очень кратко (буквально в пару строк кода) рассказывал в предыдущей статье, посвященной разработке для андроид в Delphi. Сегодня я постараюсь более подробно разобраться с работой механизма намерений и разобрать ещё несколько примеров по его использованию. Намерение (Intent) может быть двух видов — явным и неявным.Если говорить кратко, то в явном намерении мы однозначно (явно) указываем какую активность нам необходимо вызвать для чего указываем намерению необходимый класс. Например, мы можем создать намерение на запуск приложения Twitter (если, конечно. оно установлено на устройстве). Вместе с указанием класса мы также можем указать и необходимый набор данных, которые будут переданы в принимающую активность (например, текст сообщения для Twitter). В случае же использования неявных намерений система Андроид сама определяет перечень активностей, которые могут обработать передаваемые данные. Например, ниже представлен скриншот, на котором показано какие приложения Android выбрал для отправки простого текста:

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

Как Android «понимает» какие из доступных нам активностей можно использовать для работы с передаваемыми данными? Ответ заключается в трех возможных параметрах, используемых в намерениях: действие (action), данные (data) и категория (category). Используя только три этих параметра Android и «угадывает», что мы от него хотим. Ну, например, вернемся к рассмотренному ранее примеру — открытие ссылки в браузере:

Отправка пользователя в другое android-приложение

В этом уроке

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

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

Этот урок покажет вам, как создать неявное интент для того или иного действия, и как его использовать для запуска activity , которая выполняет действие в другом приложении.

Создание неявного интента

Неявные интенты не объявляют имя класса компонента для запуска, а вместо этого объявляют выполняемое действие. Действие определяет, что вы хотите сделать, например, просмотреть,редактировать, послать, или получить что-нибудь. Интенты часто включают в себя также данные, связанные с действием, такие как адрес, который вы хотите просмотреть, или сообщения электронной почты, которое требуется передать. В зависимости от интента, которое вы хотите создать, данные могут быть Uri , каким-либо другим типом данных, или интент может не нуждаться в данных вообще.

Если ваши данные это Uri , есть простой Intent() конструктор, который можно использовать для определения действия и данных.

Например, вот как создать интент, инициирующее телефонный звонок с помощью Uri , указывающий номер телефона:

В чем разница между Явным и неявным вызовом активности в andro >

В чем разница между явным и неявным вызовом активности в android? Если вы объясните ответ простым примером, это будет хорошо.


Неявный вызов активности

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

И другой способ назвать неявное намерение ниже:

Явный вызов активности

Вы делаете вызов, который указывает, какой именно класс активности:

Надеюсь, что эта помощь поможет вам понять больше о явном и неявном вызове активности в android.

Вы можете получить более подробную информацию об Android Intent здесь

  1. Явные намерения используются для вызова определенного компонента. Когда вы знаете, какой компонент вы хотите запустить, и вы не хотите предоставлять пользователю свободный контроль над тем, какой компонент использовать. Например, у вас есть приложение, которое имеет 2 действия. Действие A и активность B. Вы хотите запустить активность B из действия A. В этом случае вы определяете явное намерение таргетинга activityB, а затем используете его для прямого вызова.
  2. Неявные намерения используются, когда у вас есть представление о том, что вы хотите сделать, но вы не знаете, какой компонент должен быть запущен. Или, если вы хотите дать пользователю возможность выбирать между списком используемых компонентов. Если эти намерения отправляются в систему Android, он ищет все компоненты, зарегистрированные для конкретного действия и типа данных. Если найден только один компонент, Android запускает компонент напрямую. Например, у вас есть приложение, которое использует камеру для съемки фотографий. Одной из особенностей вашего приложения является то, что вы предоставляете пользователю возможность отправлять фотографии, которые он сделал. Вы не знаете, какое приложение у пользователя может отправлять фотографии, и вы также хотите дать пользователю возможность выбрать, какое внешнее приложение использовать, если у него более одного. В этом случае вы не будете использовать явное намерение. Вместо этого вы должны использовать неявное намерение, действие которого установлено на ACTION_SEND, а его данные добавлены к URI фотографии.

Явное намерение всегда передается его цели, независимо от того, что она содержит; Фильтр не проконсультируется. Но неявное намерение доставляется компоненту только в том случае, если он может проходить через один из фильтров компонента

См. Резолюцию о намерениях здесь

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

Существует два типа намерений:

Явное намерение:

При создании объекта Intent, когда мы явно указываем и передаем имя целевого компонента непосредственно в намерении , это явное намерение.

Неявное намерение:

В этом случае мы делегируем задачу оценки зарегистрированных компонентов (регистрация обычно выполняется с использованием фильтров намерений, которые мы рассмотрим позже) для Android на основе данных о намерениях и предполагаемого действия (например, отправить электронное письмо, захватить фотографию, местоположение контактов На карте и т. Д.), Которые мы проходим. Таким образом, Android автоматически активирует компонент из того же приложения или другого приложения, которое может обрабатывать сообщение / задание намерения. Идея в этом случае состоит в том, что, скажем, нам нужно привязать место на карте, потому что нам не нужно кодировать нашу собственную деятельность, чтобы справиться с этим. Вместо этого просто передайте данные о местоположении в приложение, такое как карты Google, которые могут выполнять работу от имени нашего приложения.

Явный объект Intent будет конкретно ссылаться на компонент приложения Android для запуска, используя компонент приложения (например, «Активность» или «Сервис») и тип компонента. Обычно вам нужно использовать явный объект Intent для запуска компонента в вашем собственном приложении. Это связано с тем, что вы по сути знаете имя класса для подкласса Activity или подкласса Service, который вы хотите запустить, и таким образом вы можете использовать или жестко кодировать это имя компонента в Android Manifest и Java-коде.

Неявный объект Intent предоставляет описание компонента, который вы хотите запустить, но не указывает, какой из них (имя) использовать. Неявные Intent инфраструктуры более сложны для правильной настройки, чем явные намерения, потому что вам нужно настроить объект фильтра Intent, чтобы точно указать, на что должна обратить внимание Android, поскольку точное имя компонента (класса) не указано для запуска (загружено В память и обработку). Например, если вы хотите показать своему пользователю приложения местоположение на карте, вы можете использовать неявный объект Intent, чтобы спросить или запросить, чтобы другое приложение для Android с поддержкой карт показывало вашему пользователю приложения конкретное местоположение на карте, которое ваше приложение Ссылается. Неявные намерения позволяют приложениям Android работать вместе! Важно отметить, что каждый пользователь Android будет устанавливать разные приложения, поэтому на разных устройствах Android неизменно будут отображаться различные комбинации установленных приложений для Android. Это приводит к выбору всплывающих диалоговых окон. Хорошим примером этого является, когда вы нажимаете URL-адрес, а неявный Intent отключается, чтобы найти приложения, которые имеют API-интерфейс WebKit (браузер API). В диалоговом окне отображается внутренний браузер; Chrome, Firefox, Opera или других браузеров, установленных на этом устройстве. Это то, что подразумеваемые объекты Intent должны использоваться для: предоставления пользователям возможности контролировать, какие приложения используются с вашими приложениями. Давайте посмотрим на объекты IntentFilter next, чтобы лучше понять, как работают неявные объекты Intent, поскольку для оптимальной работы они нуждаются в хороших определениях IntentFilter.

Знакомство с Andro > 18/02/2020 javadevbloger Android

В нашем последнем уроке по Andro >

Что такое Intent в Android?

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

Типы Android Intent

  • Явное намерение (Explicit intent) явно определяет компонент по имени. Чаще всего в наших приложениях мы будем использовать явное намерение для запуска какого-то компонента. Суть Explicit intent в том, что вы знаете имя класса Activity или Service (сервиса), который нужно запустить. При использовании явного намерения система немедленно запускает компонент приложения, указанный в объекте Intent .
  • Неявное намерения (Implicit intent) не определяет конкретный компонент, а просто заявляет о некотором действии, позволяя компонентам других приложений его обработать. При создании неявного намерения Android система находит все возможные компоненты, которые могут обрабатывать заявленное действие, и предлагает выбрать одно из найденного списка.

Как использовать Android Intent для запуска Activity?

Чтобы создать объект Intent и запустить с помощью него Activity , нужно в параметрах передать объект-Activity класса, который вызывает и имя Activity, которое нужно запустить:

В чем разница между Явным и неявным вызовом активности в android?

В чем разница между явным и неявным вызовом активности в android? Если вы объясните ответ простым примером, это будет хорошо.

неявный вызов активности

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

И другой способ вызвать неявное намерение ниже:

Явный вызов активности

Вы делаете звонок, который точно указывает, какой класс деятельности:

Надеюсь, что это поможет вам понять больше о явном и неявном вызове активности в Android.

Вы можете получить более подробную информацию об Android Intent здесь

  • Явные намерения используются для вызова определенного компонента. Когда вы знаете, какой компонент вы хотите запустить, и вы не хотите предоставлять пользователю свободный контроль над тем, какой компонент использовать. Например, у вас есть приложение, которое имеет 2 действия. Действие A и активность B. Вы хотите запустить активность B из действия A. В этом случае вы определяете явное намерение таргетинга activityB, а затем используете его для прямого вызова.
  • Неявные намерения используются, когда у вас есть представление о том, что вы хотите сделать, но вы не знаете, какой компонент должен быть запущен. Или, если вы хотите дать пользователю возможность выбирать между списком используемых компонентов. Если эти намерения отправляются в систему Android, он ищет все компоненты, зарегистрированные для конкретного действия и типа данных. Если найден только один компонент, Android запускает компонент напрямую. Например, у вас есть приложение, которое использует камеру для съемки фотографий. Одна из особенностей вашего приложения заключается в том, что вы предоставляете пользователю возможность отправлять фотографии, которые он сделал. Вы не знаете, какое приложение у пользователя может отправлять фотографии, и вы также хотите дать пользователю возможность выбрать, какое внешнее приложение использовать, если у него более одного. В этом случае вы не будете использовать явное намерение. Вместо этого вы должны использовать неявное намерение, которое имеет действие, установленное в ACTION_SEND, и его данные добавлены к URI фотографии.

Явное намерение всегда передается его цели, независимо от того, что она содержит; фильтр не проконсультируется. Но неявное намерение доставляется компоненту только в том случае, если он может проходить через один из фильтров компонентов.

См. разрешение на выполнение здесь

Явные намерения (действия) относятся к определенному классу и, в общем, доступны только вашим пакетам. Неявные намерения относятся к фильтрам намерений, в которых приложения публично объявляют, что могут обрабатывать определенные типы данных или могут предоставлять конкретные услуги, например. Отправить письмо. При неявных намерениях пользователи выбирают, какую активность (как правило, пакет) использовать для обработки намерения или если установлен обработчик по умолчанию, он запускается.

Существует два типа намерений:

Явное намерение:

При создании объекта Intent, когда мы явно указываем и передаем имя целевого компонента непосредственно в намерении, его явное намерение.

Неявное намерение:

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

Когда использовать что?

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

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

Пример: воспроизведение музыки

Как решает ОС?

Когда есть неявный вызов с намерением, ОС выполняет действие и затем сопоставляет его со всеми фильтрами намерений всех зарегистрированных действий всех приложений, использующих PackageManager, а затем заполняет результат в виде списка. Это называется намеренным разрешением
Таким образом, существует вероятность того, что на вашем устройстве нет приложения, которое могло бы обработать ваш запрос. В этом случае вы получите исключение NullPointer.

Таким образом, более безопасный способ вызвать неявное намерение было бы это

Свой интернет-провайдер или как создать своего мини интернет-провайдера

Привет Пикабу! С Вами Миша, это мой первый пост на Пикабу. Я хочу рассказать, как создать своего интернет-провайдера для друзей. Итак, начнём.

Что Вам понадобится:
1. 1 или 2 маршрутизатора (если 1 — то Ваш будет для выхода в Интернет и для коннекта клиентов, если 2 — можно использовать 1 для себя, второй для клиентов. )
2. Высокоскоростной интернет (желательно не менее 10 мбит, но безлимита от МТС на 4 мбита думаю хватит)
3. Безлимитный интернет.
вот про моего провайдера — интернет безлимит, 100 мбит. Этого хватит вполне.
Кроме того на роутере для Ваших Клиентов желательно чтобы там сзади было побольше разъёмов. (4 мало, можно например даже большой маршрутизатор — на 16 или 32 разъема для клиентов)
4. Если пользователя нужны входящие соединения из интернета, можно сделать статический айпи, и включить UPnP во ВСЕХ ПРОМЕЖУТОЧНЫХ МАРШРУТИЗАТОРАХ.
5. ООЧЕНЬ длинный Ethernet-кабель, если у Вас два маршрутизатора, также возьмите короткий, пригодится) думаю если Вы хотите для одноклассников, у которых забрали инет, но Вы живёте рядом, то думаю хватит на 500 м, можно и подлиннее, например на 1 км, а можно и на 100 км, если далеко, но не знаю, где на 100 км продаются, а ещё можно купить промежуточные маршрутизаторы и несколько длинных проводов :)
6. Собственно, сами клиенты, на примере вымышленных двоечников, у которых родители забрали интернет :D предположим 2 двоечника, у обоих инет родители забрали, отключили вайфай или там допустим позвонили оператору сказали отключите инет, и мобильный, а затемсидят по своему мобильному инету, но предположим родители не раздают, а у них остался вайфай роутер БЕЗ ИНТЕРНЕТА.
Итак начнем.

Предположим, что у Вас 2 роутера. Первый роутер задаёт вайфай по квартире, второй — сервер Вашего провайдера. Назовем их А и Б

Берём роутер А и Роутер Б и Короткий Кабель. На Роутере А находим сзади много ethernet слотов, где написано ethernet, lan или clients, и подсоединяем в один из этих слотов Короткий Кабель. Другую часть кабеля подсоединяем в роутер Б в слот Internet или Wan. Готово, теперь роутер Б может раздавать инетрнет, за счет роутера Б.

Тоже самое делаем с роутерами Клиентов. Также если у Клиента Двоечника нету роутера, но есть комп без интернета, можно также напрямую их подключить. НО для этого необходимо проложить кабель. С этим могут возникнуть сложности. ЕСли Вы жиавете в соседних домах, попробуйте через окно проложить, если в соседней квартире, то попробуйте просверлить дырочку между Вашей квартирой и туда просунуть провод, скажите Двоечнику, что надо делать — этот провод засунуть либо в роутер в разъем где написено инетрнет или ван или напрямую к ПК в разъем как на роутере. P.S.: в некоторых квартирах, например если на Вашем этаже или джае в левой-правой части, есть так называемые, обыяно где-то в углу спрятаны — место где счетчики электричества. Если это есть прямо в квартирах, можно проложить прямо через них. Однако, если у двоечника ловит Ваш Вайфай, то проще сказать ему пароль. Готово, здесь основная сложность — прокладка кабелей.

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

Цукерберг рекомендует:  Языки - Западный сектор
Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих