For either data source method, whether it's the viewControllerBefore

the current one or the viewControllerAfter, our goal is to create

a new instance of the PhotoViewVontroller, give it a new photo and show it on screen.

So let's refactor this code out of viewDidLoad

where we create a new instance of the PhotoViewController for a given photo.

And this is pretty easy in Xcode 9.

So what we are going to do is we are going to select all of this right here.

And then we'll command or we'll right click Refactor and,

wait that doesn't seem to work.

Hold on, select Bugs, gotta love them.

Okay, let's just select this and see if we can get it to work.

Now, wonderful.

Okay, we'll do this manually.

So right after viewDidLoad, let's add a new method func photoViewerController,

With photo of type Photo.

And this is going to return an optional instance of PhotoViewerController.

So in here we'll move this guard let storyboard.

All of that cut and paste it in here.

And instead of just returning out of the method,

we'll return nil to indicate something went wrong here.

Oops, this is supposed to be an optional instance, there we go.

And then once we have that, we can grab this line of code, put it in here.

We're no longer going to reference the photos array,

we're just going to say photo, right?

This is the argument we're passing in to the method.

And then we'll return the PhotoViewerController.

So now we can use this method inside of viewDidLoad instead of our original code.

So we'll say if let photoViewerController =

photoViewerController, that method we just wrote, with.

And here we'll say photos, indexOfCurrentPhoto.

So if this works, then we'll delete this.

And we'll move this line of code up.

Okay, so that works.

Back to the data source methods.

Now that we have this helper method,

we can easily write a fewer lines of code to do the same thing.

Let's start with viewControllerBefore.

Let's walk through the steps here.

First, we need to figure out what photo is currently on screen.

To do this, we'll get the current photo and see which index it's at.

Now you might be thinking, wait a minute,

I thought the current photo was at index of current photo.

Now that holds true for the very first photo.

Once we start swiping though, unless we update index of current photo,

the index stored in the variable and

the index corresponding to the photo on screen are different.

Once we have an index, since this method asks for the ViewController before that

one, we'll get the photo at the index position immediately to the left and

use it to create an instance of the PhotoViewerController.

There's only one caveat here.

If that index is 0, there's nothing to the left, so we're going to return nil.

Okay, let's try this out.

So step one, get the photo and check the index.

If you look at the method signature of the protocol method,

it includes a reference to the current viewController right here.

This ViewController is an instance of the photoViewController, but

the type is just UIViewController.

So let's start by casting it first to the right type.

We'll say guard let photoViewController or

PhotoViewerController = viewController as PhotoViewerController.

Else if this doesn't work, return nil.

Next we need to get the index of the photo

stored in the viewController's photo property.

Let's add this logic as a check to the guard statement as well,

since the index of method returns an optional integer.

So here we'll add a comma and then we'll say let index = photos,

that's our data source, essentially .index.

And we're gonna look for index of, oops, index, right here, index of Photo.

And we'll say photoViewerController

.photo.

So what we're doing is, this is the current viewController.

We're casting that to a PhotoViewerController,

grabbing the photo out of that, and

then checking the index and comparing it to our array that we have at the top.

Next, we'll check to see if this index is the first index in the array.

So we'll say if index == photos.index or

photos.startIndex which represents the first index.

And notice that I'm not using any hard coded numbers here.

I'm relying on built in logic to traverse the array induce index math.

So if this is the start index that means there's no photo before this one.

Remember this data source method is asking, hey,

what's the viewControllerBefore this current one?

So if we're at the startIndex, there is nothing, we can return nill.

If it isn't nill, however, we will get the index right before it.

So, else, we will say let indexBefore = photos.indexBefore.

There is a method for that.

And we will use the current index.

Now we have this index, we can get a photo.

So let photo = photos[indexBefore].

And then we'll return photoViewerController with that photo.

Let's try this out.

Why is this an error?

Let me build.

Cannot call value of non-function type.

That's because these two things have the same name, so let's change that.

I'm going to command click here,

and select Rename from these new fancy methods.

You'll notice that it selects this which is obviously wrong.

We're gonna get rid of that and we'll say photoVC, right?

That should work.

Rename and that recognizes this as method.

Okay, let's give this a try.

I'm gonna run this app.

Now, before you actually tap on a photo,

remember that we're going to select a photo and try to go before it.

So backwards.

And in order to test this, you'll need more than one photo.

At least two.

So go ahead and add a few in.

So I have three in here.

I'm gonna select this one.

And you'll notice that I can swipe.

And it works.

While this page curl effect that you just saw is fun, that's out of place here, and

is mostly used when you're flipping through pages in a book.

So let's go to main.storyboard, and select the PhotoPageController.

And in the Attributes Inspector,

you'll notice under the Attribute section that there is a Transition Style.

So if you're building something like a book, you can leave the Page Curling,

otherwise we are gonna set it to Scroll.

Cool, now that we understand the logic behind how this works,

let's provide an implementation for the second delegate method.

And that's back in the PhotoPageController class.

For the second method, we need to go in the opposite direction.

So really the only change here is how we do the index checks.

So let's copy the implementation from the previous method.

We're going to get all of it, Paste it in.

And then here we'll say guard let photoViewController.

We'll make that check.

We'll get the index of the current photo, all this is the same.

Now the if statement here checks to see if the index of the current photo

is the startIndex.

We'll need to modify this to check if it's at the opposite end of the array.

Arrays have a property called endIndex that points to the index

right after the last index in the array.

So what we need to do is check whether the index of the current photo is

the same value as the index right before the index.

Make sure you don't compare it, so don't do this.

Don't do if current index is photos.endIndex.

This we'll be wrong, because endIndex represents the index after the last one.

So what we'll do here is we'll say if index ==

photos.index(before: photos.endIndex.

And then we'll return nill.

Now this does seem like a complicated way of achieving this since we can just index

less than the current property.

But by doing it this way, we let the array type worry about the index math and

we don't do any hard coded values or compare it.

So if the current photo is the last one in the list, then we return nill.

And the pageViewController takes this to mean that we can't swipe forward,

we're at the end.

In the else case,

we now need to switch the logic to get the index after the current one.

So let's rename this.

So we'll command click.

We'll rename this to indexAfter.

Hit Rename.

And then all we have to change here now is this method to say after.

Okay, that should be it.

Let's run the app.

And now if we select the first photo,

we should be able to swipe all the way to the end.

There we go.

And then back as well.

So the key bits here are the data source methods.

By returning nil when we hit the edges of our data source, we inform

the pageViewController when it should stop loading another viewController.

But when we tap on the photo here, nothing interesting happens.

So over the next few videos, let's allow the user to zoom, pinch, and pan a photo.