At this point, we have 90% of the app functionality done.

We know how to programmatically load a playlist, and

then pass that info to the detail view controller.

Right now however, we're working with one playlist, and

it's easy to pass that one playlist on because we

don't have to figure out which playlist we actually need.

Let's tackle that next.

The way our code stands right now, we've simply hard coded the playlist that we're

sending over by specifically setting the index to 0 in our init method.

What if we changed the index up in the ViewDidLoad method over here to 1?

Now our image view on the master page displays a different playlist cover image,

but when we tap it and go to the DetailViewController,

we still see the information for the playlist created using index 0.

Now, we could change the index value in the prepare for segue method again,

to 1, and to match the ViewDidLoad, but you see the problem with this.

We can't hard code every single thing, because that just won't work.

What we can do,

however, is programmatically figure out which album we're tapping.

And then use that information to pass on the right data to our

playlist detail controller in the prepare for segue method.

Before we do this however, let's modify our setup code so that we're not hard

coding index values when creating album instances and setting up our image views.

Earlier, we created a reference to the image view in our

storyboard scene with an outlet in our header file.

Now we've use this outlet to set the playlist cover image, and

do some other things as well, over here.

Soon, we're going to add a few more playlists to our app.

And we'll need to create an equal number of image views to match that.

Based on how we structured our code right now, we would have to create a playlist

instance for each of these image views, and set the cover image appropriately.

That's a lot of repeated code, and remember,

we want to adhere to the dry principle, that is, do not repeat yourself.

What we can do, instead of creating IB outlets for every single image view,

is to create a collection of IB outlets, or IB outlet collection.

In the playlist master view controller header file,

let's add an IB outlet collection to our class.

Now we'll start with a normal property declaration.

So I'm gonna do it above this one right here @property.

We're gonna specify it as strong and nonatomic.

Then this is followed by the IB outlet collection keyword,

which takes a class name for the group of outlets that we're creating.

In this case, in our case, this is image view.

UIImageView, specifically.

Since all our playlists will be of type UIImageView.

Now an IB outlet collection is always of type NSarray, since what this basically

does, is create an array that holds a collection of different IB outlets.

So next we specify NSarray, and then followed by an asterisk and

a name as usual.

Let's call ours playListImageViews.

Now, we can get rid of this playlistImageView outlet that we created.

Let's also go back to our storyboard and get rid of the reference.

Now, this can seem confusing.

So if you want to get rid of the reference in a more clear manner,

you can click on the image view and

click on the Connections Inspector to see everything connected to the image view.

Now with the connections view still open, select the View Controller either in

the document outline or using the icon in the scene.

And this should bring up a list of connections available to

the ViewController as a whole.

We can see that the outlet collection that we just created is listed in this section.

To add this image view to the IB outlet collections,

we just click on the plus button, and drag it over to our image view.

And now instead of having a single IB outlet instance,

we have this image view added to the collection.

Let's go back to our master view controller implementation file.

Now we need to modify our code to use the outlet collection rather than

this individual outlet.

So, let's get rid of this.

Since the outlet collection is simply an NSArray, we can use a for

loop and iterate over the array using an index counter.

So let's do that.

We'll do four.

We're gonna create an integer, NSUInteger.

We'll call it index and set it to 0 to initialize it.

Now we want the for

loop to keep going until it's just less than the playlist image view's count.

So we'll do index, less than self.playlistImageViews.count.

And then after all the code is executed, we want the index to increment by 1.

So in here, we do something.

So let's look at this loop.

First, we initialize the loop by setting the index to 0.

Now, we want this index to keep going, to keep looping over, until the index value

equals 1 less than the number of items in the image view's outlet collection,

that is the array, and we're going to use this index value now to

access the playlist image view instance from inside the array.

We'll also use the array then to create a new playlist instance each time.

When we're done with the segue code, we'll increment the index by 1.

So, let's do that.

First, we'll create the playlist instance.

This should all be familiar.

And we'll use the same init with index, but instead of

hard coding the index value, we'll pass in the index that we just created.

Next, we're going to get an image view out of the array using this same index.

Let's do UIImageView playlistImageView equal

self.playlistImageViews since that's an array and then we'll pass the index value.

Now we can use this playlist instance to setup this ImageView.

Let's do that.

PlaylistImageView.image equal

to playlist.playlistIcon.

And similarly, let's set the background color.

Now, when we add more image views to our view,

we don't need to set them up individually every time.

We're just going to add them to the outlet collection, which is in the array.

This automatically increases the array count that we've specified over here,

which increases our index range and sets up everything just as we did here.

Run the app, and again everything should work just like before.

There you go.

We have one bit of code here.

We need to get rid of this.

This is our previous creation of the playlist instance.

We don't need that anymore, so let's get rid of that.

Okay, now that we have our playlists and

the cover images set up properly, let's look at how we

can pass on the correct data to the detail view without hard coding any indexes.