Красота из фрагментов. Как улучшить UI в Android c помощью класса Fragment
В этом уроке:
Рассмотрим взаимодействие между Activity и ее фрагментами
После размещения фрагмента, хотелось бы начать с ним взаимодействовать. Т.е. размещать View-компоненты и работать с ними, обращаться к фрагментам из Activity и наоборот. Попробуем это реализовать.
Для чистоты эксперимента будем работать с двумя фрагментами: статическим и динамическим.
Создадим проект:
Project name
: P1061_FragmentActivity
Build Target
: Android 4.1
Application name
: FragmentActivity
Package name
: ru.startandroid.develop.p1061fragmentactivity
Create Activity
: MainActivity
В strings.xml добавим строки:
Создаем layout и классы для двух фрагментов.
fragment1.xml :
android:background ="#77ff0000"
android:orientation ="vertical" >
android:text ="@string/frag1_text" >
fragment2.xml :
android:layout_width ="match_parent"
android:layout_height ="match_parent"
android:background ="#7700ff00"
android:orientation ="vertical" >
android:layout_width ="wrap_content"
android:layout_height ="wrap_content"
android:text ="@string/frag2_text" >
Fragment1.java :
package
Import
android.app.Fragment;
import
android.os.Bundle;
import
android.util.Log;
import
android.view.LayoutInflater;
import
android.view.View;
import
import
android.widget.Button;
Public
View onCreateView
(
Bundle savedInstanceState
) {
;
button.setOnClickListener
(new
OnClickListener
() {
Log.d
(LOG_TAG,
"Button click in Fragment1"
)
;
}
})
;
Return
v;
}
}
У фрагмента нет привычного для нас метода findViewById для поиска компонентов с экрана. Поэтому вызываем этот метод для View , которое будет содержимым фрагмента. В методе onCreateView мы создаем View и сразу же находим в нем кнопку и ставим ей обработчик. Затем отдаем View системе.
Fragment2.java :
package ru.startandroid.develop.p1061fragmentactivity;
Import
android.app.Fragment;
import
android.os.Bundle;
import
android.util.Log;
import
android.view.LayoutInflater;
import
android.view.View;
import
android.view.View.OnClickListener;
import
android.view.ViewGroup;
import
android.widget.Button;
Final String LOG_TAG = "myLogs" ;
Public
View onCreateView
(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState
) {
Button button =
(Button
)
v.findViewById
(R.id.button
)
;
button.setOnClickListener
(new
OnClickListener
() {
public
void
onClick
(View v
) {
Log.d
(LOG_TAG,
"Button click in Fragment2"
)
;
}
})
;
Return
v;
}
}
Все аналогично Fragment1.
Настраиваем основное Activity.
main.xml :
xmlns:tools ="http://schemas.android.com/tools"
android:id ="@+id/LinearLayout1"
android:layout_width ="match_parent"
android:layout_height ="match_parent"
android:orientation ="vertical" >
android:name ="ru.startandroid.develop.p1061fragmentactivity.Fragment1"
android:layout_width ="match_parent"
android:layout_height ="wrap_content"
android:layout_weight ="1"
tools:layout ="@layout/fragment1" >
android:layout_width ="match_parent"
android:layout_height ="wrap_content"
android:layout_weight ="1" >
Кнопка, компонент fragment, в который помещен Fragment1, и контейнер FrameLayout, в который потом поместим Fragment2.
Обратите внимание на атрибут tools:layout . В нем указан layout-файл, и мы можем на этапе разработки видеть, как будет выглядеть статический фрагмент, когда приложение будет запущено.
Для этого надо нажать правой кнопкой на компоненте fragment, и через пункт Fragment Layout указать нужный layout.
MainActivity.java :
package ru.startandroid.develop.p1061fragmentactivity;
Import
android.app.Activity;
import
android.app.Fragment;
import
import
android.os.Bundle;
Public class MainActivity extends Activity {
@Override
;
()
.beginTransaction
()
;
ft.commit
()
;
}
}
Здесь мы просто добавляем Fragment2 в контейнер.
Все сохраняем, запускаем приложение.
Жмем кнопку Log в первом фрагменте и смотрим лог:
Button click in Fragment1
Жмем Log во втором фрагменте:
Button click in Fragment2
Все ок. Компоненты в фрагментах нашлись и обработчики среагировали на нажатия.
Атрибут onClick, который мы привыкли использовать для кнопки, здесь не прокатит. Указанный в этом атрибуте метод, будет вызван в Activity, а не в фрагменте.
Доступ к фрагменту из Activity
Разберемся, как получить доступ к фрагменту из Activity. Для этого у FragmentManager есть метод , который на вход принимает id компонента fragment (если фрагмент статический) или id контейнера (если динамический).
У нас в main.xml есть кнопка btnFind , вызывающая метод onClick при нажатии. Дорисуем в MainActivity.java метод onClick :
public
void
onClick
(View v
) {
((TextView
)
frag1.getView
()
.findViewById
(R.id.textView
))
.setText
("Access to Fragment 1 from Activity"
)
;
Fragment frag2 = getFragmentManager
()
.findFragmentById
(R.id.fragment2
)
;
((TextView
)
frag2.getView
()
.findViewById
(R.id.textView
))
.setText
("Access to Fragment 2 from Activity"
)
;
}
Используем метод findFragmentById . В первом случае на вход передаем id компонента fragment , т.к. Fragment1 у нас размещен именно так. При поиске Fragment2 указываем id контейнера , в который этот фрагмент был помещен. В результате метод findFragmentById возвращает нам объект Fragment.
Все сохраняем, запускаем. Жмем кнопку Find
Тексты в фрагментах обновились. Тем самым из Activity мы достучались до фрагментов и их компонентов.
На всякий случай проговорю одну вещь из разряда «Спасибо кэп!». Если посмотреть на код MainActivity, то можно заметить, что frag2 в методе onCreate и frag2 в методе onClick по сути работают с одним объектом – Fragment2. Это так и есть. Оба frag2 в итоге будут ссылаться на один объект. Так что, если вы динамически добавили фрагмент, то у вас уже есть ссылка на него, и искать его через findViewById вам уже не надо.
Доступ к Activity из фрагмента
Теперь попробуем из фрагмента поработать с Activity. Для этого фрагмент имеет метод .
Давайте перепишем обработчик кнопки в первом фрагменте. Будем менять текст кнопки btnFind .
Fragment1.java :
package ru.startandroid.develop.p1061fragmentactivity;
Import
android.app.Fragment;
import
android.os.Bundle;
import
android.view.LayoutInflater;
import
android.view.View;
import
android.view.View.OnClickListener;
import
android.view.ViewGroup;
import
android.widget.Button;
Public class Fragment1 extends Fragment {
Public
View onCreateView
(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState
) {
View v = inflater.inflate
(R.layout.fragment1,
null
)
;
Button button =
(Button
)
v.findViewById
(R.id.button
)
;
button.setOnClickListener
(new
OnClickListener
() {
public
void
onClick
(View v
) {
((Button
)
getActivity
()
.findViewById
(R.id.btnFind
))
.setText
("Access from Fragment1"
)
;
}
})
;
Return
v;
}
}
Получаем Activity методом getActivity, ищем в нем кнопку и меняем текст.
Сохраняем, запускаем. Жмем кнопку в первом фрагменте:
Работает. Из фрагмента мы поменяли компонент Activity.
Обработка в Activity события из фрагмента
Рассмотрим , который описан в хелпе: фрагмент генерирует некое событие и ставит Activity обработчиком.
Например, в Activity есть два фрагмента. Первый – список заголовков статей. Второй – отображает содержимое статьи, выбранной в первом. Мы нажимаем на заголовок статьи в первом фрагменте и получаем содержимое во втором. В этом случае, цель первого фрагмента – передать в Activity информацию о том, что выбран заголовок. А Activity дальше уже сама решает, что делать с этой информацией. Если, например, приложение запущено на планшете в горизонтальной ориентации, то можно отобразить содержимое статьи во втором фрагменте. Если же приложение запущено на смартфоне, то экран маловат для двух фрагментов и надо запускать отдельное Activity со вторым фрагментом, чтобы отобразить статью.
Фишка тут в том, что первому фрагменту неинтересны все эти Activity. Фрагмент – обособленный модуль. Его дело - проинформировать, что выбрана статья такая-то. Ему не надо искать второй фрагмент и работать с ним – это дело Activity.
Тут немного отвлекусь на небольшое лирическое отступление. Модульность, вообще, - очень важная и полезная штука. И ее надо использовать для универсальности, удобности и легкости в понимании работы своих приложений. Но уникальных рецептов, как правильно все организовать, конечно, нет. Каждый делает по-своему. Именно по этим причинам я в своих уроках даю чисто технические вещи про отдельные компоненты и не рассказываю, как организовывать и писать целое приложение . Иначе, форум бы уже ломился от сообщений, что я все делаю не так и надо по-другому, и каждый бы излагал свое видение. И была бы куча споров, где одна сторона говорит, что крокодил зеленый, а другая сторона говорит, что он нифига не зеленый, а длинный))
Вернемся к уроку. Фрагмент должен сообщить в Activity, что выбрана статья. Для этого он будет вызывать некий метод в Activity. И как нам сообщает хелп, лучший способ тут – это использовать интерфейс, который мы опишем в фрагменте и который затем будет реализован в Activity. Схема известная и распространенная. Давайте реализуем. В нашем приложении никаких статей нет, поэтому будем просто передавать произвольную строку из второго фрагмента в Activity. А Activity уже будет отображать эту строку в первом фрагменте.
Перепишем Fragment2.java :
package ru.startandroid.develop.p1061fragmentactivity;
Import
android.app.Activity;
import
android.app.Fragment;
import
android.os.Bundle;
import
android.view.LayoutInflater;
import
android.view.View;
import
android.view.View.OnClickListener;
import
android.view.ViewGroup;
import
android.widget.Button;
Public class Fragment2 extends Fragment {
Public interface
onSomeEventListener
{
public
void
someEvent
(String s
)
;
}
onSomeEventListener someEventListener;
@Override
public
void
onAttach
(Activity activity
) {
super
.onAttach
(activity
)
;
try
{
someEventListener =
(onSomeEventListener
)
activity;
}
catch
(ClassCastException e
) {
throw new
ClassCastException
(activity.toString
()
+
" must implement onSomeEventListener"
)
;
}
}
Final String LOG_TAG = "myLogs" ;
Public
View onCreateView
(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState
) {
View v = inflater.inflate
(R.layout.fragment2,
null
)
;
Button button =
(Button
)
v.findViewById
(R.id.button
)
;
button.setOnClickListener
(new
OnClickListener
() {
public
void
onClick
(View v
) {
someEventListener.someEvent
("Test text to Fragment1"
)
;
}
})
;
Return
v;
}
}
Описываем интерфейс onSomeEventListener . В нем метод someEvent , который на вход получает строку. Этот интерфейс будет реализовывать Activity.
В методе onAttach мы на вход получаем Activity, к которому присоединен фрагмент. Мы пытаемся привести это Activity к типу интерфейса onSomeEventListener, чтобы можно было вызывать метод someEvent и передать туда строку. Теперь someEventListener ссылается на Activity.
Теперь меняем Activity.
MainActivity.java :
package ru.startandroid.develop.p1061fragmentactivity;
Import
ru.startandroid.develop.p1061fragmentactivity.Fragment2.onSomeEventListener;
import
android.app.Activity;
import
android.app.Fragment;
import
android.app.FragmentTransaction;
import
android.os.Bundle;
import
android.widget.TextView;
Public class MainActivity extends Activity implements onSomeEventListener {
@Override
public
void
onCreate
(Bundle savedInstanceState
) {
super
.onCreate
(savedInstanceState
)
;
setContentView
(R.layout.main
)
;
Fragment frag2 =
new
Fragment2
()
;
FragmentTransaction ft = getFragmentManager
()
.beginTransaction
()
;
ft.add
(R.id.fragment2, frag2
)
;
ft.commit
()
;
}
@Override
public
void
someEvent
(String s
) {
Fragment frag1 = getFragmentManager
()
.findFragmentById
(R.id.fragment1
)
;
((TextView
)
frag1.getView
()
.findViewById
(R.id.textView
))
.setText
("Text from Fragment 2:"
+ s
)
;
}
}
Дописываем интерфейс onSomeEventListener к описанию класса.
onCreate без изменений.
Реализуем метод someEvent . Просто ищем первый фрагмент и вставляем туда текст.
Все сохраняем и запускаем. Жмем кнопку во втором фрагменте:
Второй фрагмент передал через интерфейс строку в Activity, а оно нашло первый фрагмент и отобразило там эту строку.
На следующем уроке:
Размещаем элементы в ActionBar
В этом уроке, я хочу объяснить, что такое Fragment и почему его нужно использовать. Мы рассмотрим немного теории, а также практический пример применения Fragments.
Представьте себе пазл, который вы можете сложить и получить общий вид картинки, именно так можно представить Fragment . Или же если вы работали разработкой сайтов, а именно PHP то вам знакома возможность подключать общие части сайта например меню как отдельного блока с помощью include .
Шаг 0. Теория
Так как определение не совсем понятно, я решил сказать своими словами его.
Fragment (Фрагмент) – по сути это подобие Activity, которое мы можем подключать в разные части приложения. Но одно Activity может содержать несколько fragment.
Фрагменты появились в API 11 (Android 3.0) для поддержки на более старых версиях был доработан Android Support library.
Также важно понимать, что фрагменты – это не замена активности, они не могут существовать сами по себе, а только вместе с Activity. Поэтому в AndroidManifest регистрировать Fragments не нужно.
Шаг 1. Создаем проект
Давайте создадим простой проект, пока без использования Fragment-ов. Создаем Android Gradle Project:
Теперь создадим Activity в пакете com.myfragmentexam.app назовем его MainActivity :
Package com.myfragmentexam.app; import android.app.Activity; import android.os.Bundle; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main_layout); } }
Для этого activity нам нужно создать layout, создаем в res/layout новый layout и называем его main_layout :
Как видите в 33-й строке мы указываем на ресурс изображения, для этого вам нужно в res/drawable добавить следующее изображение:
Последним шагом нужно зарегистрировать activity MainActivity в AndroidManifest .xml :
Начиная с 9-й строки мы регистрируем Activity в контексте.
Теперь запустим. Мы должны увидеть следующее:
Пока это простое приложение, которое не выполняет никакой логики и не имеет фрагментов.
Шаг 2. Делим на части
Особенность Fragment-ов в том, что вы можете разбить внешний вид на блоки и потом подключать их для отображения на разных устройствах по своему (смартфон /планшет ). Также мы получим возможность переиспользования блоков(Fragments ).
Первыйм делом вынесем кнопки в отдельный фрагмент, в res/layout создаем новый layout и называем его button_fragment :
Выглядеть это будет так:
Теперь вынесем CheckBox-сы в отдельный layout назовем его checkbox_fragment:
Выглядеть это будет так:
И вынесем картинку в layout назвав его image_fragment :
Выглядеть это будет так:
Шаг 3. Создаем Fragments
Мы поделили наш первоначальный вид на части, теперь давайте создадим на их основе фрагменты.
Посмотрите на структуру классов ниже и на её основе создайте пакет fragments и в нем классы классы ButtonFragment , CheckBoxFragment , ImageFragment.
Для того чтобы все эти классы стали фрагментами их нужно унаследовать от класса Fragment . Обратите внимание что класс фрагмент мы будем использовать не со стандартной библиотеки android .app , а с android .support .v4.app .
Причина этого то что фрагменты в вспомогательном пакете более лучше поддерживаются и если сравнивать со стандартным, то он не имеет тех багов, которые имеет стандартный пакет(android.app ).
В Activity мы подключали layout в методе onCreate() через метод setContentView() . Но в фрагментах метод onCreate() используется немного для других целей. Поэтому для подключения layout используется отдельный метод onCreateView() .
Давайте начнем с ButtonFragment :
Package com.myfragmentexam.app.fragments; import android.os.Bundle; import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import com.myfragmentexam.app.R; public class ButtonFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View viewHierarchy = inflater.inflate(R.layout.button_fragment, container, false); return viewHierarchy; } }
Теперь детальней рассмотрим что же мы тут делаем.
LayoutInflater – позволяет построить нужный макет, считывая информацию из указанного XML-файла.
Обратите внимание на то что 16-й строке в метод inflate() мы передаем 3 параметра разметку нашего фрагмента, контейнер, и значение (true |false ), которое указывает на возможность подключения фрагментов в Activity через контейнер. Мы указали false так как сами создаем блоки для фрагментов.
Теперь по аналогии создадим реализацию для фрагмента CheckBoxFragment :
Package com.myfragmentexam.app.fragments; import android.os.Bundle; import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import com.myfragmentexam.app.R; public class CheckBoxFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View viewHierarchy = inflater.inflate(R.layout.checkbox_fragment, container, false); return viewHierarchy; } }
И для последнего ImageFragment :
Package com.myfragmentexam.app.fragments; import android.os.Bundle; import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import com.myfragmentexam.app.R; public class ImageFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View viewHierarchy = inflater.inflate(R.layout.image_fragment, container, false); return viewHierarchy; } }
Шаг 4. Собираем все в кучу
Мы создали пачку фрагментов, но что с ними делать? Их мы теперь можем подключать в те места куда нам нужно. Для примера мы переделаем MainActivity и main_layout под фрагменты.
Для начало давайте модифицируем MainActivity:
Package com.myfragmentexam.app; import android.os.Bundle; import android.support.v4.app.FragmentActivity; public class MainActivity extends FragmentActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main_layout); } }
Обратите на строку 6, как видите мы наследуемся не просто от Activity, а от FragmentActivity это нужно делать когда вы используете Fragment с пакета android.support.v4.app.
Теперь модифицируем layout для нашего Activity, а именно main_layout :
Обратите внимание на выделенные строки, тут мы указываем какой фрагмент подключать.
Но теперь в Intellij IDEA режим Preview работает не корректно:
Для того чтобы это исправить нам нужно немного модифицировать main_layout :
На выделенных строках видно изменения, таким образом мы указали фрагментам на нашем layout какие layout они отображают.
И теперь режим Preview работает корректно:
После этого, можно запустить и проверить. Вы должны увидеть тоже что показано на Preview.
Шаг 5. Добавляем альбомный вид
Для этого создаем в res папке layout-land и копируем в в него все содержимое папки layout.
После этого немного изменим расположение фрагментов на main_layout. Обратите внимание, что мы будем менять расположение фрагментов, а не их компонентов, что довольно таки удобно.
Теперь запускаем и смотрим на результат:
Теперь у нас есть вид как для смартфонов так и для планшетов.
Последнее обновление: 06.03.2017
Организация приложения на основе нескольких activity не всегда может быть оптимальной. Мир ОС Android довольно сильно фрагментирован и состоит из многих устройств. И если для мобильных аппаратов с небольшими экранами взаимодействие между разными activity выглядит довольно неплохо, то на больших экранах - планшетах, телевизорах окна activity смотрелись бы не очень в силу большого размера экрана. Собственно поэтому и появилась концепция фрагментов.
Фрагмент существует в контексте activity и имеет свой жизненный цикл, вне activity обособлено он существовать не может. Каждая activity может иметь несколько фрагментов.
Для начала работы с фрагментами создадим новый проект с пустой MainActivity. И вначале создадим первый фрагмент.
Во-первых, фрагменты содержат те же элементы управления, что и activity. Поэтому создадим в папке res/layout новый файл fragment_content.xml :
Здесь определены кнопка и текстовое поле, которые будут составлять интерфейс фрагмента.
Теперь создадим сам класс фрагмента. Для этого добавим в одну папку с MainActivity новый класс. Для этого нажмем на папку правой кнопкой мыши и выберем в меню New -> Java Class . Назовем новый класс ContentFragment и определим у него следующее содержание:
Package com.example.eugene.fragmentapp; import android.view.View; import android.view.LayoutInflater; import android.view.ViewGroup; import android.os.Bundle; import android.support.v4.app.Fragment; import android.widget.Button; import android.widget.TextView; import java.util.Date; public class ContentFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_content, container, false); Button updateButton = (Button) view.findViewById(R.id.updateButton); final TextView updateBox = (TextView) view.findViewById(R.id.textBox); updateButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { String curDate = new Date().toString(); updateBox.setText(curDate); } }); return view; } }
Класс фрагмента должен наследоваться от класса Fragment .
Для создания визуального интерфейса фрагмент переопределяет родительский метод onCreateView() . Он принимает три параметра:
Объект LayoutInflater используется для установки ресурса разметки для создания интерфейса
Параметр ViewGroup container устанавливает контейнер интерфейса
Параметр Bundle savedInstanceState передает ранее сохраненное состояние
Для создания интерфейса применяется метод inflate() объекта LayoutInflater. Он получает ресурс разметки layout для данного фрагмента, контейнер, в который будет заключен интерфейс, и третий булевый параметр указывает, надо ли прикреплять разметку к контейнеру из второго параметра.
И как и в activity, здесь мы можем устанавливать обработчики дял элементов управления, обрабатывать их событий. В данном случае в текстовом поле выводится текущая дата.
Также стоит отметить, что в Android Studio есть специальный шаблон для добавления фрагмента. Для его использования также надо нажать на папку пакета классов правой кнопкой мыши и через выпадающее меню выбрать New -> Fragment -> Fragment(Blank) :
Данный шаблон сразу добавит в проект и класс фрагмента и связанный с ним класс разметки интерфейса.
И в конце надо добавить фрагмент в activity. Для этого изменим файл activity_main.xml , которая определяет интерфейс для MainActivity:
Каждый фрагмент задается с помощью элемента
Кроме фрагмента мы можем добавить в разметку activity_main.xml мы можем добавить другие элементы или фрагменты, но в данном случае ограничимся одним фрагментом.
Код класса MainActivity остается тем же, что и при создании проекта:
Package com.example.eugene.fragmentapp; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } }
Весь проект будет выглядеть следующим образом:
Если мы запустим приложение, то мы увидим фактически тот же самый интерфейс, который мы могли бы сделать и через activity, только в данном случае интерфейс будет определен во фрагменте:
Добавление фрагмента в коде
Кроме определения фрагмента в xaml-файле интерфейса мы можем добавить его динамически в activity.
Для этого изменим файл activity_main.xml :
И также изменим класс MainActivity :
Package com.example.eugene.fragmentapp; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (savedInstanceState == null) { getSupportFragmentManager().beginTransaction() .add(R.id.container, new ContentFragment()) .commit(); } } }
Метод getSupportFragmentManager() возвращает объект FragmentManager , который управляет фрагментами. Но в данном случае надо сделать уточнение. В данном коде используется фрагмент - наследник класса android.support.v4.app.Fragment . Но для создания фрагментов мы также можем использовать класс android.app.Fragment из API 11. В случае использования android.app.Fragment менеджер фрагментов вызывается с помощью метода getFragmentManager() .
Объект FragmentManager с помощью метода beginTransaction() создает объект FragmentTransaction.
FragmentTransaction выполняет два метода: add() и commit(). Метод add() добавляет фрагмент: add(R.id.container, new ContentFragment()) - первым аргументом передается ресурс разметки, в который надо добавить фрагмент. И метод commit() подтвержает и завершает операцию добавления.
Итоговый результат такого добавления фрагмента будет тем же, что и при явном определении фрагмента через элемент
Рисунок 2. Жизненный цикл фрагмента (во время выполнения операции)
Для создания фрагмента необходимо создать подкласс класса (или его существующего подкласса). Класс имеет код, во многом схожий с кодом . Он содержит методы обратного вызова, аналогичные методам операции, такие как , и . На практике, если требуется преобразовать существующее приложение Android так, чтобы в нем использовались фрагменты, достаточно просто переместить код из методов обратного вызова операции в соответствующие методы обратного вызова фрагмента.
Как правило, необходимо реализовать следующие методы жизненного цикла:
Система вызывает этот метод, когда создает фрагмент. В своей реализации разработчик должен инициализировать ключевые компоненты фрагмента, которые требуется сохранить, когда фрагмент находится в состоянии паузы или возобновлен после остановки. Система вызывает этот метод при первом отображении пользовательского интерфейса фрагмента на дисплее. Для прорисовки пользовательского интерфейса фрагмента следует возвратить из этого метода объект , который является корневым в макете фрагмента. Если фрагмент не имеет пользовательского интерфейса, можно возвратить null. Система вызывает этот метод как первое указание того, что пользователь покидает фрагмент (это не всегда означает уничтожение фрагмента). Обычно именно в этот момент необходимо фиксировать все изменения, которые должны быть сохранены за рамками текущего сеанса работы пользователя (поскольку пользователь может не вернуться назад).
Существует также ряд подклассов, которые, возможно, потребуется расширить вместо использования базового класса :
Отображение перемещаемого диалогового окна. Использование этого класса для создания диалогового окна является хорошей альтернативой вспомогательным методам диалогового окна в классе . Дело в том, что он дает возможность вставить диалоговое окно фрагмента в управляемый операцией стек переходов назад для фрагментов, что позволяет пользователю вернуться к закрытому фрагменту. Отображение списка элементов, управляемых адаптером (например, ), аналогично классу . Этот класс предоставляет несколько методов для управления списком представлений, например, метод обратного вызова для обработки нажатий. Отображение иерархии объектов в виде списка, аналогично классу . Этот класс полезен, когда в приложении создается операция «Настройки».
Добавление пользовательского интерфейса
Фрагмент обычно используется как часть пользовательского интерфейса операции, при этом он добавляет в операцию свой макет.
Чтобы создать макет для фрагмента, разработчик должен реализовать метод обратного вызова , который система Android вызывает, когда для фрагмента наступает время отобразить свой макет. Реализация этого метода должна возвращать объект , который является корневым в макете фрагмента.
Примечание. Если фрагмент является подклассом класса , реализация по умолчанию возвращает класс из метода , так что реализовывать его нет необходиомости.
Чтобы возвратить макет из метода , можно выполнить его раздувание из , определенного в XML-файле. Для этой цели метод предоставляет объект .
Например, код подкласса класса , загружающий макет из файла example_fragment.xml , может выглядеть так:
Public static class ExampleFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { // Inflate the layout for this fragment return inflater.inflate(R.layout.example_fragment, container, false); } }
Создание макета
В приведенном коде конструкция R.layout.example_fragment является ссылкой на ресурс макета по имени example_fragment.xml , хранящийся в ресурсах приложения. Подробные сведения о создании макета в XML см. в статье .
Пример операции, использующей фрагмент в качестве фонового потока, без пользовательского интерфейса, приведен в образце кода FragmentRetainInstance.java , входящем в число образцов в SDK (и доступном при помощи
Android SDK Manager). Путь к нему в системе -
Управление фрагментами
Для управления фрагментами в операции нужен класс . Чтобы получить его, следует вызвать метод из кода операции.
Ниже указаны действия, которые позволяет выполнить :
- получать фрагменты, имеющиеся в операции, с помощью метода (для фрагментов, предоставляющих пользовательский интерфейс в макете операции) или (как для фрагментов, имеющих пользовательский интерфейс, так и для фрагментов без него);
- снимать фрагменты со стека переходов назад методом (имитируя нажатие кнопки Назад пользователем);
- регистрировать процесс-слушатель изменений в стеке переходов назад при помощи метода .
Дополнительные сведения об этих и других методах приводятся в документации по классу .
Как было показано в предыдущем разделе, можно использовать класс для открытия , что позволяет выполнять транзакции с фрагментами, например, добавление и удаление.
Выполнение транзакций с фрагментами
Большим достоинством использования фрагментов в операции является возможность добавлять, удалять, заменять их и выполнять другие действия с ними в ответ на действия пользователя. Любой набор изменений, вносимых в операцию, называется транзакцией. Ее можно выполнить при помощи API-интерфейсов в . Каждую транзакцию можно сохранить в стеке переходов назад, которым управляет операция. Это позволит пользователю перемещаться назад по изменениям во фрагментах (аналогично перемещению назад по операциям).
Взаимодействие с операцией
public static class FragmentA extends ListFragment { OnArticleSelectedListener mListener; ... @Override public void onAttach(Activity activity) { super.onAttach(activity); try { mListener = (OnArticleSelectedListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " must implement OnArticleSelectedListener"); } } ... }Если операция не реализовала интерфейс, фрагмент генерирует исключение . В случае успеха элемент mListener будет содержать ссылку на реализацию интерфейса OnArticleSelectedListener в операции, чтобы фрагмент A мог использовать события совместно с операцией, вызывая методы, определенные интерфейсом OnArticleSelectedListener . Например, если фрагмент A является расширением класса , то всякий раз, когда пользователь нажимает элемент списка, система вызывает во фрагменте. Этот метод, в свою очередь, вызывает метод onArticleSelected() , чтобы использовать событие совместно с операцией:
Public static class FragmentA extends ListFragment { OnArticleSelectedListener mListener; ... @Override public void onListItemClick(ListView l, View v, int position, long id) { // Append the clicked item"s row ID with the content provider Uri Uri noteUri = ContentUris. (ArticleColumns.CONTENT_URI, id); // Send the event and Uri to the host activity mListener.onArticleSelected(noteUri); } ... }
Параметр id , передаваемый методу , - это идентификатор строки с выбранным элементом списка, который операция (или другой фрагмент) использует для получения статьи от объекта приложения.
Дополнительные сведения о работе с поставщиком контента приводятся в документе .
Добавление элементов в строку действий
Фрагменты могут добавлять пункты меню в операции (и, следовательно, в ), реализовав . Однако, чтобы этот метод мог принимать вызовы, необходимо вызывать во время выполнения метода , чтобы сообщить, что фрагмент намеревается добавить пункты в Меню вариантов (в противном случае фрагмент не примет вызов метода ).
Любые пункты, добавляемые фрагментом в Меню вариантов, присоединяются к уже существующим. Кроме того, фрагмент принимает обратные вызовы метода , когда пользователь выбирает пункт меню.
Разработчик может также зарегистрировать представление в макете своего фрагмента, чтобы предоставить контекстное меню. Для этого следует вызвать метод . Когда пользователь открывает контекстное меню, фрагмент принимает вызов метода . Когда пользователь выбирает пункт меню, фрагмент принимает вызов метода .
Примечание. Хотя фрагмент принимает обратный вызов по событию «выбран пункт меню» для каждого добавленного им пункта, операция первой принимает соответствующий обратный вызов, когда пользователь выбирает пункт меню. Если имеющаяся в операции реализация обратного вызова по событию «выбран пункт меню» не обрабатывает выбранный пункт, событие передается методу обратного вызова во фрагменте. Это справедливо для Меню вариантов и контекстных меню.
Подробные сведения относительно меню см. в руководствах для разработчиков и
Управление жизненным циклом фрагмента
Рисунок 3 . Влияние жизненного цикла операции на жизненный цикл фрагмента
Управление жизненным циклом фрагмента во многом аналогично управлению жизненным циклом операции. Как и операция, фрагмент может существовать в одном из трех состояний:
Возобновлен Фрагмент виден во время выполнения операции. Приостановлен На переднем плане выполняется и находится в фокусе другая операция, но операция, содержащая данный фрагмент, по-прежнему видна (операция переднего плана частично прозрачна или не занимает весь экран). Остановлен Фрагмент не виден. Либо контейнерная операция остановлена, либо фрагмент удален из нее, но добавлен в стек переходов назад. Остановленный фрагмент по-прежнему активен (вся информация о состоянии и элементах сохранена в системе). Однако он больше не виден пользователю и будет уничтожен в случае уничтожения операции.Здесь снова просматривается аналогия с операцией: разработчик может сохранить состояние фрагмента с помощью на случай, если процесс операции будет уничтожен, а разработчику понадобится восстановить состояние фрагмента при повторном создании операции. Состояние можно сохранить во время выполнения метода обратного вызова во фрагменте и восстановить его во время выполнения , или . Дополнительные сведения о сохранении состояния приводятся в документе .
Самое значительное различие в ходе жизненного цикла между операцией и фрагментом состоит в принципах их сохранения в соответствующих стеках переходов назад. По умолчанию операция помещается в управляемый системой стек переходов назад для операций, когда она останавливается (чтобы пользователь мог вернуться к ней с помощью кнопки Назад , как описано в статье ). В то же время, фрагмент помещается в стек переходов назад, управляемый операцией, только когда разработчик явно запросит сохранение конкретного экземпляра, вызвав метод во время транзакции, удаляющей фрагмент.
В остальном управление жизненным циклом фрагмента очень похоже на управление жизненным циклом операции. Поэтому практические рекомендации по применимы и к фрагментам. При этом разработчику необходимо понимать, как жизненный цикл операции влияет на жизненный цикл фрагмента.
Внимание! Если возникнет необходимость в объекте внутри объекта класса , можно вызвать метод . Однако разработчик должен быть внимательным и вызывать метод только когда фрагмент прикреплен к операции. Если фрагмент еще не прикреплен или был откреплен в конце его жизненного цикла, метод возвратит null.
Согласование с жизненным циклом операции
Жизненый цикл операции, содержащей фрагмент, непосредственным образом влияет на жизненый цикл фрагмента, так что каждый обратный вызов жизненного цикла операции приводит к аналогичному обратного вызову для каждого фрагмента. Например, когда операция принимает вызов , каждый ее фрагмент принимает .
Однако у фрагментов есть несколько дополнительных методов обратного вызова жизненого цикла, которые обеспечивают уникальное взаимодействие с операцией для выполнения таких действий, как создание и уничтожение пользовательского интерфейса фрагмента. Вот эти методы:
OnCreate() , фрагмент внутри этой операции принимает всего лишь метод обратного вызова .
Когда операция переходит в состояние «возобновлена», можно свободно добавлять в нее фрагменты и удалять их. Таким образом, жизненный цикл фрагмента может быть независимо изменен, только пока операция остается в состоянии «возобновлена».
Однако, когда операция выходит из этого состояния, продвижение фрагмента по его жизненному циклу снова осуществляется операцией.
Пример:
Чтобы суммировать все сказанное в этом документе, рассмотрим пример операции, использующей два фрагмента для создания макета с двумя панелями. Операция, код которой приведен ниже, включает в себя один фрагмент для отображения списка пьес Шекспира, а другой - для отображения краткого содержания пьесы, выбранной из списка. В примере показано, как следует организовывать различные конфигурации фрагментов в зависимости от конфигурации экрана.
Примечание. Полный исходный код этой операции находится в разделе .
Главная операция применяет макет обычным способом, в методе :
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.fragment_layout); }
Здесь применяется макет fragment_layout.xml:
Пользуясь этим макетом, система создает экземпляр класса TitlesFragment (список пьес), как только операция загрузит макет. При этом объект (в котором будет находиться фрагмент с кратким содержанием) занимает место в правой части экрана, но поначалу остается пустым. Как будет показано ниже, фрагмент не помещается в , пока пользователь не выберет элемент в списке.
Однако не все экраны достаточно широки, чтобы отображать краткое содержание рядом со списком пьес. Поэтому описанный выше макет используется только при альбомной ориентации экрана и хранится в файле res/layout-land/fragment_layout.xml .
Когда же устройство находится в книжной ориентации, система применяет макет, приведенный ниже, который хранится в файле res/layout/fragment_layout.xml:
В этом макете присутствует только объект TitlesFragment . Это означает, что при книжной ориентации устройства виден только список пьес. Когда пользователь нажимает на элемент списка в этой конфигурации, приложение запускает новую операцию для отображения краткого содержания, а не загружает второй фрагмент.
Далее можно видеть, как это реализовано в классах фрагмента. Вначале идет код класса TitlesFragment , отображающий список пьес Шекспира. Этот фрагмент является расширением класса и использует его функции для выполнения основной работы со списком.
Изучая код, обратите внимание на то, что в качестве реакции на нажатие пользователем элемента списка возможны две модели поведения. В зависимости от того, какой из двух макетов активен, либо в рамках одной операции создается и отображается новый фрагмент с кратким содержанием (за счет добавления фрагмента в объект ), либо запускается новая операция (отображающая фрагмент).
Второй фрагмент, DetailsFragment , отображает краткое содержание пьесы, выбранной в списке TitlesFragment:
Вспомним код класса TitlesFragment: если пользователь нажимает на пункт списка, а текущий макет не включает в себя представление R.id.details (которому принадлежит фрагмент DetailsFragment), то приложение запускает операцию DetailsActivity для отображения содержимого элемента.
Public static class DetailsActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) { // If the screen is now in landscape mode, we can show the // dialog in-line with the list so we don"t need this activity. finish(); return; } if (savedInstanceState == null) { // During initial setup, plug in the details fragment. DetailsFragment details = new DetailsFragment(); details.setArguments(getIntent().getExtras()); getFragmentManager().beginTransaction().add(android.R.id.content, details).commit(); } } }
Обратите внимание, что в альбомной конфигурации эта операция самостоятельно завершается, чтобы главная операция могла принять управление и отобразить фрагмент DetailsFragment рядом с фрагментом TitlesFragment . Это может произойти, если пользователь запустит операцию DetailsActivity в книжной ориентации экрана, а затем перевернет устройство в альбомную ориентацию (в результате чего текущая операция будет перезапущена).
Дополнительные образцы кода, использующего фрагменты (и файлы с полным исходным кодом этого примера), доступны в приложении-примере API Demos в разделе (которое можно загрузить из ).
Создать хороший UI сложно, особенно если у тебя еще не так много опыта в этой области. Поэтому вот тебе быстрый тест на знание вопроса: если ты привык, что для нового окна обязательно нужен Activity или вместо плавной анимации в свеженаписанной программе почему-то происходят конвульсии, - эта статья для тебя 🙂
Грабли Activity
Большинство туториалов, демонстрирующих фишки Android-разработки, начинаются одинаково: неопытным разработчикам предлагают накидать все визуальные элементы прямо в XML-разметку главного Activity. Выглядит это примерно так:
Public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ...
Такая проектировка входит в привычку, и проект заполняется новыми Activity со все более сложной разметкой. Как итог - даже минимально полезное приложение обрастает стеком Activity, сжирающим всю оперативную память, а в разработчика летят камни и двойки в Google Play.
А все потому, что ОС Android совершенно не обещает держать твои Activity живыми. Как ты помнишь, эти компоненты существуют независимо друг от друга, обладая особым жизненным циклом. Если Activity переходит в состояние onPause , а происходит это довольно часто, он становится котейкой Шредингера: нельзя заранее знать, будет он жив или нет.
Используя дополнительные Activity для вывода меню и других мелочей, ты подвергаешь опасности все логические связи внутри приложения. Activity собираются в стек, и ОС может начать выгружать их по одному или группой. Когда пользователь захочет вернуться в предыдущее окно, Activity может уже быть уничтожен, и юзер выпадет из приложения.
Кроме проблем с сохранением логики, есть и рутина поддержки ООП-кода: плотно завязанные на Activity интерфейсы практически невозможно развивать дальше. Масштабирование, быструю замену одних элементов на другие, анимацию - все это будет очень тяжело реализовать в новых версиях приложения.
Благодаря моде на единую экосистему все мобильные приложения стали в целом очень похожи. Стоит только нащупать тропинку да немного потренироваться, и тогда качество начинает быстро расти. Следуя принципу «критикуя - предлагай», мы сейчас напишем приложение, реализующее универсальный пользовательский интерфейс. Это будет интересно не только с академической точки зрения - уверен, написанный сегодня код ты сможешь легко встроить в свои проекты. Итак, начнем!
Fragments
Чтобы работать с UI было проще и быстрее, Google создала фрагмент (Fragment) - класс - прослойку между Activity и визуальными составляющими программы. С одной стороны, это контейнер для любых View-объектов, которые могут быть показаны пользователю. С другой - продолжение Activity, от которого Fragment получает всю информацию об изменениях в жизненном цикле.
У фрагментов, как и у Activity, есть свой (правда, более оригинальный) жизненный цикл. К примеру, работать с UI сразу после создания фрагмента невозможно, нужно ждать загрузки всех элементов - после метода onCreate выполнится метод onCreateView , где и можно будет загрузить элементы.
Public class FragmentOne extends Fragment { ... public View onCreateView(...) { View view =inflater.inflate(R.layout.fragment_one, container,false); TextView textView = (TextView)view.findViewById(R.id.fo_text); textView.setText("Hello, i"m first fragment!"); return view; ...
В фрагменте тоже можно переопределять любые методы, отслеживающие состояние окна. Так, если приложение уйдет в фон, в Activity выполнится onPause , а затем метод с точно таким же названием выполнится здесь. Это может быть полезно - удобно для отключения от сторонних объектов, например привязанных сервисов (bound service).
FragmentTransaction
Зная, что работа с фрагментами будет насыщенной, Google заблаговременно создала для этого специальные инструменты. Классы FragmentManager и FragmentTransaction аккумулируют в себе все процессы: создание новых фрагментов и их удаление, передачу данных и так далее.
Объект FragmentManager создавать не нужно, он уже есть в каждом Activity, нужно только получить на него ссылку. А все действия будут проходить через FragmentTransaction , который затем самостоятельно передаст данные менеджеру фрагментов.
FragmentManager manager = getSupportFragmentManager(); FragmentTransaction transaction = manager.beginTransaction();
Хочу заметить, что классы, работающие с фрагментами, доступны в двух вариантах. Рекомендую использовать более новую версию - это те, у которых в пути импорта присутствует строчка android.support.v4. Это большая библиотека, созданная для организации обратной совместимости. Компания Google бережно относится к устройствам на всех версиях ОС, а библиотеки позволяют использовать новшества разработки даже при работе со старым API.
Import android.support.v4.app.FragmentTransaction; import android.support.v4.app.Fragment;...
FrameLayout
Часто данные в UI приходят динамически, в зависимости от происходящих событий. Чтобы было куда поместить картинку или текст, существует специальный контейнер - FrameLayout . В этом и есть его основная задача - зарезервировать на экране место для любого объекта класса View, который можно будет подгрузить позднее. Фрагменты тоже живут в таких контейнерах.
Добавить новый фрагмент в FrameLayout можно по-разному: в FragmentTransaction доступны схожие по функциональности методы замены (replace) и добавления (add).
Transaction.replace(R.id.frame_container, fragmentObject);
Несмотря на внешнюю схожесть, нужно хорошо понимать, какого результата ты можешь добиться. Метод replace работает очень просто - добавит фрагмент и, если в контейнере раньше что-то было, удалит старые фрагменты.
Transaction.add(R.id.frame_container, fragment);
Метод add же создает стек из фрагментов, и каждый новый вызов помещает на верх стека новый экземпляр. Важно, что при появлении нового фрагмента старые объекты в стеке не получают никаких оповещений и работают так, как будто бы ничего не произошло. Это значит, что метод onPause для них не выполнится и они продолжат расходовать ресурсы устройства, хотя пользователь перестанет их видеть.
Такая растрата выделенной памяти бывает оправданна, например если хочется организовать предобработку данных: фрагмент может что-нибудь подгрузить, пока будет незаметен, а потом показать уже готовый результат.
Действий с фрагментами может быть несколько, они будут аккумулироваться до тех пор, пока не выполнится метод commit.
Transaction.commit();
Продолжение доступно только подписчикам
Вариант 1. Оформи подписку на «Хакер», чтобы читать все материалы на сайте
Подписка позволит тебе в течение указанного срока читать ВСЕ платные материалы сайта. Мы принимаем оплату банковскими картами, электронными деньгами и переводами со счетов мобильных операторов.
