Like we created a new object for the data model, let's create another one to

handle the different color objects, we need to create for our interactivity.

The alternative is to add that code into the ViewController as we've done with

this line here.

Remember, we want a nice separation of concerns.

The creation of colors isn't something the ViewController needs to know about.

Its only job is to set a value on the view's backgroundColor property.

So let's right-click on the FunFacts group and add a new file.

Like before, it's going to be a Swift File under iOS Source, and hit Next.

We'll name this one BackgroundColorProvider.

Now, in this file, we're going to get rid of the import Foundation line,

because we don't need anything from the Foundation framework.

But instead, we're going to import UI Kit because we need to have

access to the UI color object, which is part of that framework.

Now, we'll structure this struct,

which we'll call BackgroundColorProvider exactly like the fax provider object.

This will be a nice refresher for you, rather than yet

another new concept in this course, so struct BackgroundColorProvider.

And to this, we're going to add a single stored property, and

array to hold a bunch of different color objects.

Then we'll have a method that returns a random color.

This way, when we tap on the show FunFact button,

not only do we get another random fact back, but we also get a random color.

So like before, we will just add a fixed constant array.

We'll start off with an empty array, and

to this we'll add a bunch of different values.

Now typically, we create an instance, assign it to a constant.

And then we add the constant to an array, right, the way we did with the color.

If we were to do that, that would be a lot of extra constants.

And we can just as easily write the code to create a color instance

inline inside the array itself.

So, for example, for the first one, we'll say UI color.

We'll use initializer that takes RGB values.

And we'll say,

90/255, 187/255,

181/255, and 1.0.

I'm gonna add a comment here and say, this is teal color.

Now, doing it this way, I've created the color value right inline in the array.

Now, there's a lot of typing here to create several different color instances.

So I'm just going to copy paste the coding using an Xcode snippet.

If you look in the teacher's notes section, you'll see the code for

the entire array as well, so that you can copy paste it.

Although, if you'd like to get in practice,

you could type it out all yourself.

All right, now that we have an array of colors,

we need a method to get a random color out of the array.

This is exactly like the method we implemented in the fact provider struct.

To start, remember we need a random number generator.

And in fact provider, we use some code from the Game Kit framework to do this.

So let’s import that here as well, say import GameKit.

We'll call this method randomColor, and like last time, no parameters.

But instead of returning a string this time,

we're going to return an instance of UIColor.

Inside of the body, just like before,

we'll start off by creating a random number.

So let's say, random number.

This is the constant to which we're going to assign the randomNumber.

And to do that, we'll use the GKRandomSource.sharedRandom().nexInt(uppe-

rBound:).

And we'll pass in the upperBound of the array colors.count.

I'm not gonna repeat what this code does because we covered

that in the fact provider set of videos.

So if you're confused, go back and check it out.

We just need to remember to set the upper bound of the random number to the count

property of the colors array.

And with that random number,

we can now return a random color using subscript notation.

Okay, so we have a color provider object.

Let's go back to the ViewController.

And just like we did with the fact provider, let's create a stored property.

So let's say, let colorModel, enter that or we'll say, colorProvider.

Sounds more accurate.

And to that, we'll assign an instance of BackgroundColorProvider.

Now, inside the showFact method, let's get rid of this newColor that we created.

And instead, get a random color out of our provider object.

So we'll say, colorProvider.randomColor.

Once we have a random color, we can simply assign this to the views backgroundColor.

This solves one of our problems.

And that's getting a new backgroundColor every single time we press a button.

We still need that button tint color to match the new backgroundColor though.

Since the object was created in Interface Builder.

If we want to meddle with its properties in code, we need to create an IB outlet.

So let's do that.

Let's go back to main.storyboard, and

this is the button we're trying to meddle around with.

So remember to have the two editors side by side.

We are going to open up the assistant editor

which should automatically bring up the ViewController.

Now, once you have the button selected, we're going to control drag.

This end will do it up over here, we'll control drag over.

Make sure you're inserting an outlet and

then call this funFactButton.

Okay, now all we have to do, let's go back to the standard editor.

Go back to the ViewController and in here, now,

that we have this random color that we're holding onto.

Let's assign this color object to the tint color property of the funFactButton.

So funFactButton.tintColor = randomColor.

Remember, the reason we're assigning it to tintColor is because

a button is a UI control.

And controls inherit their text color through the tintColor object,

not the textColor object.

Okay, let's build and run this.

And notice that, everything works.

So we have our labels, we have a fact.

And when we press it every time, we get a random color and a random fact.

And now, the button matches.

And it looks like we're showing the color underneath.

Awesome, you've built your very first app.

Congratulations.