Android UI Programming

Activity
● Android Application Component for UI
– Provides a window for user interaction
– Content area for views and widgets
– Requires lifecycle and state management
Example: HelloWorldActivity (Java)

package [Link];
import [Link];
import [Link];
public class HelloWorldActivity extends Activity
{
/** Called when the activity is first created.*/
@Override
public void onCreate(Bundle savedInstanceState)
{
[Link](savedInstanceState);
setContentView([Link]);
}
}
Example: HelloWorldActivity (Kotlin)

package [Link]
import [Link]
import [Link]

class HelloWorldActivity : Activity() {

override fun onCreate(savedInstanceState: Bundle?) {
[Link](savedInstanceState)
setContentView([Link])
}
}
Example Manifest declaration
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="[Link]
package="[Link]"
android:versionCode="1"
android:versionName="1.0" >

<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"

<activity
android:name="HelloWorldActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="[Link]" />

<category android:name="[Link]" />

</intent-filter>
</activity>

</application>

</manifest>
 Activity Lifecycle

● Primary states
– Resumed : Activity in foreground – user can interact
– Paused : At least partially obscured by another activity – activity may be
partially visible but loses focus.
– Stopped : Completely hidden – not visible to user. Activity may exist in
memory, but in low memory situation, can be killed by OS.
 Lifecycle and state management
● Need
– Stop animations / video and other actions consuming
CPU
– Release system resources such as handles to sensors
– Commit unsaved changes (if required)
● Method
– onPause() / onResume()
● release / acquire resources, stop / start CPU utilization
– onStop() / onStart() / onRestart()
● save / handle persistent data
– onSaveInstanceState() / onRestoreInstanceState()
● save / load transient data
 Basic Activity Relationships
Provides access to
application global state
Useful for looking up assets,
resources and other
application level information

Visual components

A container for storing map data

Useful for state management
 Views and Widgets
[Link]

[Link]
 UI Development Approaches
● Programmatic
– Using Java/Kotlin code
– Dynamic view generation
– Slightly complicated to maintain
● Declarative
– Using XML
– Static views – may be further adjusted through
programmatic approach
– Easier to maintain
Example: Notes App
package [Link]; package [Link];

import [Link]; import [Link];

import [Link]; import [Link];

public class Note{ class Note {

private var id:String? = null
private String id; private var content:String? = null
private String content; private var creationDateTim e:Date? = null
private Date creationDateTime;

public Note(){ constructor() {

init(); init()
} }

public Note(String content){ constructor(content:String?) {

init(); init()
[Link] = content; [Link] = content
} }
private void init(){
private fun init() {
[Link] = [Link]().toString();
[Link] = new Date(); id = [Link] UUID().toString()
} creationDateTim e = Date()
}
public void setContent(String content){
[Link] = content; fun setContent(content:String?) {
} [Link] = content
}
} }

Java Kotlin
package [Link];

import [Link];
Programmatic Approach
import [Link];
import [Link];
...
class MainActivity :Activity() {
public class NotesActivity extends Activity var notes:ArrayList<Note?>? = null
{ var currentNote:Note? = null
ArrayList<Note> notes; var textArea:EditText? = null
Note currentNote;
EditText textArea;
public override fun onCreate(savedInstanceState:Bundle?) {
public void onCreate(Bundle savedInstanceState) [Link](savedInstanceState)
{ //setContentView([Link]);
[Link](savedInstanceState); createUi()
//setContentView([Link]);
createUi(); notes = ArrayList<Note?>()
notes = new ArrayList<Note>(); }
}
private fun saveNote() {
private void saveNote(){ val content = textArea!!.[Link]()
String content = [Link]().toString(); if (currentNote == null) {
if(currentNote == null){
currentNote = new Note(content); currentNote = Note(content)
[Link](currentNote); notes!!.add(currentNote)
} }
[Link](content); currentNote!!.setContent(content)
val text = "Note saved successfully"
String text = "Note saved successfully";
Toast toast = val toast = Toast.m akeText(this,text,Toast.LENGTH_SHORT)
[Link](this,text,Toast.LENGTH_SHORT); [Link]()
[Link](); }
}
private fun newNote() {
private void newNote(){ saveNote()
saveNote();
[Link](""); textArea!!.setText("")
currentNote = null; currentNote = null
} }

private void listNotes(){ private fun listNotes() {

String text = "Total " + [Link]() + " notes"; val text = "Total " + notes!!.size + " notes"
Toast toast = [Link](this,text,Toast.LENGTH_LONG);
[Link](); val toast = Toast.m akeText(this,text,Toast.LENGTH_LONG)
} [Link]()
}
private void createUi(){ ... }
private void createMenu(){ ... } private fun createUI() { ...}
}
private fun createMenu() { ...}
}
private void createUi(){
LinearLayout outerLayout = new LinearLayout(this);
Programmatic Approach (Java)
[Link](new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
[Link]([Link]);

textArea = new EditText(this);

[Link](new [Link](LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT,1f));
[Link]("Notes");
[Link]([Link]);

[Link](textArea);
[Link](createMenu());
setContentView(outerLayout);
}

private ViewGroup createMenu(){

LinearLayout layout = new LinearLayout(this);
[Link](new LayoutParams(LayoutParams.MATCH_PARENT,LayoutParams.WRAP_CONTENT));
[Link]([Link]);
[Link]([Link]);

LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT,LayoutParams.WRAP_CONTENT);

Button saveButton = new Button(this);

[Link](params);
[Link]("Save");
[Link](new OnClickListener() {
public void onClick(View arg0) {
saveNote();
}
});
Button newButton = new Button(this);
[Link](params);
[Link]("New");
[Link](new OnClickListener() {
public void onClick(View arg0) {
newNote();
}
});
Button listButton = new Button(this);
[Link](params);
[Link]("List");
[Link](new OnClickListener() {
public void onClick(View arg0) {
listNotes();
}
});

[Link](saveButton);
[Link](newButton);
[Link](listButton);

return layout;
}
private fun createUi() { Programmatic Approach (Kotlin)
val outerLayout = LinearLayout(this)
[Link] =
[Link] s(
[Link] s.MATCH_PARENT,
[Link] s.MATCH_PARENT
)
[Link] = [Link]
textArea = EditText(this)
textArea!!.layoutParams = [Link] s(
[Link] s.MATCH_PARENT,
[Link] s.WRAP_CONTENT,
1f
)
textArea!!.hint = "Notes"
textArea!!.gravity = [Link]
[Link](textArea)
[Link](createMenu())
setContentView(outerLayout)
}

private fun createMenu():ViewGroup {

val layout = LinearLayout(this)
[Link] =
[Link] s(
[Link] s.MATCH_PARENT,
[Link] s.WRAP_CONTENT
)
[Link] = [Link]
[Link] = [Link]
val param s = [Link] s(
[Link] s.WRAP_CONTENT,
[Link] s.WRAP_CONTENT
)
val saveButton = Button(this)
[Link] = param s
[Link] = "Save"
[Link] { saveNote() }
val newButton = Button(this)
[Link] = param s
[Link] = "New"
[Link] { newNote() }
val listButton = Button(this)
[Link] = param s
[Link] = "List"
[Link] { listNotes() }
[Link](saveButton)
[Link](newButton)
[Link](listButton)
 Declarative Approach
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="[Link]
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
>
<EditText
android:id="@+id/text_area"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:hint="Notes"
android:gravity="top"
/>
<LinearLayout
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
>
<Button
android:id="@+id/button_save"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Save"
android:onClick="buttonClick"
/>
<Button
android:id="@+id/button_new"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="New"
android:onClick="buttonClick"
/>
<Button
android:id="@+id/button_list"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="List"
android:onClick="buttonClick"
/>
</LinearLayout>
</LinearLayout>
package [Link];

import [Link]; Declarative Approach

import [Link];
...
public class NotesActivity extends Activity class NotesActivity :Activity() {
{ private var notes:ArrayList<Note>? = null
ArrayList<Note> notes; private var currentNote:Note? = null
Note currentNote; private var textArea:EditText? = null
EditText textArea;
public override fun onCreate(savedInstanceState:Bundle?) {
public void onCreate(Bundle savedInstanceState) [Link](savedInstanceState)
{ setContentView([Link].main_linear)
[Link](savedInstanceState); textArea = findViewById<View>([Link].text_area) as EditText
setContentView([Link]); notes = ArrayList()
textArea = (EditText) findViewById([Link].text_area);
}
notes = new ArrayList<Note>();
}
private fun saveNote() {
private void saveNote(){ val content = textArea!!.[Link]()
String content = [Link]().toString(); if (currentNote == null) {
if(currentNote == null){ currentNote = Note(content)
currentNote = new Note(content); notes!!.add(currentNote!!)
[Link](currentNote); }
} currentNote!!.setContent(content)
[Link](content); . ..
... }
}
private fun newNote() {
private void newNote(){ saveNote()
saveNote(); textArea!!.setText("")
[Link](""); currentNote = null
currentNote = null;
}
}

private void listNotes(){ private fun listNotes() {

String text = "Total " + [Link]() + " notes"; val text = "Total " + notes!!.size + " notes"
Toast toast = [Link](this,text,Toast.LENGTH_LONG); val toast = Toast.m akeText(this,text,Toast.LENGTH_LONG)
[Link](); [Link]()
} }

public void buttonClick(View v){ fun buttonClick(v:View) {

if([Link]() == [Link].button_save){ if ([Link] == [Link].button_save) {
saveNote(); saveNote()
} else if([Link]() == [Link].button_new){ }
newNote(); if ([Link] == [Link].button_new) {
} else if([Link]() == [Link].button_list){ newNote()
listNotes(); }
} if ([Link] == [Link].button_list) {
} listNotes()
}
}
}
}
 Resource
● Additional files (other than code) used by app
● Types
– layout
● defines UI layouts and components
– drawables
● bitmaps and other graphics used in app
– values
● string constants
● colors
● styles, etc
– other resources
● menu, animations, etc
 Strings

<?xml version="1.0" encoding="utf-8"?>

<resources>
<string name="app_name">Notes</string>
<string name="new">New</string>
<string name="save">Save</string>
<string name="list">List</string>
<string name="notes">Notes</string>
</resources>
 UI Pattern: Lists and Grids
● Presents large data sets in form of lists or grids
● Features
– Scrollable
– Customization of UI as well as data source
– Recycling support
● Implementation
– Consider Adapter design pattern
Example: RecyclerView
 Adapter Design Pattern


Design pattern
 Makes incompatible interfaces work with each other
 Converts the interface to the one client expects
 Allows creating decoupled general-purpose
implementations that can work with each other using
adapter

Applicability
 Adapters for third-party libraries
public class NoteAdapter extends // create as an inner class of NoteAdapter Java
[Link]<[Link]> {
private ArrayList<Note> mDataset; public class NoteViewHolder extends
[Link] {
public NoteAdapter(ArrayList<Note> ds) {
mDataset = ds; public TextView title;
} public TextView timestamp;
public Button remove;
public [Link]
onCreateViewHolder(ViewGroup parent, public NoteViewHolder(View v) {
int viewType) { super(v);
title = (TextView) [Link]([Link]);
View v = [Link]([Link]()) timestamp = (TextView)
.inflate([Link].note_list_item, parent, false); [Link]([Link]);

NoteViewHolder vh = new NoteViewHolder(v); remove = (Button)

return vh; [Link]([Link].button_remove);
}
[Link](
public void new [Link]() {
onBindViewHolder(NoteViewHolder holder,
int position) { public void onClick(View v) {
Note note = [Link](position); int pos = (int) [Link]();
String content = [Link](); [Link](pos);
String ts = [Link]();
String title = [Link](0,[Link]("\n")); //adapter method
[Link](title); notifyDataSetChanged();
[Link](ts); }
[Link](position);
} });
}
public int getItemCount() {
return [Link](); } // end of view holder class
}
} // end of adapter class
public class MainActivity extends AppCompatActivity {
Java
private RecyclerView recyclerView;
private [Link] mAdapter;
private [Link] layoutManager;
ArrayList<Note> dataSet = new ArrayList<Note>();

protected void onCreate(Bundle savedInstanceState) {

[Link](savedInstanceState);
setContentView([Link]);
recyclerView = (RecyclerView) findViewById([Link]);
[Link](true);

// use a linear layout manager

layoutManager = new LinearLayoutManager(this);
[Link](layoutManager);

// specify an adapter
mAdapter = new NoteAdapter(dataSet);
[Link](new DividerItemDecoration(this, [Link]));
[Link](mAdapter);
}

public void clickHandler(View v){

if ([Link]() == [Link].button_new){
Note note = new Note("Note " + ([Link]()+1) + "\nLorem ipsum ...");
[Link](note);
[Link]();
}
}
}
class NoteAdapter(private val mDataset: ArrayList<Note>) : // create as an inner class of NoteAdapter Kotlin
[Link]<NoteViewHolder>() {
inner class NoteViewHolder(v: View) :
override fun onCreateViewHolder( [Link](v) {
parent: ViewGroup,
viewType: Int var title: TextView
) : NoteViewHolder { var timestamp: TextView
// create a new view var remove: Button
val v = [Link]([Link])
.inflate([Link].note_list_item, parent, false) init {
return NoteViewHolder(v) title = [Link]<View>([Link]) as
} TextView

timestamp =
override fun onBindViewHolder( [Link]<View>([Link]) as TextView
holder: NoteViewHolder, position: Int) {
remove =
// - get element from your dataset at this position [Link]<View>([Link].button_remove) as Button
// - replace the contents of the view with that element
val content = mDataset[position].content [Link] { v ->
[Link] = val pos = [Link] as Int
content!!.substring(0, [Link]("\n")) [Link](pos)
[Link] = mDataset[position].timeStamp notifyDataSetChanged()
[Link] = position }
} }

// return the size of your dataset } // end of inner class

// (invoked by the layout manager)
override fun getItemCount(): Int {
return [Link] } // end of adapter class
}
class MainActivity : AppCompatActivity() {
Kotlin
private var recyclerView: RecyclerView? = null
private var mAdapter: [Link]<*>? = null
private var layoutManager: [Link]? = null
var dataSet = ArrayList<Note>()

override fun onCreate(savedInstanceState: Bundle?) {

[Link](savedInstanceState)
setContentView([Link])
recyclerView = findViewById<View>([Link]) as RecyclerView
recyclerView!!.setHasFixedSize(true)

// use a linear layout manager

layoutManager = LinearLayoutManager(this)
recyclerView!!.layoutManager = layoutManager

// specify an adapter (see also next example)

mAdapter = NoteAdapter(dataSet)
recyclerView!!.addItemDecoration(DividerItemDecoration(this, [Link]))
recyclerView!!.adapter = mAdapter
}

fun clickHandler(v: View) {

if ([Link] == [Link].button_new) {
val note = Note(
""" Note ${[Link] + 1}
Lorem ipsum … """.trimIndent() )
[Link](note)
mAdapter!!.notifyDataSetChanged()
}
}
}
 Launching another Activity

Using an Intent
 An action intended for the android platform
 One of the uses is to start another activity
 Specify Activity class to be invoked
 Use ActivityResultLauncher to launch a child activity
returning a result back to parent
» startActivityForResult used in older APIs is deprecated
public class MainActivity extends AppCompatActivity { Java
// other attributes ...
ActivityResultLauncher<Intent> notesLauncher;

protected void onCreate(Bundle savedInstanceState) {

// other UI creation related tasks
// ....

//register
notesLauncher = registerForActivityResult(
new [Link](),
new ActivityResultCallback<ActivityResult>() {

public void onActivityResult(ActivityResult result) {

if([Link]() == RESULT_OK){
Intent data = [Link]();
String id = [Link]("id");
// handle incoming data from child
}
}
});

public void clickHandler(View v){

if ([Link]() == [Link].button_new){
Intent intent = new Intent(this,[Link]);
[Link]("id","");
[Link](intent);
}
}
}
public class NotesActivity extends Activity Java
{
EditText textArea;
String noteId;

public void onCreate(Bundle savedInstanceState)

{
[Link](savedInstanceState);
setContentView([Link]);
textArea = (EditText) findViewById([Link].text_area);

Intent intent = getIntent();

String content = [Link]("content");
[Link](content);
noteId = [Link]("id");
}

public void saveNote(View v){

Intent result = new Intent();
[Link]("content",[Link]().toString());
[Link]("id",noteId);
setResult(RESULT_OK,result);
finish();
}

public void cancelNote(View v){

Intent result = new Intent();
setResult(RESULT_CANCELED,result);
finish();
}
}
class MainActivity : AppCompatActivity() { Kotlin
// other attributes ...
ActivityResultLauncher<Intent>? = null

override fun onCreate(savedInstanceState?: Bundle) {

// other UI creation related tasks
// ....

//register
notesLauncher = registerForActivityResult<Intent, ActivityResult>(
[Link]()
) { result ->
if ([Link] == RESULT_OK) {
val data = [Link]
val id = [Link]("id")
// handle incoming data
}
}
}

fun clickHandler(v: View) {

if ([Link] == [Link].button_new) {
val intent = Intent(this, NotesActivity::[Link])
[Link]("id", "")
notesLauncher!!.launch(intent)
}
}
}
class NotesActivity : Activity() { Kotlin
var textArea: EditText? = null
var noteId: String? = null

public override fun onCreate(savedInstanceState: Bundle?) {

[Link](savedInstanceState)
setContentView([Link])
textArea = findViewById<View>([Link].text_area) as EditText
val intent = intent
val content = [Link]("content")
textArea!!.setText(content)
noteId = [Link]("id")
}

private fun saveNote() {

val result = Intent()
[Link]("content", textArea!!.[Link]())
[Link]("id", noteId)
setResult(RESULT_OK, result)
finish()
}

private fun cancelNote() {

val result = Intent()
setResult(RESULT_CANCELED, result)
finish()
}
}
 UI Pattern: Searching and Filter
● Filter
– A convenient widget for filtering result sets
– Performs complex processing in a worker thread
– Return result to UI thread

● User interaction
– EditText combined with TextWatcher
– Other views e.g. toggle buttons, SearchView, etc.
public class NoteAdapter extends [Link]<[Link]> implements Filterable
{ Java
private Filter filter;
private ArrayList<Note> notes;
private ArrayList<Note> filteredNotes;
...

public Filter getFilter() {

if (filter == null){
filter = new NotesFilter();
}
return filter;
}

public class NoteViewHolder extends [Link] {

...
public NoteViewHolder(View v) {
super(v);
...
[Link](new [Link]() {
@Override
public void onClick(View view) {
int pos = (int) [Link]();
[Link]([Link](pos));
}
});
}
}

public NoteAdapter(ArrayList<Note> ds, NoteItemClickListener ls) {

notes = ds;
filteredNotes = ds;
listener = ls;
}

public NoteViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

...
}

public void onBindViewHolder(NoteViewHolder holder, int position) {

String content = [Link](position).getContent();
...
}

public int getItemCount() {

return [Link]();
}
...
}
 Java

Declared private as generally implemented as an inner class

private class NotesFilter extends Filter{

@Override
protected FilterResults performFiltering(CharSequence constraint) {
FilterResults results = new FilterResults();
if(constraint != null && [Link]() > 0){
ArrayList<Note> filteredList = new ArrayList<Note>();
for(int i=0; i < [Link](); i++){
if([Link](i).getContent().contains(constraint)){
[Link]([Link](i));
}
}

[Link] = [Link]();
[Link] = filteredList;

}
else{
[Link] = [Link]();
[Link] = notes;
}

return results;
}

@Override
protected void publishResults(CharSequence constraint, FilterResults results) {
filteredNotes = (ArrayList<Note>) [Link];
notifyDataSetChanged();
}

}
}
 Java

search = (EditText) findViewById([Link]);

[Link](new TextWatcher() {

public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {

}

public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {

[Link]().filter([Link]().toString());
}

public void afterTextChanged(Editable editable) {

}
});

Invoking filter
class NoteAdapter(private val notes: ArrayList<Note>, ls: NoteItemClickListener) :
[Link]<NoteViewHolder>(), Filterable { Kotlin
private var filteredNotes: ArrayList<Note>
private val listener: NoteItemClickListener
private var filter: Filter? = null
override fun getFilter(): Filter? {
if (filter == null) {
filter = NotesFilter()
}
return filter
}

inner class NoteViewHolder(v: View) : [Link](v) {

...
init {
...
[Link] { v ->
val pos = [Link] as Int
val note = filteredNotes[pos]
[Link](note)
...

}
[Link] {
val pos = [Link] as Int
[Link](filteredNotes[pos])
}
}
}

// Provide a suitable constructor (depends on the kind of dataset)

init {
filteredNotes = notes
listener = ls
}

override fun onCreateViewHolder(parent: ViewGroup,viewType: Int): NoteViewHolder {

...
}

override fun onBindViewHolder(holder: NoteViewHolder, position: Int) {

...
[Link] = filteredNotes[position].timeStamp
...
}

override fun getItemCount(): Int {

return [Link]
}
 Kotlin

Declared private as generally implemented as an inner class

private inner class NotesFilter : Filter() {

override fun performFiltering(constraint: CharSequence): FilterResults {
val results = FilterResults()
if (constraint != null && [Link] > 0) {
val filteredList = ArrayList<Note>()
for (i in [Link]) {
if (notes[i].content!!.contains(constraint)) {
[Link](notes[i])
}
}
[Link] = [Link]
[Link] = filteredList
} else {
[Link] = [Link]
[Link] = notes
}
return results
}

override fun publishResults(constraint: CharSequence, results: FilterResults) {

filteredNotes = [Link] as ArrayList<Note>
notifyDataSetChanged()
}
}

}
 Kotlin

search = findViewById<View>([Link]) as EditText

search!!.addTextChangedListener(object : TextWatcher {
override fun beforeTextChanged(charSequence: CharSequence, i: Int, i1: Int,
i2: Int) {}

override fun onTextChanged(charSequence: CharSequence, i: Int, i1: Int, i2: Int) {

filterable!!.[Link](search!!.[Link]())
}

override fun afterTextChanged(editable: Editable) {}

})

Invoking filter
 Basic state management
public class Note implements [Link]
{
...
}

public class MainActivity extends Activity

{
...
public void onSaveInstanceState(Bundle savedInstanceState){
[Link](savedInstanceState);

try{
[Link]("noteslist",notes);
}
catch(Exception ex){ }
}
public void onRestoreInstanceState(Bundle savedInstanceState){
[Link](savedInstanceState);

try{
notes = (ArrayList<Note>)
[Link]("noteslist");
}
catch(Exception ex){ }
}

...

Bundle available to onSaveInstanceState : suitable for lightweight transient data

 View Model
● In-memory storage structure for UI state
● Associated with Activity's life-cycle
● Survives screen rotations but not system-initiated death

public class UsersViewModel extends ViewModel {

private List<User> users;
public List<User> getUsers() {
if (users == null) {
users = new ArrayList<User>();
// other related operations ...
}
return users;
}
}
 UI Pattern: Menus
● Options Menu
– Primary collection of menu items for an activity
– Manages global navigation for activity / application
– Activities can enable / disable / change menu items
– Application-wide generalization can be done through an abstract
base Activity and a Template Method design pattern
● Context Menu
– Floating menu that appears on long-click of an element
– Provides options for manipulating a selected item
– Contextual Action Mode can be used for manipulating multiple items
simultaneously
 Options Menu
Menu item fixed

App Bar Overflow menu

Create Menu Items

menu resource file
Override
onCreateOptionsMen
u
Inflate menu using
MenuInflater

Handle click events

Override
onOptionsItemSelecte
d
Contextual Menu and Action Mode
Contextual action bar
as an action mode


Implement
[Link]
• Inflate menu

• Handle actions


Initiate action mode
• View's long-click
Recyclerview layout changed listener
to allow selection
• call startActionMode