UITableView inside UICollectionViewCell with the UITableView still scrollable, but touches should got to the collection view

What it looks like

This is what a single CollectionView cell looks like.

+-------------------------------+
| +-------+                     |
| | Image |    Some text        |
| +-------+                     |
|                               |
| +---------------------------+ |
| + Table View row 1          | |
| +---------------------------+ |
| + Table View row 2          | |
| +---------------------------+ |
| + Table View row 3          | |
| +---------------------------+ |
+-------------------------------+

What I would like to achieve

Depending on the data displayed, the entries in the table may or may not be selectable.
But it can always happen that there are more than three rows, so you have to be able to scroll the table vertically.
But now I would also like that for the tables where the individual rows are not selectable, a touch on a table row is passed to the CollectionView so that it recognizes the touch and triggers the appropriate delegate method.

What I've tried so far

Setting tableView.allowsSelection := false causes the rows in a table to be not touchable. However, the tap does not seem to be forwarded to the collection view.

Setting tableView.isUserInteractionEnabled = false causes tap to be forwarded to the collection view, but the table view is no longer scrollable.

Returning nil in func tableView(_ tableView: UITableView, willSelectRowAt indexPath: IndexPath) -> IndexPath? causes the rows in a table to be not touchable. However, the tap does not seem to be forwarded to the collection view.

Overriding func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? and return nil when the rows should not be selectable, causes tap to be forwarded to the collection view, but the table view is no longer scrollable.

Is there any way to achieve this at all?

One approach...

• leave all the table view cells "selectable"
• set .selectionStyle = .none and implement your own visual change to indicate selected
• in your collection view class add a closure to the collection view cell
• in collection view cell class, call that closure when a table row is selected

Here is a complete example...

simple, single-label table view cell class - change contentView background color only if canSelect is true:

class SomeTableCell: UITableViewCell {
	
	static let identifier: String = "SomeTableCell"
	
	var canSelect: Bool = true

	let label = UILabel()
	
	override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
		super.init(style: style, reuseIdentifier: reuseIdentifier)
		commonInit()
	}
	required init?(coder: NSCoder) {
		super.init(coder: coder)
		commonInit()
	}
	private func commonInit() {
		label.translatesAutoresizingMaskIntoConstraints = false
		contentView.addSubview(label)
		let g = contentView.layoutMarginsGuide
		NSLayoutConstraint.activate([
			label.topAnchor.constraint(equalTo: g.topAnchor),
			label.leadingAnchor.constraint(equalTo: g.leadingAnchor),
			label.trailingAnchor.constraint(equalTo: g.trailingAnchor),
			label.bottomAnchor.constraint(equalTo: g.bottomAnchor),
		])
		
		//label.font = .systemFont(ofSize: 12.0, weight: .light)
		label.font = .italicSystemFont(ofSize: 12.0)
		
		// so we can see the framing
		label.backgroundColor = .yellow
	}
	
	override func setSelected(_ selected: Bool, animated: Bool) {
		super.setSelected(selected, animated: animated)
		if canSelect {
			contentView.backgroundColor = selected ? .orange : .clear
		}
	}
	
}

collection view cell class - with image view, label and table view... override isSelected so we can see that the cell is selected... gotTap closure to inform the collection view controller that a table row was selected:

class SomeCollectionCell: UICollectionViewCell, UITableViewDataSource, UITableViewDelegate {
	
	// closure so we can tell the controller that a table row was tapped
	//	whether selectable or not
	var gotTap: ((UICollectionViewCell) -> ())?
	
	static let identifier: String = "SomeCollectionCell"
	
	let imgView = UIImageView()
	let label = UILabel()
	let tableView = UITableView()
	
	var numTableRows: Int = 0 { didSet { tableView.reloadData() } }
	var canSelectRows: Bool = true { didSet { tableView.reloadData() } }
	
	override init(frame: CGRect) {
		super.init(frame: frame)
		commonInit()
	}
	required init?(coder: NSCoder) {
		super.init(coder: coder)
		commonInit()
	}
	private func commonInit() {

		[imgView, label, tableView].forEach { v in
			v.translatesAutoresizingMaskIntoConstraints = false
			contentView.addSubview(v)
		}
		let g = contentView.layoutMarginsGuide
		NSLayoutConstraint.activate([
			
			imgView.topAnchor.constraint(equalTo: g.topAnchor),
			imgView.leadingAnchor.constraint(equalTo: g.leadingAnchor),
			imgView.widthAnchor.constraint(equalToConstant: 60.0),
			imgView.heightAnchor.constraint(equalToConstant: 40.0),
			
			label.leadingAnchor.constraint(equalTo: imgView.trailingAnchor, constant: 8.0),
			label.trailingAnchor.constraint(equalTo: g.trailingAnchor),
			label.centerYAnchor.constraint(equalTo: imgView.centerYAnchor),
			
			tableView.topAnchor.constraint(equalTo: imgView.bottomAnchor, constant: 8.0),
			tableView.leadingAnchor.constraint(equalTo: g.leadingAnchor),
			tableView.trailingAnchor.constraint(equalTo: g.trailingAnchor),
			tableView.bottomAnchor.constraint(equalTo: g.bottomAnchor),

		])
		
		tableView.register(SomeTableCell.self, forCellReuseIdentifier: SomeTableCell.identifier)
		tableView.dataSource = self
		tableView.delegate = self
		
		// element properties
		imgView.contentMode = .scaleAspectFit
		label.font = .systemFont(ofSize: 13.0, weight: .light)
		contentView.layer.borderWidth = 1
		contentView.layer.borderColor = UIColor.darkGray.cgColor
		
		// so we can see the framing
		imgView.backgroundColor = UIColor(white: 0.95, alpha: 1.0)
		label.backgroundColor = .cyan
		tableView.backgroundColor = .green
	}
	
	func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
		return numTableRows
	}
	func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
		let c = tableView.dequeueReusableCell(withIdentifier: SomeTableCell.identifier, for: indexPath) as! SomeTableCell
		if canSelectRows {
			c.label.text = "Sel row: \(indexPath.row)"
			c.canSelect = true
		} else {
			c.label.text = "NON-Sel row: \(indexPath.row)"
			c.canSelect = false
		}
		c.selectionStyle = .none
		return c
	}
	func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
		// either Always call the closure
		gotTap?(self)
		
		// or, only call it if the table rows are "not selectable"
		//if !canSelectRows {
		//	gotTap?(self)
		//}
	}
	
	override var isSelected: Bool {
		didSet {
			contentView.backgroundColor = isSelected ? .systemBlue : .systemBackground
		}
	}
}

view controller class - we'll create 30 "data" elements, with the number of table view rows for each collection view cell. We will "disable" table row selection on every 3rd item:

class SomeViewController: UIViewController, UICollectionViewDataSource, UICollectionViewDelegate {
	
	var collectionView: UICollectionView!
	
	var myData: [Int] = []
	
	override func viewDidLoad() {
		super.viewDidLoad()
		
		let fl = UICollectionViewFlowLayout()
		fl.scrollDirection = .horizontal
		fl.itemSize = .init(width: 160.0, height: 164.0)
		
		collectionView = UICollectionView(frame: .zero, collectionViewLayout: fl)
		collectionView.translatesAutoresizingMaskIntoConstraints = false
		view.addSubview(collectionView)
		
		let g = view.safeAreaLayoutGuide
		NSLayoutConstraint.activate([
			collectionView.topAnchor.constraint(equalTo: g.topAnchor, constant: 20.0),
			collectionView.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 20.0),
			collectionView.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: -20.0),
			collectionView.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: -20.0),
		])
		
		collectionView.register(SomeCollectionCell.self, forCellWithReuseIdentifier: SomeCollectionCell.identifier)
		collectionView.dataSource = self
		collectionView.delegate = self
		
		// let's generate data...
		//	30 items, each with random 3-to-12 table rows
		for _ in 0..<30 {
			myData.append(Int.random(in: 3...12))
		}
		
	}
	
	func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
		return myData.count
	}
	func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
		let c = collectionView.dequeueReusableCell(withReuseIdentifier: SomeCollectionCell.identifier, for: indexPath) as! SomeCollectionCell
		c.imgView.image = UIImage(systemName: "\(indexPath.item).circle.fill")
		c.label.text = "Item: \(indexPath.item)"
		c.numTableRows = myData[indexPath.item]
		
		// every 3rd item will have non-selectable table rows
		c.canSelectRows = indexPath.row % 3 != 0
		
		// closure so the collection view cell can tell us the table was tapped
		c.gotTap = { [weak self] c in
			guard let self = self,
				  let indexPath = self.collectionView.indexPath(for: c)
			else { return }
			
			// tell the collection view to select that item
			self.collectionView.selectItem(at: indexPath, animated: true, scrollPosition: [])
			
			// call custom func to "do something"
			self.myCollectionView(self.collectionView, didSelectItemAt: indexPath)
		}
		return c
	}
	
	func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
		// call custom func to "do something"
		myCollectionView(collectionView, didSelectItemAt: indexPath)
	}
	private func myCollectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
		print("Selected item: \(indexPath.item)")
	}
}