UISearchController: show results even when search bar is empty

Question

As I understand, the default behaviour of UISearchController is:

On tapping search bar, background is dimmed and 'cancel' button is shown. SearchResultsController is not shown till this point.
SearchResultsController is displayed only if search bar is not empty.

I want to display SearchResultsController even when search bar is empty but selected (i.e is case 1 above).

Simply put, instead of background dimming, I would like to show Search results.

Is there a way for doing this?

More Clarification:

I am not using UISearchController to filter results shown on the view on which it is shown, but some other unrelated results. It will be like what facebook does on its 'News Feed'. Tapping on search bar shows search suggestions initially and then, when we start editing, it shows search results which might not be related to news feed.

score 43 · Answer 1 · answered Mar 13 '16 at 06:48

You can simply implement the UISearchResultsUpdating protocol and set the results controller view to always show in updateSearchResultsForSearchController:

 func updateSearchResultsForSearchController(searchController: UISearchController) {

   // Always show the search result controller
   searchController.searchResultsController?.view.hidden = false

   // Update your search results data and reload data
   ..
}

This works because the method is called even when the search bar is activated, without any text.

This worked for me, and it's way simpler than the other suggested methods. — mrks_, Aug 11 '16 at 17:19

score 35 · Accepted Answer · edited May 23 '17 at 12:18

35

If your searchBar is active but has no text, the underlying tableView results are shown. That's the built-in behavior, and the reason why searchResultsController is hidden for that state.

To change the behavior when search is active but not filtering, you're going to have to show the searchResultsController when it is normally still hidden.

There may be a good way to accomplish this via <UISearchResultsUpdating> and updateSearchResultsForSearchController:. If you can solve it via the protocol, that's the preferred way to go.

If that doesn't help, you're left with hacking the built-in behavior. I wouldn't recommend or rely on it, and it's going to be fragile, but here's an answer if you choose that option:

Make sure your tableViewController conforms to <UISearchControllerDelegate>, and add

self.searchController.delegate = self;

Implement willPresentSearchController:

- (void)willPresentSearchController:(UISearchController *)searchController
{
    dispatch_async(dispatch_get_main_queue(), ^{
        searchController.searchResultsController.view.hidden = NO;
    });
}

This makes the searchResultsController visible after its UISearchController set it to hidden.

Implement didPresentSearchController:

- (void)didPresentSearchController:(UISearchController *)searchController
{
    searchController.searchResultsController.view.hidden = NO;
}

For a better way to work around the built-in behavior, see malhal's answer.

edited May 23 '17 at 12:18

Community

1
1

answered Jun 13 '15 at 01:16

Thanks!! I tried the hack and it worked. One question, what is 'dispatch_async' for? – optimus Jun 13 '15 at 18:37
Dispatch_async schedules the method to be called in an upcoming run loop. In effect, it's adding a slight delay to the method being called, so we can unhide the `searchResultsController` *after* the search controller marked it hidden. – Jun 13 '15 at 18:43
Very rarely, the screen flickers from dim to the view. But works, saved me a lot of pain. – atastrophic Oct 29 '15 at 21:51
you can easily set it not to dim to fix that flicker – malhal Jan 07 '16 at 01:04
3

To add to the answer, I also set `view.hidden = false` on the `updateSearchResultsForSearchController` delegate method, to keep the results view controller visible even if the user clears the search text. – Eneko Alonso May 08 '16 at 02:10
^^^ I also added view.hidden = NO to updateSearchResultsForSearchController to make the results controller visible even if the user clears the search text. Now this answer is perfect. – coolcool1994 Nov 12 '17 at 15:35

Simon Wang · Answer 3 · 2019-08-22T05:34:49.940

Updated for iOS 13

From iOS13, we got system API support for this behaviour. You can set the property showsSearchResultsController = true

WWDC screenshot

For iOS 12 and below

I am recently working on UISearchController. I want to show search history in searchResultsController when search bar is empty. So searchResultsController needs to show up whenever UISearchController gets presented.

Here, I use another solution to make the searchResultsController always visible by overriding the hidden property in a custom view.

for example, my searchResultsController is a UITableViewController. I create a VisibleTableView as a subclass of UITableView, and then change the UITableView custom class of searchResultsController to VisibleTableView in xib or storyboard. This way, my searchResultsController will never be hidden by UISearchController.

The good things here:

Easier to implement than KVO.
No delay to show searchResultsController. Flipping the hidden flag in "updateSearchResults" delegate method works, but there is a delay to show the searchResultsController.
It does't reset the hidden flag, so there is no UI gap/jumping between hidden and visible.

Swift 3 sample code:

class VisibleTableView: UITableView {
override var isHidden: Bool {
    get {
        return false
    }
    set {
        // ignoring any settings
    }
}
}

Looks promising! Did you use it in production? Is it reliable? — Roi Mulia, Nov 12 '18 at 22:36
Hi @RoiMulia, yes, the solution is very reliable. We have been using it in a production for 2 years. — Simon Wang, Nov 13 '18 at 01:35
for some reason VisibleTableView doesn't work if you use UIViewController + IBOutlet, even if in storyboard your tableview is VisibleTableView. isHidden just never called — Timur Suleimanov, Apr 29 '20 at 16:55

score 14 · Answer 4 · answered Oct 30 '15 at 19:59

I have tried PetahChristian solution, the preload result did show up when we first focus the searchbar, but when we enter something then clear it, the preload results will not reappear.

I came up with another solution. We only need to add a delegate into SearchResultsController and call it when our searchController.searchBar.text is empty. Something like this:

SearchResultsController:

protocol SearchResultsViewControllerDelegate {
   func reassureShowingList() -> Void
}

class FullSearchResultsViewController: UIViewController, UISearchResultsUpdating{
   var delegate: SearchResultsViewControllerDelegate?
   ...
   func updateSearchResultsForSearchController(searchController: UISearchController) {
    let query = searchController.searchBar.text?.trim()
    if query == nil || query!.isEmpty {
        ...
        self.delegate?.reassureShowingList()
        ...
    }
    ...
}

And in the controller contains the SearchController, we add our delegate:

self.searchResultsController.delegate = self
func reassureShowingList() {
    searchController.searchResultsController!.view.hidden = false
}

Great solution! I had to call unhiding searchResultsController on main thread as well, then works perfectly. — rafalkitta, Dec 04 '15 at 11:13
Personally, I think this should be accepted as the answer! It works seamlessly! — HunTer DRF, Feb 25 '16 at 21:59

malhal · Answer 5 · 2016-03-09T21:46:58.250

With tricky things like this I recommend the sledge hammer approach! That is to detect when something tries to make it hidden and when it does, change it back. This can be done via KVO (Key Value Observing). This will work no matter what, without having to handle all the intricacies of the search bar. Sorry the code is complicated but KVO is an older style API but my code follows recommend practice. In your SearchResultsViewController put this:

static int kHidden;

@implementation SearchResultsViewController

-(void)viewDidLoad{
    [super viewDidLoad];
    [self.view addObserver:self
                   forKeyPath:@"hidden"
                      options:(NSKeyValueObservingOptionNew |
                               NSKeyValueObservingOptionOld)
                      context:&kHidden];
}

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context {
    // if it was our observation
    if(context == &kHidden){
        // if the view is hidden then make it visible.
        if([[change objectForKey:NSKeyValueChangeNewKey] boolValue]){
            self.view.hidden = NO;
        }
    }
    else{
        // if necessary, pass the method up the subclass hierarchy.
        if([super respondsToSelector:@selector(observeValueForKeyPath:ofObject:change:context:)]){
            [super observeValueForKeyPath:keyPath
                                 ofObject:object
                                   change:change
                                  context:context];
        }
    }
}

- (void)dealloc
{
    [self.view removeObserver:self forKeyPath:@"hidden"];
}

// Here have the rest of your code for the search results table.

@end

This works in all cases including if the text is cleared.

Lastly, to prevent the table doing an ugly fade to grey then to white when the search activates, use this:

self.searchController.dimsBackgroundDuringPresentation = NO;

For a less verbose version of the same thing, see my answer. — skensell, Mar 18 '16 at 14:04

score 8 · Answer 6 · edited Aug 16 '18 at 12:32

Swift 3 Version:

If your searchResultController is not nil and you are using a separate table view controller to show the search results, then you can make that table view controller conform to UISearchResultUpdating and in the updateSearchResults function, you can simply unhide the view.

func updateSearchResults(for searchController: UISearchController) {
    view.hidden = false
}

Swift 4 Version:

func updateSearchResults(for searchController: UISearchController) {
    view.isHidden = false
}

matt · Answer 7 · 2017-09-11T13:12:30.743

What is being hidden is the search results controller's view. Therefore it is sufficient to unhide it any time it might be hidden. Simply do as follows in the search results controller:

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    self.view.isHidden = false
}

func updateSearchResults(for searchController: UISearchController) {
    self.view.isHidden = false
    // ... your other code goes here ...
}

Now the results view (i.e. the table view) is always visible, even when the search bar text is empty.

By the way, the iOS Mail app behaves like this, and I assume that's how it's implemented (unless Apple has access to some secret private UISearchController setting).

[Tested in iOS 10 and iOS 11; I didn't test on any earlier system.]

I know this comment is useless, but this answer is underrated — saurabh, Mar 09 '18 at 07:32

Niels · Answer 8 · 2017-02-14T00:38:49.400

The Swift 2.3 version of @malhal's approach:

class SearchResultsViewController : UIViewController {
    var context = 0

    override func viewDidLoad() {
        super.viewDidLoad()
        // Add observer
        view.addObserver(self, forKeyPath: "hidden", options: [ .New, .Old ], context: &context)
    }

    deinit {
        view.removeObserver(self, forKeyPath: "hidden")
    }

    override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
        if context == &self.context {
            if change?[NSKeyValueChangeNewKey] as? Bool == true {
                view.hidden = false
            }
        } else {
            super.observeValueForKeyPath(keyPath, ofObject: object, change: change, context: context)
        }
    }
}

Lausbert · Answer 9 · 2017-12-13T10:24:20.587

Swift 4 version of malhals answer:

class SearchController: UISearchController {

    private var viewIsHiddenObserver: NSKeyValueObservation?

    override func viewDidLoad() {
        super.viewDidLoad()

        viewIsHiddenObserver = self.searchResultsController?.view.observe(\.hidden, changeHandler: { [weak self] (view, _) in
            guard let searchController = self else {return}
            if view.isHidden && searchController.searchBar.isFirstResponder {
            view.isHidden = false
            }
        })

    }

}

Please note the [weak self]. Otherwise you would introduce a retain cycle.

score 0 · Answer 10 · answered Jun 11 '15 at 20:05

0

I think you are mistaken.

SearchResultsController only appears when there are results. This is slightly different than your interpretation.

The results are loaded manually based on the text in the search bar. So you can intercept it if the search bar is empty and return your own set of results.

answered Jun 11 '15 at 20:05

Fogmeister

76,236
42
207
306

I always have results (even for empty search bar). Where should I intercept and 'return' it? setting property 'active' to YES in 'searchBarTextDidBeginEditing' is not working. – optimus Jun 11 '15 at 20:40
On a train at the moment so can't look up method names. What code are you using to return results? – Fogmeister Jun 11 '15 at 20:42
I am not returning the results anywhere. My SearchResultsController is a separate view controller in which the results are set in method 'updateSearchResultsForSearchController'. The method is called by UISearchController when text in search bar changes or 'active' is set to yes. This is working fine when I have some text in search bar. – optimus Jun 11 '15 at 20:49

score 0 · Answer 11 · answered Jun 12 '15 at 06:50

0

If you don't want to dim the results, set the dimsBackgroundDuringPresentation property to false.

This will make sure that the underlying content is not dimmed during a search.

You will also have to make sure you return results even when the searchText is empty otherwise an empty tableview will be displayed.

answered Jun 12 '15 at 06:50

Praveen Gowda I V

9,569
4
41
49

Dimming is not my concern, not showing results controller is. Please see more clarification that I have added. – optimus Jun 12 '15 at 07:06

score 0 · Answer 12 · answered Mar 18 '16 at 14:02

0

I spent a lot of time with this, and ultimately the solution I went with is like @malhals's, but the amount of code is significantly reduced by using facebook's KVOController: https://github.com/facebook/KVOController . Another advantage here is that if your searchResultsController is a UINavigationController then you don't need to subclass it just to add @malhal's code.

// always show searchResultsController, even if text is empty
[self.KVOController observe:self.searchController.searchResultsController.view keyPath:@"hidden" options:NSKeyValueObservingOptionNew block:^(id observer, UIView* view, NSDictionary *change) {
    if ([change[NSKeyValueChangeNewKey] boolValue] == YES) {
        view.hidden = NO;
    }
}];
self.searchController.dimsBackgroundDuringPresentation = NO;

answered Mar 18 '16 at 14:02

skensell

1,421
12
21

Blocks with KVO crash and looks like Facebooks library has the same issues – malhal Mar 19 '16 at 17:57
Facebook's library has only one open issue, and it's when you observe self like `[self.KVOController observe:self keypath:...`. I'm using the above code and there is no retain cycle nor crash. – skensell Mar 19 '16 at 22:02
The issue is with dealloc and multiple instances of the view controller. If the observer isn't removed correctly then it will crash. Maybe try this one as it correctly uses dealloc: https://github.com/jpmhouston/TotalObserver – malhal Mar 20 '16 at 01:54

score 0 · Answer 13 · answered Mar 26 '16 at 19:26

The easiest way is to use ReactiveCocoa with this extension https://github.com/ColinEberhardt/ReactiveTwitterSearch/blob/master/ReactiveTwitterSearch/Util/UIKitExtensions.swift

        presentViewController(sc, animated: true, completion: {
            sc.searchResultsController?.view.rac_hidden.modify({ value -> Bool in
                return false
            })
        } )

where sc is your UISearchController

score 0 · Answer 14 · answered Nov 21 '17 at 09:51

I really liked Simon Wang's answer and worked with it and this is what I did and it works perfectly:

I subclass the UISearchController in my custom class:

class CustomClass: UISearchController {
  override var searchResultsController: UIViewController? {
    get {
      let viewController = super.searchResultsController
      viewController?.view.isHidden = false
      return viewController
    }
    set {
      // nothing
    }
  }
}

Also make sure you don't have this anywhere in your code:

self.resultsSearchController.isActive = true

resultsSearchController is my UISearchController

Gaurav Pandey · Answer 15 · 2021-09-07T12:24:45.873

Simply what I was using this case

func updateSearchResults(for searchController: UISearchController) {
    if let inputText = searchController.searchBar.text, !inputText.isEmpty {
            self.view.isHidden = false
    }
}

where self.view is a view of "searchResultsController" during initialisation of UISearchController.

 var searchController = UISearchController(searchResultsController: searchResultsController)

UISearchController: show results even when search bar is empty

15 Answers15

Linked

Related