Start custom activity android

Qt Documentation

Contents

Demonstrates working with custom Android activities.

This example demonstrates how to create an Android Activity and run it from your Qt application. The activity is composed of a Java class and an Android XML layout which is started from the main app. The activity can send back data after finishing which can be used in QML.

When you click the «Start custom Android activity» button, the activity is started, and the activity has a text view and a button to exit. The activity can either use the button or the back gesture to go back.

Running the Example

To run the example from Qt Creator, open the Welcome mode and select the example from Examples. For more information, visit Building and Running an Example.

Create Activity Class

Define an Android class called CustomActivity in the CustomActivity.java file as follows:

The Activity’s layout is defined at customactivity/android/res/layout/second_activity.xml.

To use this Activity, it must be defined in the AndroidManifest.xml file as follows:

Note: To use any native JNI calls, you must extend QtActivity instead of Activity .

Start the Activity

To start an Activity from Qt, you need to create an intent using QAndroidIntent, then call QtAndroid::startActivity providing the intent, a custom request code, and a callback function. The latter is called after the activity has finished. You can start the activity as follows:

Then, define the callback function that is called directly after the activity is done:

Note: You can first check that the requestCode and resultCode are correct.

To connect C++ with QML, add an instance of the C++ class that is handling the JNI logic as a QML property in the main.cpp file:

Then, add a Connections element to watch for messages from C++ in the main.qml file:

And set the onClicked for the «Start custom Android activity» button to:

В© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

Источник

[Android]Start Activity by Custom URL Scheme

If you want start activity, you write code like this.

And If you want launch url page, you will pass Uri with Intent.ACTION_VIEW.

If you use many browser in your phone, android will show select browser view for url load.
This select view is not only url also any other duplication action.

How you can see this select view?

Because that applications use same custom scheme (like ‘http://’, ‘xxx://’)

Let’s see example.
This is notification view about user’s action.
(Look like facebook or instagram’s notification view)

If you click item of list, we will move to activity.
Post’s row id is 10 and Activity name is ‘Activity_Post_Detail’.
Then you can write code like this.
Make new intent instance and pass String extra.

But If you use ‘Custom URL’, you can write code like this.
(Look like load url page)

This way don’t need Activity name. (need only url path)
Furthermore you can launch activity at your browser

Custom URL Scheme

1. Declare host / scheme at your activity (AndroidManifest.xml)

In this example, schme is selphone and host is post_detail

(Custom url will selphone://post_detail)

Now If you load ‘selphone://post_detail?…’ url, this activity will launch.

2. If you want to pass parameter to Activity, pass by query string

If you want pass post_id ( id: 10), you can add query string end of url.
“selphone://post_detail?post_id=10”

3. In your Activity, get your parameter at query string

Check intent action, and get query parameter from intent data.

Do it your self custom url activity for your application
If you want to know more detail infomation, check this page Android Intent Fileters

Источник

Полный список

В этом уроке мы:

— создадим и вызовем второе Activity в приложении

Урок был обновлен 12.06.2017

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

Application/Library name: TwoActivity
Module name: p0211twoactivity
Package name: ru.startandroid.p0211twoactivity

Откроем activity_main.xml и создадим такой экран:

На экране одна кнопка, по нажатию которой будем вызывать второй экран.

Открываем MainActivity.java и пишем код:

Мы определили кнопку btnActTwo и присвоили ей Activity в качестве обработчика. Реализация метода onClick для кнопки пока заполнена частично — определяем, какая кнопка была нажата. Чуть позже здесь мы будем вызывать второй экран. Но сначала этот второй экран надо создать.

Если помните, при создании проекта у нас по умолчанию создается Activity.

От нас требуется только указать имя этого Activity – обычно мы пишем здесь MainActivity. Давайте разбираться, что при этом происходит.

Мы уже знаем, что создается одноименный класс MainActivity.java – который отвечает за поведение Activity. Но, кроме этого, Activity «регистрируется» в системе с помощью манифест-файла — AndroidManifest.xml.

Давайте откроем этот файл:

Нас интересует тег application. В нем мы видим тег activity с атрибутом name = MainActivity. В activity находится тег intent-filter с определенными параметрами. Пока мы не знаем что это и зачем, сейчас нам это не нужно. Забегая вперед, скажу, что android.intent.action.MAIN показывает системе, что Activity является основной и будет первой отображаться при запуске приложения. А android.intent.category.LAUNCHER означает, что приложение будет отображено в общем списке приложений Android.

Т.е. этот манифест-файл — это что-то типа конфигурации. В нем мы можем указать различные параметры отображения и запуска Activity или целого приложения. Если в этом файле не будет информации об Activity, которое вы хотите запустить в приложении, то вы получите ошибку.

Android Studio при создании модуля создала MainActivity и поместила в манифест данные о нем. Если мы надумаем сами создать новое Activity, то студия также предоставит нам визард, который автоматически добавит создаваемое Activity в манифест.

Давайте создадим новое Activity

Жмем правой кнопкой на package ru.startandroid.p0211twoactivity в папке проекта и выбираем New -> Activity -> Empty Activity

В появившемся окне вводим имя класса – ActivityTwo, и layout – activity_two.

Класс ActivityTwo создан.

В setContentView сразу указан layout-файл activty_two.

Он был создан визардом

Откройте activty_two.xml и заполните следующим кодом:

Экран будет отображать TextView с текстом «This is Activity Two».

Сохраните все. Класс ActivityTwo готов, при отображении он выведет на экран то, что мы настроили в layout-файле two.xml.

Давайте снова заглянем в файл манифеста

Появился тег activity с атрибутом name = .ActivityTwo. Этот тег совершенно пустой, без каких либо параметров и настроек. Но даже пустой, он необходим здесь.

Нам осталось вернуться в MainActivity.java и довершить реализацию метода onClick (нажатие кнопки), а именно — прописать вызов ActivityTwo. Открываем MainActivity.java и добавляем строки:

(добавляете только строки 2 и 3)

Обновите импорт, сохраните все и можем всю эту конструкцию запускать. При запуске появляется MainActivity

Нажимаем на кнопку и переходим на ActivityTwo

Код вызова Activity пока не объясняю и теорией не гружу, урок и так получился сложным. Получилось много текста и скриншотов, но на самом деле процедура минутная. Поначалу, возможно, будет непонятно, но постепенно втянемся. Создадим штук 5-6 новых Activity в разных проектах и тема уляжется в голове.

Пока попробуйте несколько раз пройти мысленно эту цепочку действий и усвоить, что для создания Activity необходимо создать класс (который наследует android.app.Activity) и создать соответствующую запись в манифест-файле.

На следующем уроке:

— разбираемся в коде урока 21
— теория по Intent и Intent Filter (не пропустите, тема очень важная)
— немного о Context

Присоединяйтесь к нам в Telegram:

— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Источник

Разбираемся с launchMode Android Activity: standard, singleTop, singleTask и singleInstance

Activity — это одна из самых ярких концепций в Android (самой популярной мобильной операционной системе с хорошо продуманной архитектурой управления памятью, которая отлично реализует многозадачность).

Так или иначе, с запуском Activity на экран не все так однозначно. Способ, которым оно было запущено, также важен. Нюансов в этой теме очень много. Одним из действительно важных является launchMode, о котором мы и поговорим в этой статье.

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

Вот почему важно указывать, нужно ли создавать новое Activity или использовать существующее, иначе это может привести к плохому UX или сбоям. Благодаря разработчикам ядра Android, это легко сделать с помощью launchMode, который был специально для этого разработан.

Определение launchMode

По сути, мы можем определить launchMode напрямую в качестве атрибута тега activity> в AndroidManifest.xml :

Доступно 4 типа launchMode. Давайте рассмотрим их по очереди.

Это режим «по умолчанию».

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

Поведение на пре-Lollipop Android

Этот вид Activity будет создан и помещен в верх стека в той же задаче, которая и отправила Intent.

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

А это то, что вы увидите в диспетчере задач. (Может показаться немного странным)

Если мы переключим приложение на другую задачу, а затем переключимся обратно в Галерею, мы все равно увидим, что стандартный launchMode помещается поверх задачи Галереи. В результате, если нам нужно что-то сделать в Галерее, мы должны сначала закончить нашу работу в этом дополнительном Activity.

Поведение на Lollipop Android

Если эти Activity относятся к одному и тому же приложению, поведение будет таким же, как и в пре-Lollipop реализации — размещение в стеке поверх задачи.

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

Это то, что вы увидите в диспетчере задач.

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

Примером такого вида Activity является Compose Email Activity (составление письма) или Social Network’s Status Posting Activity (обновление статуса в соцсети). Если у вас на уме Activity, которое отдельно обрабатывает каждый Intent, то вы думаете именно о standard Activity.

singleTop

Следующий режим — singleTop. Он ведет себя почти так же, как и standard, что означает, что экземпляров singleTop Activity можно создать столько, сколько мы захотим. Единственное отличие состоит в том, что если уже есть экземпляр Activity с таким же типом наверху стека в вызывающей задаче, не будет создано никакого нового Activity, вместо этого Intent будет отправлен существующему экземпляру Activity через метод onNewIntent() .

В режиме singleTop вы должны предусмотреть обработку входящего Intent в onCreate() и onNewIntent() , чтобы он работал во всех случаях.

Пример использования этого режима — функция поиска. Давайте подумаем о создании окна поиска, которое направляет вас к SearchActivity, чтобы увидеть результаты поиска. Для лучшего UX обычно мы всегда помещаем окно поиска на страницу результатов поиска, чтобы позволить пользователю выполнить следующий поиск, не возвращаясь назад.

А теперь представьте, что если мы всегда запускаем новое SearchActivity, чтобы обслуживать новый результат поиска, то мы получим 10 новых Activity для 10 итераций поиска. Было бы очень странно возвращаться назад, так как вам нужно было бы нажимать назад 10 раз, чтобы пройти через все результаты поиска, чтобы вернуться к корневой Activity.

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

В любом случае singleTop работает в той же задаче, что и вызывающая сторона. Если вы ожидаете, что Intent будет отправлен в существующее Activity, помещенное поверх любой другой задачи, я должен вас разочаровать, сказав, что там это так уже не работает. В случае, если Intent отправлен из другого приложения в singleTop Activity, новое Activity будет запущено в том же аспекте, что и для standart launchMode (пре-Lollipop: помещено поверх вызывающей задачи, Lollipop: будет создана новая задача).

singleTask

Этот режим сильно отличается от standart и singleTop. Activity с singleTask launchMode разрешено иметь только один экземпляр в системе (аля синглтон). Если в системе уже существует экземпляр Activity, вся задача, удерживающая экземпляр, будет перемещен наверх, а Intent будет предоставлен через метод onNewIntent() . В противном случае будет создано новое Activity и помещено в соответствующую задачу.

Работая в одном приложении

Если в системе еще не было экземпляра singleTask Activity, будет создан новый, и он будет просто помещен вверх стека в той же задаче.

Но если он существует, все Activity, расположенные над этим singleTask Activity, автоматически будут жестоко уничтожены надлежащим образом (жизненный цикл закончен), чтобы отобразить на вершине стека нужное нам Activity. В то же время Intent будет отправлен в singleTask Activity через прекрасный метод onNewIntent() .

Это не имеет смысла с точки зрения пользовательского опыта, но оно он разработано именно таким образом…

Вы можете заметить один нюанс, который упоминается в документации:

Система создает новую задачу и инстанцирует экземпляр activity в корне новой задачи.

Но на практике похоже, что это работает не так, как описано. SingleTask Activity по-прежнему помещается наверх стека Activity задачи, как видно из результата команды dumpsys activity .

Если вы хотите, чтобы singleTask Activity вело себя так, как описано в документе: создайте новую задачу и поместите Activity в качестве корневого Activity. Вам нужно определить атрибут taskAffinity для singleTask Activity следующим образом.

Таким будет результат, когда мы попытаемся запустить SingleTaskActivity .

Ваша задача решить, использовать taskAffinity или нет в зависимости от желаемого поведения Activity.

Взаимодействуя с другим приложением

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

Если не существует задачи, которая бы являлась владельцем вызывающей singleTask Activity, вместо нее будет выведено наверх новое Activity.

В случае, если в какой-либо задаче существует экземпляр Activity, вся задача будет перемещена вверх, и для каждого отдельного Activity, расположенного над singleTask Activity, будет завершен жизненный цикл. Если нажата кнопка «Назад», пользователь должен пройти через Activity в стеке, прежде чем вернуться к вызывающей задаче.

Примером использования этого режима является любое Entry Point Activity, например, страница «Входящие» почтового клиента или таймлайн соцсети. Эти Activity не предполагают более чем одного экземпляра, поэтому singleTask отлично справится со своей задачей. В любом случае вы должны использовать этот режим с умом, так как в этом режиме Activity могут быть уничтожены без подтверждения пользователя, как описано выше.

singleInstance

Этот режим очень похож на singleTask, где в системе мог существовать только один экземпляр Activity. Разница в том, что задача, которая располагает этим Activity, может иметь только одно Activity — то, у которого атрибут singleInstance. Если из этого вида Activity вызывается другое Activity, автоматически создается новое задание для размещения этого нового Activity. Аналогичным образом, если вызывается singleInstance Activity, будет создана новая задача для размещения этого Activity.

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

Вот что происходит, когда вызывается singleInstance Activity, в то время как в стеке уже существует какое-либо Activity.

А вот что мы видим в диспетчере задач.

Поскольку эта задача может иметь только одно Activity, мы больше не можем переключаться обратно на задачу № 1. Единственный способ сделать это — перезапустить приложение из лаунчера, но, как в итоге получится, singleInstance задача будет скрыта в фоновом режиме.

Во всяком случае, есть некоторые обходные пути для этой проблемы. Как и в случае с singleTask Activity, просто назначьте атрибут taskAffinity для singleInstance Activity, разрешающим существование нескольких задач в диспетчере задач.

Теперь картина имеет больше смысла.

Этот режим используется редко. Некоторые из вариантов использования на практике — это лаунчер-Activity или приложение, для которого вы на 100% уверены, что там должно быть только одно Activity. В любом случае, я предлагаю вам не использовать этот режим, если на то нет крайней необходимости.

Intent-флаги

Помимо назначения режима запуска непосредственно в AndroidManifest.xml , мы также можем регулировать поведение с помощью инструмента, называемого Intent-флагами, например:

запустит StandardActivity с условием singleTop launchMode.

Есть довольно много флагов, с которыми вы можете работать. Вы можете найти больше информации об этом здесь.

Источник