Start off by creating a new Swift file called ContactFetchHelper.swift. After creating the file, add it to a new folder called Helpers. First, we'll extract all the contact fetching code to our ContactFetchHelper struct. Then, we'll refactor ViewController.swift so it uses our new helper instead of implementing all the fetching code in the view controller. The following is the implementation for ContactFetchHelper:

import Contacts 
 
struct ContactFetchHelper { 
    typealias ContactFetchCallback = ([ContactDisplayable]) -> Void 
     
    let store = CNContactStore() 
     
    func fetch(withCallback callback: @escaping 
      ContactFetchCallback) { 
        if CNContactStore.authorizationStatus(for: .contacts) 
          == .notDetermined { 
            store.requestAccess(for: .contacts, completionHandler: 
              {authorized, error in 
                if authorized { 
                    self.retrieve(withCallback: callback) 
                } 
            }) 
        } else if CNContactStore.authorizationStatus(for: .contacts) 
           == .authorized { 
            retrieve(withCallback: callback) 
        } 
    } 
     
    private func retrieve(withCallback callback: 
      ContactFetchCallback) { 
        let keysToFetch = 
            [CNContactGivenNameKey as CNKeyDescriptor, 
             CNContactFamilyNameKey as CNKeyDescriptor, 
             CNContactImageDataKey as CNKeyDescriptor, 
             CNContactImageDataAvailableKey as CNKeyDescriptor, 
             CNContactEmailAddressesKey as CNKeyDescriptor, 
             CNContactPhoneNumbersKey as CNKeyDescriptor, 
             CNContactPostalAddressesKey as CNKeyDescriptor] 
         
        let containerId = store.defaultContainerIdentifier() 
        let predicate = CNContact.predicateForContactsInContainer
          (withIdentifier: containerId) 
         
        guard let retrievedContacts = try? store.unifiedContacts(matching: 
          predicate, keysToFetch: keysToFetch) else { 
            // call back with an empty array if we fail to retrieve contacts 
            callback([]) 
            return 
        } 
         
        let contacts: [ContactDisplayable] = retrievedContacts.map { 
          contact in 
            return HCContact(contact: contact) 
        } 
         
        callback(contacts) 
    } 
} 

This simple struct now contains all the required logic to fetch contacts. Let's go through some of the most interesting parts of code in this struct:

typealiasContactFetchCallback = ([HCContact]) -> Void 

This line of code defines an alias, ContactFetchCallback, for a closure that receives an array of HCContact instances and returns nothing. This is the closure that is passed to the fetch method and it's called after the fetching is performed.

The fetch method is the method we'll call whenever we want to fetch contacts. The only argument it takes is a closure that needs to be called when the contacts are fetched. The fetch method performs the same authorization check we had in the view controller's viewDidLoad method.

Next, we have a private method, retrieve, that actually retrieves the contacts. The fetch method calls this method and passes on the callback it received. Once retrieve has retrieved the contacts, it calls the callback with the array of fetched contacts.

In ViewController.swift, all you will need to do is use the following code to retrieve contacts:

let contactFetcher = ContactFetchHelper() 
contactFetcher.fetch { [weak self] contacts in 
    self?.contacts = contacts 
    self?.collectionView.reloadData() 
} 

You can delete the retrieveContacts method entirely and the preceding snippet replaces the code that checked for permissions in viewDidLoad. Also, because we're not directly using the Contacts framework anymore, you can also remove its import at the top of the file. You have now successfully extracted the contact's fetching code into a struct and you're using a typealias to make your code more readable. This is already a big win for maintainability and reusability. Now, let's extract our animation code as well.

The process of extracting our bounce animation is a little bit more complex than it was to extract the contact fetching. The purpose of extracting this bounce animation is to make it bounce, so we can make other objects in other sections of our app bounce just as the contact cell's image does.

To figure out what our bounce animation helper should do exactly and how it should work, it's a great idea to think about how you want to use this helper at the call site. The call site can be defined as the place where you use your helper. So, in this case, the call site is considered the ViewController. Let's write some down some pseudo code to try and determine what we will program later:

let onBounceComplete = { [weak self] finished in 
    self?.performSegue( 
withIdentifier: "contactDetailSegue", 
        sender: self) 
} 
 
let bounce = BounceAnimationHelper(targetView: cell.contactImage, 
onComplete: onBounceComplete) 

This looks pretty good already and in reality, it's very close to the actual code we'll end up with later. All we really want to do is configure a bounce animation by passing it a view to perform the bounce on and to have some control over, should, happen after the animation is complete. We should consider the following two things before we can write the BounceAnimationHelper implementation:

To address the first point, we could implement two initializers: one that uses a default duration and another where the users of the helper can specify their own duration. Doing this makes use of Swift's powerful method overloading, which enables us to write multiple initializers for the same object. This also enables programmers to write methods with the same name but a different signature due to different parameters.

The second point is valid, and we should write the helper in a way that requires manual starting of the animation. Theoretically speaking, we could add a Boolean value to the initializer that enables users of the helper to choose whether the animation should start automatically or not. We won't do this for now because manually starting the animation will make it feel more like the UIViewPropertyAnimator that's used under the hood. The calling code we'll end up with will look similar to the following code. You can go ahead and add it to the ViewController.swift file in place of the current bounce animation. We'll implement the helper shortly:

let onBounceComplete = { [weak self] finished in 
    self?.performSegue( 
withIdentifier: "contactDetailSegue", sender: self)

(without the newline after "contactDetailSegue", 
} 
 
let bounce = BounceAnimationHelper(targetView: cell.contactImage, 
onComplete: onBounceComplete) 
 
bounce.startAnimation() 

Now that we have the call site figured out, let's take a look at the implementation of our BounceAnimationHelper. Create a new Swift file and add it to the Helpers folder. Start off by defining a struct named BounceAnimationHelper in the corresponding Swift file. Next, let's define a typealias for the completion handler and specify the properties we will need in our struct, as follows:

import UIKit 
 
struct BounceAnimationHelper { 
    typealias BounceAnimationComplete = (Bool) -> Void 
 
    let animator: UIViewPropertyAnimator 
} 

The initial implementation for the struct is pretty bare boned. We define a typealias that passes a Boolean into a closure that has no return value. We'll also hold on to the UIViewPropertyAnimator so we can tell it to start whenever the helper's startAnimation method is called. Let's add the initializers we came up with earlier, in the following code:

init(targetView: UIView, onComplete: BounceAnimationComplete) { 
    self.init(targetView: targetView, onComplete: onComplete, duration: 0.4) 
} 
 
init(targetView: UIView, onComplete: BounceAnimationComplete, duration: TimeInterval) { 
 
} 

These two initializers provide the APIs we're looking for. The first initializer calls out to the second with a default duration value of 0.4. Doing this allows us to write the actual animation in just a single place. There is just one initializer, the designated initializer, that's responsible for fully configuring our helper. The implementation for this initializer looks like this:

init(targetView: UIView, onComplete: BounceAnimationComplete, duration: TimeInterval) { 
    let downAnimationTiming = UISpringTimingParameters( 
dampingRatio: 0.9, 
  initialVelocity: CGVector(dx: 20, dy: 0)) 
 
  self.animator = UIViewPropertyAnimator( 
        duration: duration/2, 
  timingParameters: downAnimationTiming) 
 
  self.animator.addAnimations { 
  targetView.transform =
CGAffineTransform(scaleX: 0.9, y: 0.9) 
    } 
 
  self.animator.addCompletion { position in 
        let upAnimationTiming = UISpringTimingParameters( 
dampingRatio: 0.3, 
  initialVelocity:CGVector(dx: 20, dy: 0)) 
 
        let upAnimator = UIViewPropertyAnimator( 
            duration: duration/2, 
  timingParameters: upAnimationTiming) 
 
  upAnimator.addAnimations { 
  targetView.transform =
CGAffineTransform.identity

   }
upAnimator.addCompletion(onComplete) 
 
    upAnimator.startAnimation() 
    } 
} 

This snippet is very similar to the old animation; the main differences are highlighted. Instead of hard-coding a duration, we will use half of the total duration for the downward motion and half for the upward motion. Also, instead of using the cell's image directly, we will use the specified targetView. Finally, instead of passing our own callback to the upAnimator closure's completion, we will use the onComplete closure that was passed to the initializer. Note that the down animation hasn't started yet; we'll implement a separate method for that:

func startAnimation() { 
    animator.startAnimation() 
} 

Add the preceding method to the BounceAnimationHelper and run your app. Your animation should bounce just as it did before, except the animation is reusable now and the code in ViewController.swift looks a lot cleaner.

With our cleaned up ViewController in place, let's see where we could benefit from protocols.