BookmarkListController.m

/*
 bookmarks and active session view controller
 
 Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz
 
 This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
 If a copy of the MPL was not distributed with this file, You can obtain one at
 http://mozilla.org/MPL/2.0/.
 */
 
#import "BookmarkListController.h"
#import "Utils.h"
#import "BookmarkEditorController.h"
#import "RDPSessionViewController.h"
#import "Toast+UIView.h"
#import "Reachability.h"
#import "GlobalDefaults.h"
 
// currently, session section is unused. so hide it
#define SHOW_SESSIONS_SECTION 0
 
#define SECTION_SESSIONS 0
#define SECTION_BOOKMARKS 1
#define NUM_SECTIONS 2
 
@interface BookmarkListController (Private)
#pragma mark misc functions
- (void)performSearch:(NSString *)searchText;
- (void)askToSaveTemporaryBookmark;
#pragma mark Persisting bookmarks
- (void)scheduleWriteBookmarksToDataStore;
- (void)writeBookmarksToDataStore;
- (void)scheduleWriteManualBookmarksToDataStore;
- (void)writeManualBookmarksToDataStore;
- (void)readManualBookmarksFromDataStore;
- (void)writeArray:(NSArray *)bookmarks toDataStoreURL:(NSURL *)url;
- (NSMutableArray *)arrayFromDataStoreURL:(NSURL *)url;
- (NSURL *)manualBookmarksDataStoreURL;
- (NSURL *)connectionHistoryDataStoreURL;
@end
 
@implementation BookmarkListController
 
@synthesize searchBar = _searchBar, tableView = _tableView, sessTableCell = _sessTableCell;
 
// The designated initializer.  Override if you create the controller programmatically and want to
// perform customization that is not appropriate for viewDidLoad.
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
  if ((self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil]))
  {
    // load bookmarks
    [self readManualBookmarksFromDataStore];
 
    // load connection history
    [self readConnectionHistoryFromDataStore];
 
    // init search result array
    _manual_search_result = nil;
 
    // register for session notifications
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(sessionDisconnected:)
                                                 name:TSXSessionDidDisconnectNotification
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(sessionFailedToConnect:)
                                                 name:TSXSessionDidFailToConnectNotification
                                               object:nil];
 
    // set title and tabbar controller image
    [self setTitle:NSLocalizedString(@"Connections",
                                     @"'Connections': bookmark controller title")];
    [self setTabBarItem:[[[UITabBarItem alloc]
                            initWithTabBarSystemItem:UITabBarSystemItemBookmarks
                                                 tag:0] autorelease]];
 
    // init reachability detection
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(reachabilityChanged:)
                                                 name:kReachabilityChangedNotification
                                               object:nil];
 
    // init other properties
    _active_sessions = [[NSMutableArray alloc] init];
    _temporary_bookmark = nil;
  }
  return self;
}
 
- (void)loadView
{
  [super loadView];
}
 
// Implement viewDidLoad to do additional setup after loading the view, typically from a nib.
- (void)viewDidLoad
{
  [super viewDidLoad];
 
  // set edit button to allow bookmark list editing
  [[self navigationItem] setRightBarButtonItem:[self editButtonItem]];
 
  // set margin
  [_tableView setPreservesSuperviewLayoutMargins:YES];
  [_searchBar setPreservesSuperviewLayoutMargins:YES];
 
  // set self-sizing rows
  [_tableView setEstimatedRowHeight:UITableViewAutomaticDimension];
}
 
- (void)viewWillAppear:(BOOL)animated
{
  [super viewWillAppear:animated];
 
  // in case we had a search - search again cause the bookmark searchable items could have changed
  if ([[_searchBar text] length] > 0)
    [self performSearch:[_searchBar text]];
 
  // to reflect any bookmark changes - reload table
  [_tableView reloadData];
}
 
- (void)viewDidAppear:(BOOL)animated
{
  [super viewDidAppear:animated];
 
  // a quick connect session ended while its view was on top
  if (_temporary_bookmark)
    [self askToSaveTemporaryBookmark];
}
 
// recalc safe area for modern device
- (void)viewSafeAreaInsetsDidChange
{
  [super viewSafeAreaInsetsDidChange];
  [[self view] setNeedsLayout];
}
 
- (void)viewDidLayoutSubviews
{
  [super viewDidLayoutSubviews];
 
  const CGRect bounds = [[self view] bounds];
  const UIEdgeInsets safe = [[self view] safeAreaInsets];
  const CGFloat x = safe.left;
  const CGFloat w = bounds.size.width - safe.left - safe.right;
  CGFloat searchH = CGRectGetHeight([_searchBar frame]);
 
  [_searchBar setFrame:CGRectMake(x, safe.top, w, searchH)];
  [_tableView
      setFrame:CGRectMake(x, safe.top + searchH, w, bounds.size.height - safe.top - searchH)];
}
 
- (void)viewWillDisappear:(BOOL)animated
{
  [super viewWillDisappear:animated];
 
  // clear any search
  [_searchBar setText:@""];
  [_searchBar resignFirstResponder];
  [self performSearch:@""];
}
 
// Override to allow orientations other than the default portrait orientation.
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return YES;
}
 
- (void)didReceiveMemoryWarning
{
  // Releases the view if it doesn't have a superview.
  [super didReceiveMemoryWarning];
 
  // Release any cached data, images, etc that aren't in use.
}
 
- (void)viewDidUnload
{
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}
 
- (void)dealloc
{
  [[NSNotificationCenter defaultCenter] removeObserver:self];
 
  [_temporary_bookmark release];
  [_connection_history release];
  [_active_sessions release];
  [_manual_search_result release];
  [_history_search_result release];
  [_manual_bookmarks release];
 
  [super dealloc];
}
 
#pragma mark -
#pragma mark Table view data source
 
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
  // Return the number of sections.
  return NUM_SECTIONS;
}
 
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
 
  switch (section)
  {
    case SECTION_SESSIONS:
      return 0;
      break;
 
    case SECTION_BOOKMARKS:
    {
      // (+1 for Add Bookmark entry)
      if (_manual_search_result != nil)
        return ([_manual_search_result count] + [_history_search_result count] + 1);
      return ([_manual_bookmarks count] + 1);
    }
    break;
 
    default:
      break;
  }
  return 0;
}
 
- (UITableViewCell *)cellForGenericListEntry
{
  static NSString *CellIdentifier = @"BookmarkListCell";
  UITableViewCell *cell = [[self tableView] dequeueReusableCellWithIdentifier:CellIdentifier];
  if (cell == nil)
  {
    cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
                                   reuseIdentifier:CellIdentifier] autorelease];
    [cell setSelectionStyle:UITableViewCellSelectionStyleNone];
    [cell setAccessoryType:UITableViewCellAccessoryDetailButton];
  }
 
  return cell;
}
 
- (void)setText:(NSString *)text forGenericListEntry:(UITableViewCell *)cell
{
  UIListContentConfiguration *content = [cell defaultContentConfiguration];
  [content setText:text];
  [cell setContentConfiguration:content];
}
 
- (BookmarkTableCell *)cellForBookmark
{
  static NSString *BookmarkCellIdentifier = @"BookmarkCell";
  BookmarkTableCell *cell = (BookmarkTableCell *)[[self tableView]
      dequeueReusableCellWithIdentifier:BookmarkCellIdentifier];
  if (cell == nil)
  {
    cell = [[[BookmarkTableCell alloc] initWithStyle:UITableViewCellStyleSubtitle
                                     reuseIdentifier:BookmarkCellIdentifier] autorelease];
  }
 
  return cell;
}
 
// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView
         cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
 
  switch ([indexPath section])
  {
    case SECTION_SESSIONS:
    {
      // get custom session cell
      static NSString *SessionCellIdentifier = @"SessionCell";
      SessionTableCell *cell = (SessionTableCell *)[tableView
          dequeueReusableCellWithIdentifier:SessionCellIdentifier];
      if (cell == nil)
      {
        [[NSBundle mainBundle] loadNibNamed:@"SessionTableViewCell" owner:self options:nil];
        cell = _sessTableCell;
        _sessTableCell = nil;
      }
 
      // set cell data
      RDPSession *session = [_active_sessions objectAtIndex:[indexPath row]];
      [[cell title] setText:[session sessionName]];
      [[cell server] setText:[[session params] StringForKey:@"hostname"]];
      [[cell username] setText:[[session params] StringForKey:@"username"]];
      [[cell screenshot]
          setImage:[session getScreenshotWithSize:[[cell screenshot] bounds].size]];
      [[cell disconnectButton] setTag:[indexPath row]];
      return cell;
    }
 
    case SECTION_BOOKMARKS:
    {
      // special handling for first cell - quick connect/quick create Bookmark cell
      if ([indexPath row] == 0)
      {
        // if a search text is entered the cell becomes a quick connect/quick create
        // bookmark cell - otherwise it's just an add bookmark cell
        UITableViewCell *cell = [self cellForGenericListEntry];
        if ([[_searchBar text] length] == 0)
        {
          [self setText:NSLocalizedString(@"Add Connection",
                                          @"'Add Connection': button label")
              forGenericListEntry:cell];
          [cell setAccessoryType:UITableViewCellAccessoryNone];
        }
        else
        {
          [self setText:[_searchBar text] forGenericListEntry:cell];
          [cell setAccessoryType:UITableViewCellAccessoryDetailButton];
        }
 
        return cell;
      }
      else
      {
        // do we have a history cell or bookmark cell?
        if ([self isIndexPathToHistoryItem:indexPath])
        {
          UITableViewCell *cell = [self cellForGenericListEntry];
          [self setText:[_history_search_result
                            objectAtIndex:[self historyIndexFromIndexPath:indexPath]]
              forGenericListEntry:cell];
          [cell setAccessoryType:UITableViewCellAccessoryDetailButton];
          return cell;
        }
        else
        {
          // set cell properties
          ComputerBookmark *entry;
          BookmarkTableCell *cell = [self cellForBookmark];
          if (_manual_search_result == nil)
            entry = [_manual_bookmarks
                objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];
          else
            entry = [[_manual_search_result
                objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]]
                valueForKey:@"bookmark"];
 
          [cell setTitle:[entry label]];
          [cell setSubTitle:[[entry params] StringForKey:@"hostname"]];
          return cell;
        }
      }
    }
 
    default:
      break;
  }
 
  NSAssert(0, @"Failed to create cell");
  return nil;
}
 
// Override to support conditional editing of the table view.
- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath
{
  // dont allow to edit Add Bookmark item
  if ([indexPath section] == SECTION_SESSIONS)
    return NO;
  if ([indexPath section] == SECTION_BOOKMARKS && [indexPath row] == 0)
    return NO;
  return YES;
}
 
// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView
    commitEditingStyle:(UITableViewCellEditingStyle)editingStyle
     forRowAtIndexPath:(NSIndexPath *)indexPath
{
  if (editingStyle == UITableViewCellEditingStyleDelete)
  {
    // Delete the row from the data source
    switch ([indexPath section])
    {
      case SECTION_BOOKMARKS:
      {
        if (_manual_search_result == nil)
          [_manual_bookmarks
              removeObjectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];
        else
        {
          // history item or bookmark?
          if ([self isIndexPathToHistoryItem:indexPath])
          {
            [_connection_history
                removeObject:
                    [_history_search_result
                        objectAtIndex:[self historyIndexFromIndexPath:indexPath]]];
            [_history_search_result
                removeObjectAtIndex:[self historyIndexFromIndexPath:indexPath]];
            [self scheduleWriteConnectionHistoryToDataStore];
          }
          else
          {
            [_manual_bookmarks
                removeObject:
                    [[_manual_search_result
                        objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]]
                        valueForKey:@"bookmark"]];
            [_manual_search_result
                removeObjectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];
          }
        }
        [self scheduleWriteManualBookmarksToDataStore];
        break;
      }
    }
 
    [tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]]
             withRowAnimation:UITableViewRowAnimationNone];
  }
}
 
// Override to support rearranging the table view.
- (void)tableView:(UITableView *)tableView
    moveRowAtIndexPath:(NSIndexPath *)fromIndexPath
           toIndexPath:(NSIndexPath *)toIndexPath
{
  if ([fromIndexPath compare:toIndexPath] != NSOrderedSame)
  {
    switch ([fromIndexPath section])
    {
      case SECTION_BOOKMARKS:
      {
        NSInteger fromIdx = [self bookmarkIndexFromIndexPath:fromIndexPath];
        NSInteger toIdx = [self bookmarkIndexFromIndexPath:toIndexPath];
        ComputerBookmark *temp_bookmark =
            [[_manual_bookmarks objectAtIndex:fromIdx] retain];
        [_manual_bookmarks removeObjectAtIndex:fromIdx];
        if (toIdx >= [_manual_bookmarks count])
          [_manual_bookmarks addObject:temp_bookmark];
        else
          [_manual_bookmarks insertObject:temp_bookmark atIndex:toIdx];
        [temp_bookmark release];
 
        [self scheduleWriteManualBookmarksToDataStore];
        break;
      }
    }
  }
}
 
// prevent that an item is moved before the Add Bookmark item
- (NSIndexPath *)tableView:(UITableView *)tableView
    targetIndexPathForMoveFromRowAtIndexPath:(NSIndexPath *)sourceIndexPath
                         toProposedIndexPath:(NSIndexPath *)proposedDestinationIndexPath
{
  // don't allow to move:
  //  - items between sections
  //  - the quick connect/quick create bookmark cell
  //  - any item while a search is applied
  if ([proposedDestinationIndexPath row] == 0 ||
      ([sourceIndexPath section] != [proposedDestinationIndexPath section]) ||
      _manual_search_result != nil)
  {
    return sourceIndexPath;
  }
  else
  {
    return proposedDestinationIndexPath;
  }
}
 
// Override to support conditional rearranging of the table view.
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath
{
  // dont allow to reorder Add Bookmark item
  if ([indexPath section] == SECTION_BOOKMARKS && [indexPath row] == 0)
    return NO;
  return YES;
}
 
- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section
{
  if (SHOW_SESSIONS_SECTION && section == SECTION_SESSIONS && [_active_sessions count] > 0)
    return NSLocalizedString(@"My Sessions", @"'My Session': section sessions header");
  if (section == SECTION_BOOKMARKS)
    return NSLocalizedString(@"Manual Connections",
                             @"'Manual Connections': section manual bookmarks header");
  return nil;
}
 
- (NSString *)tableView:(UITableView *)tableView titleForFooterInSection:(NSInteger)section
{
  return nil;
}
 
- (CGFloat)tableView:(UITableView *)tableView heightForHeaderInSection:(NSInteger)section
{
  // remove gap unused session section.
  if (!SHOW_SESSIONS_SECTION && section == SECTION_SESSIONS)
    return CGFLOAT_MIN;
  return UITableViewAutomaticDimension;
}
 
- (CGFloat)tableView:(UITableView *)tableView heightForFooterInSection:(NSInteger)section
{
  // remove gap unused session section.
  if (!SHOW_SESSIONS_SECTION && section == SECTION_SESSIONS)
    return CGFLOAT_MIN;
  return [tableView sectionFooterHeight];
}
 
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
  if ([indexPath section] == SECTION_SESSIONS)
    return 72;
 
  return UITableViewAutomaticDimension;
}
 
#pragma mark -
#pragma mark Table view delegate
 
- (void)setEditing:(BOOL)editing animated:(BOOL)animated
{
  [super setEditing:editing animated:animated];
  [[self tableView] setEditing:editing animated:animated];
}
 
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
  if ([indexPath section] == SECTION_SESSIONS)
  {
    // resume session
    RDPSession *session = [_active_sessions objectAtIndex:[indexPath row]];
    UIViewController *ctrl =
        [[[RDPSessionViewController alloc] initWithNibName:@"RDPSessionView"
                                                    bundle:nil
                                                   session:session] autorelease];
    [ctrl setHidesBottomBarWhenPushed:YES];
    [[self navigationController] pushViewController:ctrl animated:YES];
  }
  else
  {
    ComputerBookmark *bookmark = nil;
    if ([indexPath section] == SECTION_BOOKMARKS)
    {
      // first row has either quick connect or add bookmark item
      if ([indexPath row] == 0)
      {
        if ([[_searchBar text] length] == 0)
        {
          // show add bookmark controller
          ComputerBookmark *bookmark =
              [[[ComputerBookmark alloc] initWithBaseDefaultParameters] autorelease];
          BookmarkEditorController *bookmarkEditorController =
              [[[BookmarkEditorController alloc] initWithBookmark:bookmark] autorelease];
          [bookmarkEditorController
              setTitle:NSLocalizedString(@"Add Connection", @"Add Connection title")];
          [bookmarkEditorController setDelegate:self];
          // breaks nav bar item updates with the top tab bar (iPad)
          if ([[UIDevice currentDevice] userInterfaceIdiom] != UIUserInterfaceIdiomPad)
            [bookmarkEditorController setHidesBottomBarWhenPushed:YES];
          [[self navigationController] pushViewController:bookmarkEditorController
                                                 animated:YES];
        }
        else
        {
          // create a quick connect bookmark and add an entry to the quick connect history
          // (if not already in the history)
          bookmark = [self bookmarkForQuickConnectTo:[_searchBar text]];
          if (![_connection_history containsObject:[_searchBar text]])
          {
            [_connection_history addObject:[_searchBar text]];
            [self scheduleWriteConnectionHistoryToDataStore];
          }
        }
      }
      else
      {
        if (_manual_search_result != nil)
        {
          if ([self isIndexPathToHistoryItem:indexPath])
          {
            // create a quick connect bookmark for a history item
            NSString *item = [_history_search_result
                objectAtIndex:[self historyIndexFromIndexPath:indexPath]];
            bookmark = [self bookmarkForQuickConnectTo:item];
          }
          else
            bookmark = [[_manual_search_result
                objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]]
                valueForKey:@"bookmark"];
        }
        else
          bookmark = [_manual_bookmarks
              objectAtIndex:[self bookmarkIndexFromIndexPath:
                                      indexPath]]; // -1 because of ADD BOOKMARK entry
      }
 
      // set reachability status
      [bookmark
          setConntectedViaWLAN:[[Reachability
                                   reachabilityWithHostName:[[bookmark params]
                                                                StringForKey:@"hostname"]]
                                   currentReachabilityStatus] == ReachableViaWiFi];
    }
 
    if (bookmark != nil)
    {
      // create rdp session
      RDPSession *session = [[[RDPSession alloc] initWithBookmark:bookmark] autorelease];
      UIViewController *ctrl =
          [[[RDPSessionViewController alloc] initWithNibName:@"RDPSessionView"
                                                      bundle:nil
                                                     session:session] autorelease];
      [ctrl setHidesBottomBarWhenPushed:YES];
      [[self navigationController] pushViewController:ctrl animated:YES];
      [_active_sessions addObject:session];
    }
  }
}
 
- (void)tableView:(UITableView *)tableView
    accessoryButtonTappedForRowWithIndexPath:(NSIndexPath *)indexPath
{
  // get the bookmark
  NSString *bookmark_editor_title =
      NSLocalizedString(@"Edit Connection", @"Edit Connection title");
  ComputerBookmark *bookmark = nil;
  if ([indexPath section] == SECTION_BOOKMARKS)
  {
    if ([indexPath row] == 0)
    {
      // create a new bookmark and init hostname and label
      bookmark = [self bookmarkForQuickConnectTo:[_searchBar text]];
      bookmark_editor_title = NSLocalizedString(@"Add Connection", @"Add Connection title");
    }
    else
    {
      if (_manual_search_result != nil)
      {
        if ([self isIndexPathToHistoryItem:indexPath])
        {
          // create a new bookmark and init hostname and label
          NSString *item = [_history_search_result
              objectAtIndex:[self historyIndexFromIndexPath:indexPath]];
          bookmark = [self bookmarkForQuickConnectTo:item];
          bookmark_editor_title =
              NSLocalizedString(@"Add Connection", @"Add Connection title");
        }
        else
          bookmark = [[_manual_search_result
              objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]]
              valueForKey:@"bookmark"];
      }
      else
        bookmark = [_manual_bookmarks
            objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]]; // -1 because of ADD
                                                                        // BOOKMARK entry
    }
  }
 
  // bookmark found? - start the editor
  if (bookmark != nil)
  {
    BookmarkEditorController *editBookmarkController =
        [[[BookmarkEditorController alloc] initWithBookmark:bookmark] autorelease];
    // breaks nav bar item updates with the top tab bar (iPad)
    if ([[UIDevice currentDevice] userInterfaceIdiom] != UIUserInterfaceIdiomPad)
      [editBookmarkController setHidesBottomBarWhenPushed:YES];
    [editBookmarkController setTitle:bookmark_editor_title];
    [editBookmarkController setDelegate:self];
    [[self navigationController] pushViewController:editBookmarkController animated:YES];
  }
}
 
#pragma mark -
#pragma mark Search Bar Delegates
 
- (BOOL)searchBarShouldBeginEditing:(UISearchBar *)searchBar
{
  // show cancel button
  [searchBar setShowsCancelButton:YES animated:YES];
  return YES;
}
 
- (void)searchBarCancelButtonClicked:(UISearchBar *)searchBar
{
  // clear search result
  [_manual_search_result release];
  _manual_search_result = nil;
 
  // clear text and remove cancel button
  [searchBar setText:@""];
  [searchBar resignFirstResponder];
}
 
- (BOOL)searchBarShouldEndEditing:(UISearchBar *)searchBar
{
  [searchBar setShowsCancelButton:NO animated:YES];
 
  // re-enable table selection
  [_tableView setAllowsSelection:YES];
 
  return YES;
}
 
- (void)searchBarSearchButtonClicked:(UISearchBar *)searchBar
{
  [_searchBar resignFirstResponder];
}
 
- (void)searchBar:(UISearchBar *)searchBar textDidChange:(NSString *)searchText
{
  [self performSearch:searchText];
  [_tableView reloadData];
}
 
#pragma mark - Session handling
 
// session was added
- (void)sessionDisconnected:(NSNotification *)notification
{
  // remove session from active sessions
  RDPSession *session = (RDPSession *)[notification object];
  [_active_sessions removeObject:session];
 
  // if this view is currently active refresh entries
  if ([[self navigationController] visibleViewController] == self)
    [_tableView reloadSections:[NSIndexSet indexSetWithIndex:SECTION_SESSIONS]
              withRowAnimation:UITableViewRowAnimationNone];
 
  // if session's bookmark is not in the bookmark list ask the user if he wants to add it
  // (this happens if the session is created using the quick connect feature)
  if (![_manual_bookmarks containsObject:[session bookmark]])
  {
    if (_temporary_bookmark)
      [_temporary_bookmark release];
 
    // retain the bookmark in case we want to save it later (in viewDidAppear)
    // (the session view is still on top here. Presenting the alert now blocks it from being
    // popped and leaves the user stuck in the ended session.)
    _temporary_bookmark = [[session bookmark] retain];
  }
}
 
- (void)askToSaveTemporaryBookmark
{
  NSString *title =
      NSLocalizedString(@"Save Connection Settings?", @"Save connection settings title");
  NSString *message = NSLocalizedString(
      @"Your Connection Settings have not been saved. Do you want to save them?",
      @"Save connection settings message");
  UIAlertController *alert =
      [UIAlertController alertControllerWithTitle:title
                                          message:message
                                   preferredStyle:UIAlertControllerStyleAlert];
  [alert addAction:[UIAlertAction actionWithTitle:NSLocalizedString(@"No", @"No Button")
                                            style:UIAlertActionStyleCancel
                                          handler:^(UIAlertAction *action) {
                                            [_temporary_bookmark autorelease];
                                            _temporary_bookmark = nil;
                                          }]];
  [alert
      addAction:[UIAlertAction
                    actionWithTitle:NSLocalizedString(@"Yes", @"Yes Button")
                              style:UIAlertActionStyleDefault
                            handler:^(UIAlertAction *action) {
                              if (_temporary_bookmark)
                              {
                                [_manual_bookmarks addObject:_temporary_bookmark];
                                [_tableView
                                      reloadSections:[NSIndexSet
                                                         indexSetWithIndex:SECTION_BOOKMARKS]
                                    withRowAnimation:UITableViewRowAnimationNone];
                                [self scheduleWriteManualBookmarksToDataStore];
                                [_temporary_bookmark autorelease];
                                _temporary_bookmark = nil;
                              }
                            }]];
  [self presentViewController:alert animated:YES completion:nil];
}
 
- (void)sessionFailedToConnect:(NSNotification *)notification
{
  // remove session from active sessions
  RDPSession *session = (RDPSession *)[notification object];
  [_active_sessions removeObject:session];
 
  // display error toast
  [[self view] makeToast:NSLocalizedString(@"Failed to connect to session!",
                                           @"Failed to connect error message")
                duration:ToastDurationNormal
                position:@"center"];
}
 
#pragma mark - Reachability notification
- (void)reachabilityChanged:(NSNotification *)notification
{
  // no matter how the network changed - we will disconnect
  // disconnect session (if there is any)
  if ([_active_sessions count] > 0)
  {
    RDPSession *session = [_active_sessions objectAtIndex:0];
    [session disconnect];
  }
}
 
#pragma mark - BookmarkEditorController delegate
 
- (void)commitBookmark:(ComputerBookmark *)bookmark
{
  // if we got a manual bookmark that is not in the list yet - add it otherwise replace it
  BOOL found = NO;
  for (int idx = 0; idx < [_manual_bookmarks count]; ++idx)
  {
    if ([[bookmark uuid] isEqualToString:[[_manual_bookmarks objectAtIndex:idx] uuid]])
    {
      [_manual_bookmarks replaceObjectAtIndex:idx withObject:bookmark];
      found = YES;
      break;
    }
  }
  if (!found)
    [_manual_bookmarks addObject:bookmark];
 
  // remove any quick connect history entry with the same hostname
  NSString *hostname = [[bookmark params] StringForKey:@"hostname"];
  if ([_connection_history containsObject:hostname])
  {
    [_connection_history removeObject:hostname];
    [self scheduleWriteConnectionHistoryToDataStore];
  }
 
  [self scheduleWriteManualBookmarksToDataStore];
}
 
- (IBAction)disconnectButtonPressed:(id)sender
{
  // disconnect session and refresh table view
  RDPSession *session = [_active_sessions objectAtIndex:[sender tag]];
  [session disconnect];
}
 
#pragma mark - Misc functions
 
- (BOOL)hasNoBookmarks
{
  return ([_manual_bookmarks count] == 0);
}
 
- (void)performSearch:(NSString *)searchText
{
  [_manual_search_result autorelease];
  [_history_search_result autorelease];
 
  if ([searchText length] > 0)
  {
    _manual_search_result = [FilterBookmarks(
        _manual_bookmarks,
        [searchText componentsSeparatedByCharactersInSet:[NSCharacterSet
                                                             whitespaceAndNewlineCharacterSet]])
        retain];
    _history_search_result = [FilterHistory(_connection_history, searchText) retain];
  }
  else
  {
    _history_search_result = nil;
    _manual_search_result = nil;
  }
}
 
- (NSInteger)bookmarkIndexFromIndexPath:(NSIndexPath *)indexPath
{
  return [indexPath row] -
         ((_history_search_result != nil) ? [_history_search_result count] : 0) - 1;
}
 
- (NSInteger)historyIndexFromIndexPath:(NSIndexPath *)indexPath
{
  return [indexPath row] - 1;
}
 
- (BOOL)isIndexPathToHistoryItem:(NSIndexPath *)indexPath
{
  return (([indexPath row] - 1) < [_history_search_result count]);
}
 
- (ComputerBookmark *)bookmarkForQuickConnectTo:(NSString *)host
{
  ComputerBookmark *bookmark =
      [[[ComputerBookmark alloc] initWithBaseDefaultParameters] autorelease];
  [bookmark setLabel:host];
  [[bookmark params] setValue:host forKey:@"hostname"];
  return bookmark;
}
 
#pragma mark - Persisting bookmarks
 
- (void)scheduleWriteBookmarksToDataStore
{
  [[NSOperationQueue mainQueue] addOperationWithBlock:^{
    [self writeBookmarksToDataStore];
  }];
}
 
- (void)writeBookmarksToDataStore
{
  [self writeManualBookmarksToDataStore];
}
 
- (void)scheduleWriteManualBookmarksToDataStore
{
  [[NSOperationQueue mainQueue]
      addOperation:[[[NSInvocationOperation alloc]
                       initWithTarget:self
                             selector:@selector(writeManualBookmarksToDataStore)
                               object:nil] autorelease]];
}
 
- (void)writeManualBookmarksToDataStore
{
  [self writeArray:_manual_bookmarks toDataStoreURL:[self manualBookmarksDataStoreURL]];
}
 
- (void)scheduleWriteConnectionHistoryToDataStore
{
  [[NSOperationQueue mainQueue]
      addOperation:[[[NSInvocationOperation alloc]
                       initWithTarget:self
                             selector:@selector(writeConnectionHistoryToDataStore)
                               object:nil] autorelease]];
}
 
- (void)writeConnectionHistoryToDataStore
{
  [self writeArray:_connection_history toDataStoreURL:[self connectionHistoryDataStoreURL]];
}
 
- (void)writeArray:(NSArray *)bookmarks toDataStoreURL:(NSURL *)url
{
  NSError *error = nil;
  NSData *archived_data = [NSKeyedArchiver archivedDataWithRootObject:bookmarks
                                                requiringSecureCoding:YES
                                                                error:&error];
 
  if (!archived_data)
  {
    // leave the existing file untouched rather than replacing it with bad data
    NSLog(@"%s: failed to archive %@: %@", __func__, [url lastPathComponent], error);
    return;
  }
 
  [archived_data writeToURL:url atomically:YES];
}
 
- (void)readManualBookmarksFromDataStore
{
  [_manual_bookmarks autorelease];
  _manual_bookmarks = [self arrayFromDataStoreURL:[self manualBookmarksDataStoreURL]];
 
  if (_manual_bookmarks == nil)
  {
    _manual_bookmarks = [[NSMutableArray alloc] init];
  }
}
 
- (void)readConnectionHistoryFromDataStore
{
  [_connection_history autorelease];
  _connection_history = [self arrayFromDataStoreURL:[self connectionHistoryDataStoreURL]];
 
  if (_connection_history == nil)
    _connection_history = [[NSMutableArray alloc] init];
}
 
- (NSMutableArray *)arrayFromDataStoreURL:(NSURL *)url
{
  NSData *archived_data = [NSData dataWithContentsOfURL:url];
 
  if (!archived_data)
    return nil;
 
  // covers both data stores: an array of ComputerBookmark and an array of NSString
  NSSet *classes = [NSSet setWithObjects:[NSArray class], [ComputerBookmark class],
                                         [ConnectionParams class], [NSDictionary class],
                                         [NSString class], [NSNumber class], [NSData class], nil];
  NSError *error = nil;
  NSArray *decoded = [NSKeyedUnarchiver unarchivedObjectOfClasses:classes
                                                         fromData:archived_data
                                                            error:&error];
 
  if (!decoded)
  {
    NSLog(@"%s: failed to unarchive %@: %@", __func__, [url lastPathComponent], error);
    return nil;
  }
 
  // the decoded array is immutable, but callers mutate the result
  return [[NSMutableArray alloc] initWithArray:decoded];
}
 
- (NSURL *)manualBookmarksDataStoreURL
{
  return [NSURL
      fileURLWithPath:[NSString stringWithFormat:@"%@/%@",
                                                 [NSSearchPathForDirectoriesInDomains(
                                                     NSDocumentDirectory, NSUserDomainMask, YES)
                                                     lastObject],
                                                 @"com.freerdp.ifreerdp.bookmarks.plist"]];
}
 
- (NSURL *)connectionHistoryDataStoreURL
{
  return [NSURL
      fileURLWithPath:[NSString
                          stringWithFormat:@"%@/%@",
                                           [NSSearchPathForDirectoriesInDomains(
                                               NSDocumentDirectory, NSUserDomainMask, YES)
                                               lastObject],
                                           @"com.freerdp.ifreerdp.connection_history.plist"]];
}
 
@end