Intro to Android Development
  • Welcome
  • Syllabus
  • Hack Challenge
  • Resources
    • Lecture Videos
    • Ed Discussion
    • Git & GitHub Help/How-To
    • Setting up Android Studio
    • Starting an Android Studio Project & Making an Emulator
    • Importing, Exporting, & Submitting Your Projects to CMS
  • SP25 Course Material
    • Week 1 | Course Logistics, Kotlin, & Basic UI
      • Relevant Links
      • Demo/Lecture: Eatery Card
      • A0: Eatery Card (Follow-Along)
    • Week 2 | States, Components, LazyColumn
      • Relevant Links
      • Demo: Todo List
      • A2: Shopping List
    • Week 3 | Navigation & Animations
      • Relevant Links
      • Demo: Onboarding
      • A3: Stock Trading (RobbingGood)
    • Week 4 | MVVM and Flows
      • Relevant Links
      • Demo: Eatery Card 2
      • A4: Chat of a Lifetime
    • Week 5 | Dumb Components & UIEvents
      • Relevant Links
      • Demo: Music Player
      • A5: Rate My Vibe
    • Week 6 | Coroutines, Networking, JSON
      • Relevant Links
      • Demo: Retrofit
      • A6: You Should Even Lift, Bro.
  • Bonus Week | Android Job Search
    • Relevant Links
    • Android Technical Interview Question!
  • Textbook
    • 1. Introduction to the Editor and Views
      • 1.1 Introduction to the Editor
      • 1.2 SDK Management
      • 1.3 Kotlin Overview
      • 1.4 Views
      • 1.5 Android Studio Project Demo + Understanding The Editor
    • 2. Jetpack Compose
      • 2.1 Introduction
      • 2.2 Layouts
      • 2.3 Modifiers
      • 2.4 Animations
      • 2.5 Lazy Lists
      • 2.6 Reactive UI
    • 3. Intents and Manifest
      • 3.1 Activities
      • 3.2 Implicit Intents
      • 3.3 Explicit Intents
      • 3.4 Manifest
      • 3.5 Permissions
      • 3.6 Summary
    • 4. Navigation
      • 4.1 Types of Navigation
      • 4.2 Implementation of the Bottom Navigation Bar
    • 5. Data and Persistent Storage
      • 5.1 Singleton Classes
      • 5.2 Shared Preferences
      • 5.3 Rooms
      • 5.4 Entities
      • 5.5 Data Access Objects
      • 5.6 Databases
    • 5.5 Concurrency
      • 5.5.1 Coroutines
      • 5.5.2 Implementation of Coroutines
      • 5.5.3 Coroutines with Networking Calls
    • 6. Networking and 3rd Party libraries
      • 6.1 HTTP Overview
      • 6.2 3rd Party Libraries
      • 6.3 JSON and Moshi
      • 6.4 Retrofit
      • 6.5 Summary
    • 7. MVVM Design Pattern
      • 7.1 Key Idea
      • 7.2 Implementation Ideas
    • 8. Flows
    • 9. The Art and Ontology of Software
    • 10. 🔥 Firebase
      • 10.1 Setting up Firebase
      • 10.2 Authentication
      • 10.3 Analytics
      • 10.4 Messaging
      • 10.5 Firestore
  • Additional Topics
    • Git and GitHub
    • Exporting to APK
  • Archive
    • Archived Native Android Textbook Pages
      • 1. Layouts and More Views
        • 1.1 File Structure and File Types
        • 1.2 Resource Files
        • 1.3 Button and Input Control
        • 1.4 ViewGroups
        • 1.5 Summary + A Note On Chapter 2 Topics
      • 2. RecyclerViews
        • 2.1 RecyclerViews
        • 2.2 RecyclerView Performance
        • 2.3 Implementation of a Recycler View
        • 2.4 Implementation with Input Controls
        • 2.5 Filtering RecyclerViews
        • 2.6 Recyclerview Demo
      • 3. ListViews and Searching
        • 3.1 ListView vs. RecyclerView
        • 3.2 ListView Performance
        • 3.3 Implementation of a ListView
        • 3.4 Searching in a List View
      • 4. Fragments
        • 4.1 What are Fragments?
        • 4.2 Lifecycle of a Fragment
        • 4.3 Integrating a Fragment into an Activity
        • 4.4 Sharing Data Between Fragments
        • 4.5 Fragment Slide Shows
      • 5. OkHttp
      • 6. Activity Lifecycle
      • 7. Implementation of Tab Layout
    • Fall 2024 Course Material
      • Lecture 1 & Exercise 1: Introduction to Android
      • Lecture 1.5: Beauty of Kotlin
      • Lecture 2 & HW 2: Modifiers, Lazylists and Reactive UI
      • Lecture 3 & HW 3: Animations, Intents and Manifest
      • Lecture 4 & HW 4: Coroutines & Navigation
      • Lecture 5 & HW 5: Persistent Storage, Networking, and JSON Parsing
      • Lecture 6 & HW 6: MVVM, Flows
      • Bonus Lectures & Bonus HW
      • Bonus Lecture: Industry Practice
    • Spring 2024 Course Material
      • Lecture 1 & Exercise 1: Introduction to Android
      • Lecture 4 & HW 4: LazyLists
      • Lecture 6 & HW 6: Networking, Data, and Persistent Storage
    • Spring 2020 Course Material
      • Week 1: Intro to the Editor
      • Week 2: Views and Layouts
      • Week 3: Intent and Manifest
      • Week 4: ListView and RecyclerView
      • Week 5: Fragments
      • Week 6: Networking
    • Spring 2021 Lecture & HW 8: Networking & 3rd Party APIs
    • HackOurCampus Workshop
Powered by GitBook
On this page
  • Callback Interface
  • Higher-order functions

Was this helpful?

  1. Archive
  2. Archived Native Android Textbook Pages
  3. 2. RecyclerViews

2.4 Implementation with Input Controls

Callback Interface

Often times, we’ll want to use the items in the RecyclerView as an entry point to another screen and the simplest way to do so is through an interface inside the adapter class.

For this example, we'll be building on top of the code shown in section 4.3.

1. We can define our own onClick() method in our interface and it can take in as many as parameters as we need.

In this example, our click listener will just take in the position of the item on the list. Just remember that if you plan to use the onClick() method to start a new fragment or activity that you may want to pass in enough information, like a list or a key, to be able to make the correct computation.

CustomAdapter.kt
class CustomAdapter(
    private val dataSet: Array<Book>,
    private val mAdapterOnClickHandler: AdapterOnClickHandler
  )
    : RecyclerView.Adapter<CustomAdapter.ViewHolder>() {

  interface AdapterOnClickHandler {
    // you can define the parameters to be what you need
    fun onClick(position: Int)
  }
}

2. Inside onBindViewHolder we can customize the onClickListeners of our various views to refer to the callback functions we just created! Below, we override the onClickListener of a button defined in our cell! We pass whatever is specified by the onClick method from our button.

CustomAdapter.kt
override fun onBindViewHolder(viewHolder: ViewHolder, position: Int) {
    viewHolder.button.setOnClickListener {
        mAdapterOnClickHandler.onClick(position)
    }
}

3. In our activity or fragment, wherever the adapter is actually created, we’ll be implementing the onClick() method to our custom listener. In this example, the adapter will start a new activity when the item is clicked on.

Don't forget to extend the interface as we did at the header of the MainActivity! Android Studio will automatically tell you to implement the given functions once you do!

MainActivity.kt
class MainActivity : AppCompatActivity(),
   CustomAdapter.AdapterOnClickHandler {
   
   override fun onCreate(Bundle savedInstanceState) {
    ...
    recyclerView.adapter = CustomAdapter(myDataset, this)
    ...
  }
  
  override fun onClick(position: Int) {
    // add code for action to happen on click of the button in your RecyclerView row
    var i = Intent(this, SomeOtherActivity::class.java)
    i.putExtra("position", position)
    startActivity(i)
  }
}

Higher-order functions

If your interface has a small amount of functions (i.e. one or two), the above can be simplified using higher-order functions!

Instead of defining some interface, we can pass the function in directly when creating a new adapter:

class CustomAdapter(
    private val dataSet: Array<Book>,
    private val onItemClick: (Int) -> Unit
  )
    : RecyclerView.Adapter<CustomAdapter.ViewHolder>() {
    
    override fun onBindViewHolder(viewHolder: ViewHolder, position: Int) {
    viewHolder.button.setOnClickListener {
        onItemClick(position)
    }
}

When initializing our adapter in our activity, we can pass in a function with the corresponding type or define it directly:

// An example that defines the function directly
val adapter = CustomAdapter(myDataset) { position -> 
   // The click action you want to perform.
}
Previous2.3 Implementation of a Recycler ViewNext2.5 Filtering RecyclerViews

Last updated 7 months ago

Was this helpful?

Kotlin functions are , which means they can be stored in variables and data structures, and can be passed as arguments to and returned from other . You can perform any operations on functions that are possible for other non-function values.

first-class
higher-order functions