In the Build Your Own iOS App capstone you will expand your repertoire of additional features and more advanced functions that may be implemented within the iOS environment. You will refine your development skill set and will apply your accumulated skills over the entire specialization series in an applied application development capstone project. This particular course is project based and structured around you building a high quality app as a capstone to the specialization. Currently this course is taught using Swift 2. The team is aware of the release of Swift 3 and will be making edits to the course in time. Please be aware that at this time the instruction is entirely with Swift 2.
Fun With Web Services: Making HTTP Requests
Loading...
From the course by University of Toronto
Build Your Own iOS App
51 оценки
From the lesson
Object Animation (Basic)
Create a simple animation of an object based on the position of the face
Meet the Instructors
Parham AarabiProfessor
Department of Electrical and Computer Engineering
[MUSIC]
Hi there, thank you for joining me again.
This is Mike and in this lecture we're going to do
an overview of web API access with Swift.
In this lecture, I'm going to cover how the sample classes for
our web services app work.
We're going to start by breaking down the HTTP request
protocol to look at its basic components.
Next, we'll take a look at the documentation for an actual web service.
The documentation will describe how to populate the fields that make up the HTTP
request that you're going to use to connect to that service.
And then finally we'll take a look at the actual code for
our API connection class and show how it makes the request in practice.
You'll likely already be familiar with HTTP requests that
your browser makes when you load websites.
A request is made each time you type a URL or search into the title bar
of the browser, and also when you click a link or submit a form.
It's tempting to associate a request with the URL itself, but the URL is
really only one component of many fields that are present in a typical request.
When you make a request in code, you're going to need to make sure
each of those required fields are filled out correctly yourself.
Each API you see in the real world uses these fields in a slightly different way,
so there's a lot of variety in the types of requests and
how you construct a requests when it comes to using different services.
So it's important to carefully read the documentation for
the web service you're actually going to connect to.
Let's take a look at the parts of a request that you might need to specify.
Here's a diagram here that shows each row as a different
section of a request that you may need to configure for an HTTP request.
So the first row here is the method.
So each HTTP request has a method type that you need to specify.
It's like a verb and it tells the server what you want to do with the information
you're either submitting or retrieving.
The service provider will define the actions that are taken for
a particular method at a particular URL path as a part of their API.
In most cases you'll see when you are retrieving information from a certain path
you'll use the get method.
This is the default when you construct an NS HTTP request instance.
So you normally don't have to do anything special to configure or
request to use the get method.
But there's a few others, this is only the beginning.
There are actually quite a few more that are part of the standard.
If you're storing or modifying information at a particular URL path,
often you'll use one of the other methods like put or post, depending on how
you want to modify the information that might be already there at that location.
And there are many others like DELETE for example, and other sort of meta methods
that you can use to retrieve information about that location.
You can find out more about that on the API connection documentation for
whichever service you're going to use.
Again, pay attention to the method you'll often see one of the key words mentioned
to your the documentation, will tell you which one you need to use.
The next you have here is the URL, and is actually going to have several
parts that contain different types of information.
You've got the protocol, the host, and the path, which are pretty familiar.
Finally you have the query string, and
that encodes one or more key value pairs into the URL itself.
The query string is used to parse named parameters to the server,
in a way like parameters will often be parsed to a function defined in Swift.
The query starts with a question mark,
which separates it from the end of the path portion of the URL.
The keys are separated from the values by an equals sign.
And each each key value pair is separated from the next one by an ampersand
symbol here.
Note how there are no quotes around the values,
it's assumed that each value will be parsed as a string.
Numbers must be converted to strings before being included in a query.
So this is I guess a prime candidate, for example,
to use Swift-like string interpolation to insert values into your query string.
Since certain special characters like spaces, for
example are not allowed in the URL, and others like question marks and
equal signs as you can see here have special meanings.
You need to escape them if they appear in your parameter values.
This just means that we have to replace instances of these characters like for
example, the space that would normally be here in the word New York
with their URL code.
So for example the space is replaced with a %20.
You can see in the code that we have in the example files that there's a Swift
function that you can use to do this, and it's included there.
The URL is the most visible part of a request, and often all you would need.
But there are often other fields that are interpreted by the server as well, and
sometimes you need to set values for these fields if the API requires it.
Each HTTP request also includes a set header fields,
this is another set of keys and values.
Typically you don't notice these when you make a requesting in your
browser because you're only seeing the URL.
But this type of information is often present as well.
This could be like metadata for
the request like when your browser sends a cookie back to the server for example,
that would be sent as one of the header fields.
For example, you might also need to include an authorization token of some
sort when you're connecting to a service.
Sometimes that's included as a value in one of the header fields as well.
The API will specify what fields need to be present if any
in a request that you make.
And then the last section of an HTTP request is the body section.
This is used to store just data of arbitrary length and format.
For example it could be a binary image file or data in a JSON structure.
The data for a large encoded image would be probably too large to fit in the URL,
so, it can go into the body.
Okay, so let's take a look at a real example, using Yelp's documentation.
Okay, so I've opened up the Getting Started page in
Yelp's Fusion API documentation.
First you can see there's a summary available functions provided by the API.
But before I can call on any of these functions,
it needs to authenticate with Yelp using the client identity
numbers that we retrieved when we signed up to use the service.
So actually, if I scroll down here, there is a section that describes how to
actually retrieve the authentication token that we can use in a session with Yelp.
Let's break it down here.
So first, it tells us the URL location of the API
that we're going to use, that's where we go to talk to the server to get our token.
And then you see that below that,
it has in bold here that it mentions the post method.
So we'll need to remember to set that
method parameter to post on the HTTP request object in Swift.
Next it requires the required query parameters.
The client_id and
client_secret strings were provided to us by Yelp when we signed up to use the API.
Each parameter has a name, so that's the part that we'll put in
before the equal sign, that's this name column here.
It has a type, in this case they're all strings, but sometimes it says you
need to supply numbers, or booleans, or decimal numbers, for example.
And then a description of the allowed values and format for each parameter.
So notice that you don't pass Swift strings or integers or
decimal types directly when you actually do this in code.
First you need to convert them to text format,
and then any resulting special characters would need to be present and
coded before it's actually written into the query portion of the URL.
Okay, and then that's it for
this description of the request that you need to make.
It doesn't mention anything about the HTTP body or header fields, so
we don't need to do anything special for those, for this type of request.
And then after that it actually tells us what we're going to get back
in the response from the server, ideally if we've done everything correctly.
So this data is parsed back to your conclusion block when the server
returns a result.
Its actually a JSON object where three fields, and
the important one here you're going to see is the access token.
You'll notice below that it says that, to authenticate
API calls we need to set that, set an authorization HTTP header and
it tells you how to do that using the access token.
So, in this request to get the token we don't need to set any header fields.
But in further requests, it's telling us to make sure we always
add the token as one of the values in the header fields.
All right, so let's take a, if you scroll back up here,
we can sort of look ahead a little bit, and take a look at the search API.
This is one of the functions we implemented in the Swift class as
an example.
So we just take a look and we can see that this one has a different path in the URL.
Same post but has a different path, and it's also saying here the method you need,
which is GET.
So this one has a slightly different method as well from the authorization.
And it has lots of, a lot more different types of
query parameters that you can use and actually not all of them are required.
So sometimes you can eliminate ones that aren't relevant for a particular search,
and it actually shows you which ones ones are optional, for
example, here in the description for each one.
But remember that you also need to include the authorization header key and
token value with each search request,
as I noticed that the documentation was telling us as well before.
And you can see how that works in the Swift code.
All right, so let's actually take a look at that code right now.
I'm going to go down to xcode and open up the Yelp API Swift class here.
It's called the YelpAPIClient.
All right, so I'm going to go down to the connectClient static function here.
This method downloads a token from Yelp server using that authentication
API that we just saw.
And then in the completion block for that operation,
it's going to construct an actual instance of the YelpAPIClient.
Copy that token into the access token property of that object and
then you can use that object for further API calls, later on in your app.
A lot of the code you'll see in this is actually error handling code.
Just to make sure we get some information back, for example,
if a request URL can't be constructed correctly.
But really what's going on here is pretty simple.
For each request, it's going to build up all the necessary parts of the HTTP
request, and then send that off using an NS URL session task.
When it gets a reply, it decodes the JSON data into the expected response.
So first, it constructs a URL, so has a string here that first includes
the host and the path, and then also uses string interpolation
to insert the client credentials that are required as part of that connection.
You'll see that it's using this encoded string for URL encoded form data.
This is just a special extension we created for
string just to make it easy to quickly encode special characters
using the string by adding percent encoding a method here.
So that actually escapes any special characters that might be present in
the user data here, the client_secret credentials that we're including.
There's the request string.
We use that string to create the URL from that string.
The next major part here is we create a mutable URL request
using that URL that we've constructed.
The request class has methods and
properties that then let us configure the actual request.
Really the only further configuration we have to do is to
configure the special HTTP method that we're going to use for this request, and
we noticed in the original documentation that it requires a POST connection.
So we just use a text string to set that to POST.
If we wanted to set any of those other parts of the HTTP request, like the header
fields or the body, we would do that using methods on this request object.
But we don't need to for this particular request.
And once we've done that, configured the request, we send it off using
a data task with request connection here, using NS URL session.
And when we get the data back, we check for errors and
then we do a series of conversions to turn that blob of data into
a structured JSON object and at the very end here get our access token.
Then we can construct a new instance of the YelpAPIClient class and
store the accessToken in that for later use in subsequent requests on that class.
So I'm going to go down here, we've implemented that location search function
here, to connect to that location search, business search API here,
to search for businesses by location.
So the format of this is quite similar, and this time you can see,
again, we're encoding the search terms and locations using that.
And we use those values to build up the request string.
And then we can go down and take a look at the request.
This time we're using the get method on this request, so
we don't actually have to set it, it's by default.
But we do have to add the access token as an HTTP header field.
If I go in here and look at add value, it's like a key value, you add a value for
the field name.
And I think this is incorrect here, I'm just going to fix that.
According to documentation, we need to set it to the authorization, and
field names, that's where the name of the field goes,and this is
where the value goes here.
So we've added a value to that.
And then again, we use that request to create a data task.
And once that is sent off,
it should return back the results of the search which are in JSON format.
And then we convert that into a Swift datatype which we can use to
access the actual value.
Okay, so that is how to create an HTTP request that you need to use to send off
to a server and how to populate many of the fields in that request.
If you want to learn how to turn an image into data that can be sent in the body
of an HTTP request for example.
You can take a look at the Microsoft cognitive services class that we also
included in the sample code, that shows you how to send an image back to
the server for analysis using the HTTP body part of the request.
So this is a pretty limited implementation of access to the Yelp API but
if you want to access more services from the Yelp API,
you basically follow the same pattern.
You go in, you can take a look at, for example, the search API and
go through some of the different quitter parameters that you can possibly use.
And then you can construct a request that populates those fields or
you can go in and take a look at some of the other API end points here.
And you can take a look at how requests are supposed to be constructed in order to
get more say details about a particular business.
But the pattern should generally be the same, and
we look forward to seeing what you come up with.
Thanks for joining me in this lecture and I hope you had fun and I wish you the best
of luck in your endeavors to connect to web services, it's really fun.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2018 Все права защищены.
