Determine whether UIView is visible to the user?

Question

Is it possible to determine whether my UIView is visible to the user or not?

My View is added as a subview several times into a UITabBarController.

Each instance of this view has an NSTimer that updates the view.

However, I don't want to update a view which is not visible to the user.

Is this possible?

Sam

If you can, would you consider updating your selected answer to the one with the most upvotes—that is, the one that checks .window (by walkingbrad), as the answer that checks .superview (by mahboudz) is not technically correct and has caused bugs for me. – Haematoxylon

Answer 1

You can check if:

• it is hidden, by checking view.hidden
• it is in the view hierarchy, by checking view.superview != nil
• you can check the bounds of a view to see if it is on screen

The only other thing I can think of is if your view is buried behind others and can't be seen for that reason. You may have to go through all the views that come after to see if they obscure your view.

Deputation

I did that this way but forgot to post the solution here :) Thanks (+1) – Sam

How did you accomplish your obscurity check? – Cheatham

Not easily. Check the bounds of all opaque child views, and keep track of portions of your view that aren't obscured to check against the next child subview. To make it easier, you might want to define a few points and if those points are visible, then assume your view is. You can choose whether all points being visible is an indication that your view is visible, or whether any single point visible will satisfy your requirement. – Deputation

the third one works even if UIView is inside another UIView which is inside a scroll view? – Amphibious

What will still fall through is if one of the superviews is hidden. – Daggna

I would add to the list checking an alpha – Harpist

It seems, unfortunately, this is not a comprehensive answer. There are many possible reasons a view might be visible, or not, making it not easily possible to determine. – Ministerial

Answer 2

For anyone else that ends up here:

To determine if a UIView is onscreen somewhere, rather than checking superview != nil, it is better to check if window != nil. In the former case, it is possible that the view has a superview but that the superview is not on screen:

if (view.window != nil) {
    // do stuff
}

Of course you should also check if it is hidden or if it has an alpha > 0.

Regarding not wanting your NSTimer running while the view is not visible, you should hide these views manually if possible and have the timer stop when the view is hidden. However, I'm not at all sure of what you're doing.

Wilscam

ay caramba! just what I needed to kill the cycled animations – Thorathoracic

Sorry I voted this up, it doesnt work. When I do po [self.view recursiveDescription] my subviews are shown in the view hierarchy, yet their view.window is always nil. – Geotaxis

@LogicsaurusRex You can have a view hierarchy that is not currently being shown in the window (hence why I originally re-answered the question). In the case you've outlined here, I imagine that self.view also has a window of nil. Is that the case? (sorry for late reply) – Wilscam

I would buy you a bottle of wine;) – Inpatient

Answer 3

This will determine if a view's frame is within the bounds of all of its superviews (up to the root view). One practical use case is determining if a child view is (at least partially) visible within a scrollview.

Swift 5.x:

func isVisible(view: UIView) -> Bool {
    func isVisible(view: UIView, inView: UIView?) -> Bool {
        guard let inView = inView else { return true }
        let viewFrame = inView.convert(view.bounds, from: view)
        if viewFrame.intersects(inView.bounds) {
            return isVisible(view: view, inView: inView.superview)
        }
        return false
    }
    return isVisible(view: view, inView: view.superview)
}

Older swift versions

func isVisible(view: UIView) -> Bool {
    func isVisible(view: UIView, inView: UIView?) -> Bool {
        guard let inView = inView else { return true }
        let viewFrame = inView.convertRect(view.bounds, fromView: view)
        if CGRectIntersectsRect(viewFrame, inView.bounds) {
            return isVisible(view, inView: inView.superview)
        }
        return false
    }
    return isVisible(view, inView: view.superview)
}

Potential improvements:

• Respect alpha and hidden.
• Respect clipsToBounds, as a view may exceed the bounds of its superview if false.

Alissaalistair

Perfect. I have a stack view as the content of a scroll view and determining which of the arrangedSubviews are (at least partially) visible is exactly what I was looking for. – Rabelais

Thanks for posting this @johngibb. My use case was needing to check if it was completely visible and I found I could achieve this be replacing intersects with contains(_:) – Dd

Answer 4

The solution that worked for me was to first check if the view has a window, then to iterate over superviews and check if:

1. the view is not hidden.
2. the view is within its superviews bounds.

Seems to work well so far.

Swift 3.0

public func isVisible(view: UIView) -> Bool {

  if view.window == nil {
    return false
  }

  var currentView: UIView = view
  while let superview = currentView.superview {

    if (superview.bounds).intersects(currentView.frame) == false {
      return false;
    }

    if currentView.isHidden {
      return false
    }

    currentView = superview
  }

  return true
}

Hallow

Awesome answer. This can fail in UITableView and UIScrollView from what I can tell though. – Lawanda

This worked perfectly for me inside UITableView and UIScrollView. – Dd

Answer 5

I benchmarked both @Audrey M. and @John Gibb their solutions.
And @Audrey M. his way performed better (times 10).
So I used that one to make it observable.

I made a RxSwift Observable, to get notified when the UIView became visible.
This could be useful if you want to trigger a banner 'view' event

import Foundation
import UIKit
import RxSwift

extension UIView {
    var isVisibleToUser: Bool {

        if isHidden || alpha == 0 || superview == nil {
            return false
        }

        guard let rootViewController = UIApplication.shared.keyWindow?.rootViewController else {
            return false
        }

        let viewFrame = convert(bounds, to: rootViewController.view)

        let topSafeArea: CGFloat
        let bottomSafeArea: CGFloat

        if #available(iOS 11.0, *) {
            topSafeArea = rootViewController.view.safeAreaInsets.top
            bottomSafeArea = rootViewController.view.safeAreaInsets.bottom
        } else {
            topSafeArea = rootViewController.topLayoutGuide.length
            bottomSafeArea = rootViewController.bottomLayoutGuide.length
        }

        return viewFrame.minX >= 0 &&
            viewFrame.maxX <= rootViewController.view.bounds.width &&
            viewFrame.minY >= topSafeArea &&
            viewFrame.maxY <= rootViewController.view.bounds.height - bottomSafeArea

    }
}

extension Reactive where Base: UIView {
    var isVisibleToUser: Observable<Bool> {
        // Every second this will check `isVisibleToUser`
        return Observable<Int>.interval(.milliseconds(1000),
                                        scheduler: MainScheduler.instance)
        .map { [base] _ in
            return base.isVisibleToUser
        }.distinctUntilChanged()
    }
}

Use it as like this:

import RxSwift
import UIKit
import Foundation

private let disposeBag = DisposeBag()

private func _checkBannerVisibility() {

    bannerView.rx.isVisibleToUser
        .filter { $0 }
        .take(1) // Only trigger it once
        .subscribe(onNext: { [weak self] _ in
            // ... Do something
        }).disposed(by: disposeBag)
}

Imperforate

@Audrey M answer only checks to see if it's within the screen bounds and not if it's actually visible. John Gibb's answer is the one that actually checks if a view can be seen. – Dd

Answer 6

Tested solution.

func isVisible(_ view: UIView) -> Bool {
    if view.isHidden || view.superview == nil {
        return false
    }

    if let rootViewController = UIApplication.shared.keyWindow?.rootViewController,
        let rootView = rootViewController.view {

        let viewFrame = view.convert(view.bounds, to: rootView)

        let topSafeArea: CGFloat
        let bottomSafeArea: CGFloat

        if #available(iOS 11.0, *) {
            topSafeArea = rootView.safeAreaInsets.top
            bottomSafeArea = rootView.safeAreaInsets.bottom
        } else {
            topSafeArea = rootViewController.topLayoutGuide.length
            bottomSafeArea = rootViewController.bottomLayoutGuide.length
        }

        return viewFrame.minX >= 0 &&
               viewFrame.maxX <= rootView.bounds.width &&
               viewFrame.minY >= topSafeArea &&
               viewFrame.maxY <= rootView.bounds.height - bottomSafeArea
    }

    return false
}

Kaluga

Answer 7

I you truly want to know if a view is visible to the user you would have to take into account the following:

• Is the view's window not nil and equal to the top most window
• Is the view, and all of its superviews alpha >= 0.01 (threshold value also used by UIKit to determine whether it should handle touches) and not hidden
• Is the z-index (stacking value) of the view higher than other views in the same hierarchy.
• Even if the z-index is lower, it can be visible if other views on top have a transparent background color, alpha 0 or are hidden.

Especially the transparent background color of views in front may pose a problem to check programmatically. The only way to be truly sure is to make a programmatic snapshot of the view to check and diff it within its frame with the snapshot of the entire screen. This won't work however for views that are not distinctive enough (e.g. fully white).

For inspiration see the method isViewVisible in the iOS Calabash-server project

Edenedens

Answer 8

The simplest Swift 5 solution I could come up with that worked in my situation (I was looking for a button embedded in my tableViewFooter).

John Gibbs solution also worked but in my cause I did not need all the recursion.

    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        let viewFrame = scrollView.convert(targetView.bounds, from: targetView)
        if viewFrame.intersects(scrollView.bounds) {
            // targetView is visible 
        }
        else {
            // targetView is not visible
        }
    }

Nathannathanael

Answer 9

In viewWillAppear set a value "isVisible" to true, in viewWillDisappear set it to false. Best way to know for a UITabBarController subviews, also works for navigation controllers.

Tempura

yeah, it seems to be the only reliable way – Thorathoracic

Answer 10

Another useful method is didMoveToWindow() Example: When you push view controller, views of your previous view controller will call this method. Checking self.window != nil inside of didMoveToWindow() helps to know whether your view is appearing or disappearing from the screen.

Prestigious

Answer 11

This can help you figure out if your UIView is the top-most view. Can be helpful:

let visibleBool = view.superview?.subviews.last?.isEqual(view)
//have to check first whether it's nil (bc it's an optional) 
//as well as the true/false 
if let visibleBool = visibleBool where visibleBool { value
  //can be seen on top
} else {
  //maybe can be seen but not the topmost view
}

Generic

Answer 12

try this:

func isDisplayedInScreen() -> Bool
{
 if (self == nil) {
     return false
  }
    let screenRect = UIScreen.main.bounds 
    // 
    let rect = self.convert(self.frame, from: nil)
    if (rect.isEmpty || rect.isNull) {
        return false
    }
    // 若view 隐藏
    if (self.isHidden) {
        return false
    }

    // 
    if (self.superview == nil) {
        return false
    }
    // 
    if (rect.size.equalTo(CGSize.zero)) {
        return  false
    }
    //
    let intersectionRect = rect.intersection(screenRect)
    if (intersectionRect.isEmpty || intersectionRect.isNull) {
        return false
    }
    return true
}

Butternut

Answer 13

In case you are using hidden property of view then :

view.hidden (objective C) or view.isHidden(swift) is read/write property. So you can easily read or write

For swift 3.0

if(view.isHidden){
   print("Hidden")
}else{
   print("visible")
}

Armandinaarmando