Today's goals

Recall: Event Dispatch

Recall: Events can represent user actions...

Example: MotionEvent which inherits from InputEvent abstract class.

Recall: Events can represent abstract concepts...

Recall: Relating this back to the phone

Recall: Relating this back to the phone

Android Callbacks

• onCreate
  • called when the activity is first created
  • we've seen this in our Doodle, Layout, and Spot The Heron apps:

@Override
protected void onCreate(Bundle savedInstanceState) {
  // We want to do any view initialization work here
  super.onCreate(savedInstanceState);
  // Load the XML representation of our layout into the view
  setContentView(R.layout.activity_main);
  // Any other work we need to do like adding views or
  // registering click listeners!
}

Other Android Callbacks

• onStart
  • Called when activity is about to be visible to the user
  • Always gets called after onCreate or onRestart

Callbacks in Android

• At the time Android was created the toolkit developers have no idea how every app may want to respond to events

• Listeners are an interface that acts as a callback method

Standard Listener Interfaces

The toolkit has pre-defined interfaces so apps or components can respond to events such as clicks or touches.

    // User tapped a view
    public static interface View.OnClickListener { ... }
    // User long pressed on a View
    public static interface View.OnLongClickListener { ... }
    // State of view has changed
    // (e.g. user clicked outside a EditText input box)
    public static interface View.OnFocusChangeListener { ... }
    // user typed something
    public static interface View.OnKeyListener { ... }

Implementing clicking

Create your button

Register an event listener with the button

Pressing something!

Registering an Event Listener

Three five ways to register an event listener:

• Creating a separate class/file or an inner class
• Creating an anonymous inner class
• Implementing an Interface in your custom view/application
• Creating an anonymous class as a parameter
• Lambdas

Examples of all of these in the Counter exercise

Code for the Counter exercise uses a helper function

/** Method to increment the count field */
private void incrementCount(View v) {
    TextView counter = findViewById(R.id.count);
    String textCount = counter.getText().toString();
    int count = Integer.parseInt(textCount);
    counter.setText("" + ++count);
    ((TextView)findViewById(R.id.whichButton)).setText(((Button)v).getText());
}

Simplest approach: Implement the method

// Approach 3 implementation: implement the listener in
// *this* class
  @Override
  public void onClick(View v) {
      incrementCount(v);
  }

Then register the listener

  // Approach 3 implementation: implement the listener in
  //*this* class
  @Override
  public void onClick(View v) {
      incrementCount(v);
  }
  // in onCreate...
  // Registering the listener in Approach 3 (using
  // this class)
    Button b3 = findViewById(R.id.button_three);
    if (b3 != null) {  // Should always check for null
        b3.setOnClickListener(this);
    }

Preferred Approach: Create an Anonymous Inner Class

public class EventExampleActivity extends AppCompatActivity {
  // An anonymous inner class as a member variable in an Activity
  View.OnClickListener mButtonClickListener = new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          // call the private method in EventExampleActivity
          incrementCount(v);
      }
  };
  protected void onCreate(Bundle savedState) {
    Button b1 = findViewById(R.id.button_one);
    if (b1 != null) {
      b1.setOnClickListener(mButtonClickListener);
    }
  }
}

Digging deeper: Creating an Anonymous Inner Class

Let's take some time to parse this...

View.OnClickListener mButtonClickListener = new View.OnClickListener() {

• View.OnClickListener is the variable type (Documentation) - a nested class in View
• new View.OnClickListener() is the the anonymous object
  • The on method that you MUST implement (in order to create a new object) is OnClick which overrides the abstract method

  public void OnClick(View v) { /* stuff in here does the work when a click is received! */ }

For very simple listeners you can use a lambda

  Button b5 = findViewById(R.id.button_five);
  if (b5 != null) {  // Should always check for null
      b5.setOnClickListener((View v) -> incrementCount(v));
  }

Other Listeners

    // User tapped a view
    public static interface View.OnClickListener { ... }
    // User long pressed on a View
    public static interface View.OnLongClickListener { ... }
    // State of view has changed
    // (e.g. user clicked outside a EditText input box)
    public static interface View.OnFocusChangeListener { ... }
    // user typed something
    public static interface View.OnKeyListener { ... }

Registering Multiple Listeners

Can register more than one listener

For example:

  View v = new View();
  v.setOnClickListener(...);
  v.setOnLongClickListener(...);

Many Views, Same Listener (1/3)

Event callbacks are passed the View as a parameter

Many Views, Same Listener (2/3)

And we can handle different actions by checking the View or its id:

  protected void onCreate(Bundle savedState) {
    Button b1 = (Button) findViewById(R.id.button_one);
    if (b1 != null) {
      b1.setOnClickListener(mButtonClickListener);
    }
    Button b2 = (Button) findViewById(R.id.button_two);
    if (b2 != null) {
      b2.setOnClickListener(mButtonClickListener);
    }
  }

Many Views, Same Listener (3/3)

You can use the ID of the view to determine where the event originated from

View.OnClickListener mButtonClickListener = new View.OnClickListener({
  public void onClick(View v) {
    if (v == null) {
      return;
    }
    int viewId = v.getId();
    switch (viewId) {
      case R.id.button_one:  // First Button
        Log.d("Button Press", "First Button");
        break;
      case R.id.button_two:  // Second Button
        Log.d("Button Press", "Second Button");
        break;
      default:               // Someone else is using the listener!
        Log.d("Button Press", "Invalid Button!");
    }
  }
});

Marking an event as handled

This ensures only one view gets it (we talk about the algorithm behind this later)

Return boolean value that indicate the event has been handled (true)

    /**
     * onLongClick - triggered when a view is long clicked
     * @param v - the view long pressed
     * @return - true if the callback consumed the long click, false otherwise.
     **/
    boolean onLongClick (View v) { ... };

Other types of interactors

What other types of interactors have you used in a Graphical User Interface (GUI)?

Menus

Create the menu resource

• Click on the Resource Manager tab and click on the vertical ...
• Select Menu
  • If you have a menu already, it will show up in this pane
  • If you don't have a menu already, click the +
  • Name your menu and add your menu items

Menus

Example: Counter

Menus

Handle the callback (from the system) with an onCreateOptionsMenu(Menu menu) listener

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.menu_main, menu);
    return true;
}

Menus

But we still need to handle the events generated from the user

public boolean onOptionsItemSelected(MenuItem item) {
  int id = item.getItemId();
  if (id != R.id.dropdown_menu) { // if not the parent hamburger menu
      if (id == R.id.reset_button_count) {
        ...
      } else if (id == R.id.reset_click_count) {
        ...
      } else {
        ...
      }
      return true;  // return true if we handled the event!
  }
  // Otherwise pass it off to the parent class for handling
  return super.onOptionsItemSelected(item);
}

Summary: Relating this back to the phone

Summary: Relating this back to the phone

Summary: Relating this back to the phone

End of Deck

Thing to think about...

How would you handle input in a circular component?