List ve Scroll Performance

List Performance Optimization

Android RecyclerView Advanced Techniques

ViewHolder Pattern Optimization

class OptimizedViewHolder(private val binding: ItemBinding) : 
    RecyclerView.ViewHolder(binding.root) {
    
    fun bind(item: DataItem) {
        // Minimize findViewById calls
        binding.apply {
            title.text = item.title
            subtitle.text = item.subtitle
            // Use data binding for performance
        }
    }
}

DiffUtil for Efficient Updates

class ItemDiffCallback : DiffUtil.ItemCallback<DataItem>() {
    override fun areItemsTheSame(oldItem: DataItem, newItem: DataItem): Boolean {
        return oldItem.id == newItem.id
    }
    
    override fun areContentsTheSame(oldItem: DataItem, newItem: DataItem): Boolean {
        return oldItem == newItem
    }
    
    override fun getChangePayload(oldItem: DataItem, newItem: DataItem): Any? {
        // Return specific change information
        return when {
            oldItem.title != newItem.title -> "title_changed"
            oldItem.subtitle != newItem.subtitle -> "subtitle_changed"
            else -> null
        }
    }
}

iOS UICollectionView Performance

Cell Pre-fetching

class PerformantCollectionViewController: UICollectionViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Enable prefetching
        collectionView.isPrefetchingEnabled = true
        collectionView.prefetchDataSource = self
    }
}

extension PerformantCollectionViewController: UICollectionViewDataSourcePrefetching {
    func collectionView(_ collectionView: UICollectionView, prefetchItemsAt indexPaths: [IndexPath]) {
        // Prefetch data for upcoming cells
        for indexPath in indexPaths {
            loadData(for: indexPath)
        }
    }
}

Flutter List Performance

Efficient ListView Implementation

class PerformantListView extends StatelessWidget {
  final List<Item> items;
  
  const PerformantListView({Key? key, required this.items}) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemCount: items.length,
      // Use item extent for better performance
      itemExtent: 80.0,
      itemBuilder: (context, index) {
        return RepaintBoundary(
          child: ItemWidget(item: items[index]),
        );
      },
    );
  }
}

Infinite Scroll Implementation

Android Pagination with Paging 3

class ItemPagingSource : PagingSource<Int, Item>() {
    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Item> {
        return try {
            val page = params.key ?: 1
            val response = apiService.getItems(page, params.loadSize)
            
            LoadResult.Page(
                data = response.items,
                prevKey = if (page == 1) null else page - 1,
                nextKey = if (response.hasMore) page + 1 else null
            )
        } catch (e: Exception) {
            LoadResult.Error(e)
        }
    }
}

iOS Pagination Implementation

class PaginatedCollectionViewController: UICollectionViewController {
    private var items: [Item] = []
    private var isLoading = false
    private var hasMoreData = true
    
    override func scrollViewDidScroll(_ scrollView: UIScrollView) {
        let offsetY = scrollView.contentOffset.y
        let contentHeight = scrollView.contentSize.height
        let frameHeight = scrollView.frame.size.height
        
        if offsetY > contentHeight - frameHeight - 200 {
            loadMoreDataIfNeeded()
        }
    }
    
    private func loadMoreDataIfNeeded() {
        guard !isLoading && hasMoreData else { return }
        
        isLoading = true
        // Load more data
    }
}

Performance Optimization Techniques

Memory Management

// Android Memory Optimization
class MemoryEfficientAdapter : RecyclerView.Adapter<ViewHolder>() {
    override fun onViewRecycled(holder: ViewHolder) {
        super.onViewRecycled(holder)
        // Clear resources when view is recycled
        holder.clearResources()
    }
}

Scroll Performance Monitoring

class ScrollPerformanceMonitor {
    private var frameDropCount = 0
    
    fun monitorScrollPerformance(recyclerView: RecyclerView) {
        recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
                // Monitor for janky scrolling
                if (isFrameDropped()) {
                    frameDropCount++
                }
            }
        })
    }
}