Let's add a new file to our project under the permissions group.

So, it's a New File, we're going to, this is going to be a Swift File and

we'll call it LocationManager.

In it we're going to create a LocationManager class that will handle

a couple different things.

Requesting permissions to get location updates from the user, starting

the location service and informing us when a location fix has been obtained.

Class LocationManager and we're going to make this class inherit from NSObject.

Essentially we want this to be an objective C class.

Now, location services are part of the core location framework, so

we need to import that so we don't get any compiler errors.

I keep referring to the core location framework, and

it's important to understand the different things it can do.

As always, I've linked to the framework reference in the teacher's notes, so

you can check it out.

The main class we're going to be working with is CLLocationManager.

So let's head over to the documentation to understand the steps to using this class.

Help > Documentation API Reference, and you should type CLLocationManager.

CLLocationManager is the central point for

configuring the delivery of location and heading-related events to your app.

And we can use it to manage any type of location activity,

including the simple initial fix that we want to get.

If we scroll down a bit on this page, It says here, to configure and

use a CLLocationManager object we need to follow these five steps.

So let's start with the first one, which involves requesting permission.

Now we need a manager to work with so that we can use it to ask for permission.

So back in our class, let's add one as a private stored property,

private let manager = CLLocationManager.

Now let's add a simple method to ask for permission.

So say func requestLocationAuthorization and

we'll make this method a throwing one.

CLLocationManager has a class method authorization status that we can use

to check the app's current authorization status for using location services.

The method is going to return an enum value of type CL authorization status.

So for example, we can check the current auth status by saying let

authorizationStatus = CLLocationManager.

Remember this is a class method,

we're calling it on the type itself, authorizationStatus.

So in here,

before we actually request authorization, we're going to check the current status.

So we have three possible situations.

In the first one, the user has restricted or denied us access to their location.

We may have asked them before, and they just went ahead and denied us.

In this case, since this method that we've defined is a throwing one, if we hit this

scenario we'll throw an error to the call site and deal with it there.

So for example, if the user denies it,

in our permissions controller we can spin up an alert that says so.

We'll say if authorizationStatus equal now,

this returns an enum value so we're going to inspect that value and say,

if it is equal to .restricted or we're using the OR operator here or

if it is equal to .denied, then we're going to throw an error.

So inside this if block, we need an error to throw.

So let's create a small type in here.

At the top we'll say enum LocationError, and

this type has to conform to the error protocol.

Let's give it three different values here,

so let's say case unknownError,

case disallowedByUser and unableToFindLocation.

Okay, so back in our if statement, we can now throw an appropriate error.

So we can say throw LocationError.disallowedByUser.

The second situation we can be in is an undetermined one.

This is where we'll end up if we've never asked for permission before.

So here we'll say, else if authorizationStatus

= .notDetermined then if it hasn't been determined before,

we can go ahead and ask our manager to request the appropriate authorization.

So, we'll say manager.requestWhenInUseAuthorization.

We need to be specific about the type of authorization request because

remember that we added to our info.p list the ns location,

when in use usage description key, and that corresponding descriptive string.

Well these two pieces, the descriptive string and

the request type go hand and hand.

If you provide a when in use description but

request an always authorization, the user won't even see a prompt.

The location request will silently fail, and

you won't be able to offer functionality.

So remember, if you're making a when in use authorization request,

you need to use the right key.

Okay, so let's make a final else case here.

We'll hit this else, if we've obtained authorization before and

we're still requesting for it.

So, all we're going to do here is return from the method, without doing anything.

Okay. Permission requested.

Let's go back to the docs and look at step two.

Step two says, create an instance of the CL location manager class and

store a strong reference to it somewhere in your app.

Okay, we've already taken care of that.

Good.

For step three, we need to assign a custom object to the manager's delegate property.

After a location manager initiates location requests,

any updates we get back are delivered through its delegate.

So, we'll create an init method and

set the delegate to self inside this init method.

So we'll do this right after the sort properties.

Now this initializer's not going to accept anything for now and in doing so

we'll customize that in a second but when we write the init method, just this way,

we need to override it because we're inheriting it from the NS object class.

Okay so we don't have any stored properties we need to initialize, so

we can call superinit to initialize the base class and

now in here we can say manager.delegate equal self.

Now the protocol in question is the CLLocationManager delegate protocol.

Before we actually implement any methods, we'll take a small break.

But before we end the video, we need to get rid of this error.

And this error is occurring because we're not conforming to the delegate protocol.

So over here, let's just go ahead and say CLLocationManagerDelegate.

All right, see you in the next video.