Adapter — ce este, modelul de transformare a interfețelor pentru dezvoltarea mobilă

Ce este modelul Adapter?

Adapter — model structural care rezolvă problema incompatibilității interfețelor. Înfășoară un obiect (Adaptee) într-o clasă (Adapter) cu interfața așteptată de client (Target). Clientul lucrează cu Target, fără să știe de existența Adaptee. Aceasta este o variație a modelului Wrapper.

// Clasă existentă cu interfață incompatibilă
class LegacyAuthApi {
    fun loginWithToken(token: String): Map {
        return mapOf("status" to "ok", "user_id" to 42)
    }
}

// Interfață țintă (ce așteaptă clientul)
interface AuthService {
    suspend fun login(credentials: Credentials): Result
}

// Adapter — transformă LegacyAuthApi în AuthService
class LegacyAuthAdapter(
    private val legacyApi: LegacyAuthApi
) : AuthService {
    override suspend fun login(credentials: Credentials): Result {
        val token = "${credentials.login}:${credentials.password}"
            .encodeToByteArray().let { Base64.encodeToString(it) }
        val response = legacyApi.loginWithToken(token)
        return if (response["status"] == "ok") {
            Result.success(User(response["user_id"] as Int))
        } else {
            Result.failure(AuthException("Login failed"))
        }
    }
}

LegacyAuthAdapter transformă apelul login(credentials) în loginWithToken(token) pentru API-ul vechi. Clientul (ViewModel) lucrează prin interfața AuthService și nu știe că sub ea se află cel mai nou Firebase Auth sau un API vechi de zece ani. Acest lucru permite înlocuirea implementărilor fără a modifica codul clientului.

Adapter în Android: RecyclerView și ListAdapter

RecyclerView.Adapter — cea mai răspândită implementare a modelului Adapter în Android. Transformă datele (o listă de obiecte) în ViewHolder-uri pe care RecyclerView le afișează pe ecran. Odată cu apariția ListAdapter (Android Architecture Components), modelul a primit suport încorporat pentru calculul diferențelor pentru animația modificărilor.

class UserAdapter(
    private val onItemClick: (User) -> Unit
) : ListAdapter(DiffCallback()) {

    override fun onCreateViewHolder(
        parent: ViewGroup,
        viewType: Int
    ): UserViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_user, parent, false)
        return UserViewHolder(view)
    }

    override fun onBindViewHolder(
        holder: UserViewHolder,
        position: Int
    ) {
        holder.bind(getItem(position), onItemClick)
    }

    class UserViewHolder(itemView: View) :
        RecyclerView.ViewHolder(itemView) {
        
        private val tvName = itemView.findViewById(R.id.tvName)
        
        fun bind(user: User, click: (User) -> Unit) {
            tvName.text = user.name
            itemView.setOnClickListener { click(user) }
        }
    }

    private class DiffCallback : DiffUtil.ItemCallback() {
        override fun areItemsTheSame(old: User, new: User) = old.id == new.id
        override fun areContentsTheSame(old: User, new: User) = old == new
    }
}

UserAdapter folosește ListAdapter cu DiffUtil pentru redarea eficientă a listei. Când datele sunt actualizate, DiffCallback calculează diferența dintre lista veche și cea nouă, iar RecyclerView animează doar elementele modificate — fără a redesena întreaga listă. Acesta este avantajul cheie față de ListView-ul mai vechi, care necesita notifyDataSetChanged() manual.

Adapter în iOS: UITableView și DiffableDataSource

UITableViewDataSource — este simultan atât modelul Adapter, cât și DataSource. Transformă datele modelului în celule de tabel. Din iOS 13, Apple a introdus DiffableDataSource — un înlocuitor modern care, asemenea ListAdapter în Android, calculează automat modificările și animează actualizările.

class UserTableViewAdapter: NSObject, UITableViewDataSource {
    var items: [User] = []
    
    func tableView(_ tableView: UITableView,
                    numberOfRowsInSection section: Int) -> Int {
        items.count
    }
    
    func tableView(_ tableView: UITableView,
                    cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(
            withIdentifier: "UserCell", for: indexPath)
        let user = items[indexPath.row]
        cell.textLabel?.text = user.name
        return cell
    }
}

// Versiune modernă: DiffableDataSource
enum Section { case main }

class ModernUserAdapter {
    var dataSource: UITableViewDiffableDataSource<Section, User>!
    
    func configure(for tableView: UITableView) {
        dataSource = UITableViewDiffableDataSource(
            tableView: tableView
        ) { tableView, indexPath, user in
            let cell = tableView.dequeueReusableCell(
                withIdentifier: "UserCell", for: indexPath)
            cell.textLabel?.text = user.name
            return cell
        }
    }
    
    func update(with users: [User]) {
        var snapshot = NSDiffableDataSourceSnapshot<Section, User>()
        snapshot.appendSections([.main])
        snapshot.appendItems(users)
        dataSource.apply(snapshot, animatingDifferences: true)
    }
}

ModernUserAdapter cu DiffableDataSource animează automat modificările la actualizarea datelor: elementele apar, dispar sau se deplasează cu animații line. DiffableDataSource din iOS și ListAdapter din Android rezolvă aceeași sarcină cu API-uri diferite, dar cu aceeași logică — calculul diferențelor + animație automată.

Object Adapter vs Class Adapter

Object Adapter folosește compoziția: adapterul conține o referință către obiectul Adaptee și îi delegă apelurile. Class Adapter folosește moștenirea: adapterul moștenește Adaptee și implementează simultan interfața țintă. În Java, Swift și Kotlin, Class Adapter este imposibil din cauza lipsei moștenirii multiple — rămâne doar Object Adapter.

În dezvoltarea mobilă se folosește doar Object Adapter. RecyclerView.Adapter conține referințe către date și LayoutInflater, UITableViewDataSource conține un array de elemente. Compoziția face codul mai flexibil și mai testabil comparativ cu moștenirea.

Exemple de Adapter în proiecte reale

Adapter se aplică nu doar pentru liste. Să examinăm trei scenarii din practica dezvoltării mobile, unde modelul rezolvă problema integrării componentelor incompatibile.

Fiecare Adapter încapsulează logica de transformare: GsonAdapter traduce un string JSON într-un obiect prin @SerializedName, PushServiceAdapter abstrage înregistrarea token-ului pentru diferite platforme. Clientul (logica de business) lucrează cu o interfață unică și nu depinde de o implementare concretă.

Erori tipice la implementarea Adapter

Erorile în implementarea Adapter duc la încetinirea listelor, scurgeri de memorie și bug-uri de actualizare a datelor. Să analizăm trei probleme frecvente.

Operații grele în onBindViewHolder

onBindViewHolder este apelat pentru fiecare celulă la derulare. Crearea de obiecte, parsarea JSON sau interogările bazei de date în această metodă duc la tremurul listei (frame drops). Soluție: toate calculele grele să fie făcute dinainte, transmitând datele gata pregătite către adapter. Pentru imagini, folosiți biblioteci cu cache — Glide, Coil, Kingfisher.

Ignorarea DiffUtil / DiffableDataSource

Apelarea notifyDataSetChanged() la fiecare actualizare redesenează întreaga listă, provocând pâlpâiri și pierderea focusului pe câmpurile de intrare. Soluție: folosiți ListAdapter cu DiffUtil în Android sau DiffableDataSource în iOS. Calculul diferențelor durează <1 ms pentru liste de până la 1000 de elemente și asigură animații line.

Stocarea obiectelor grele în adapter

Adapterul trăiește cât RecyclerView/UITableView. Stocarea Bitmap sau a array-urilor mari în adapter duce la scurgeri de memorie la schimbarea configurației (rotirea ecranului, schimbarea temei). Soluție: adapterul ar trebui să stocheze doar modele de date ușoare (data class / struct), iar resursele grele să le încarce prin ViewHolder la cerere.