[MUSIC]

Let's get this course started.

The first thing that we're gonna do in this course is

we're gonna show you how to develop apps using the Twitter Social Network.

And in particular,

the tools that iOS has built into it in order to do connections with Twitter.

There's a lot of deep integration in the iOS Software Development Kit, SDK, for

working with some of the social networks, and so

we're gonna start off with that one.

We're gonna start by making an application that can tweet for you.

That you can use to tweet.

So what I wanna talk about at a high level is those things.

That iOS has deep integration with a few social networking sites, and

this makes media sharing very easy.

One of them, among many,

is Twitter, one of the ones that has deep integration is Twitter.

And so, we are gonna step through how to do it.

We're gonna step through how to make an app that tweets.

So at a high level I want to show you kind of a structure of

what we're gonna be building because as we get into the code it's really easy to

lose track of what's happening.

You can see that there are two high granularity items.

We've got user interface components and then we have the social framework.

The social framework is what's new and what we're gonna be doing here today.

I guess some of the small user interface elements will be new compared to what

we've seen before.

So starting over on the left side, we have the view controller.

Now, the view controller is what we have been working with all along.

When we build a single view application, that's what is single about it.

Just one view.

Into that new controller, we're gonna put a toolbar

that's gonna have a button that's gonna enable us to send a tweet.

We're also gonna put a text pane where we can type text,

whatever our thoughts are that we need to get out to the social network.

We're gonna be able to type it in there.

That button is gonna activate an object that we're gonna create also,

called a UIAlertController.

It's a little bit like a pop up window.

Into that window, into that AlertController,

we're gonna put two buttons that can perform an actions for us.

Both of the buttons are UIAlertActions, the easy one is a Cancel button,

that's just gonna stop the process and go back to allowing you to write

whatever is you're gonna tweet, but the other one is going to create a pop up

window from the social framework called an SLComposedViewController.

This is a little, mini composition window that's gonna be prefilled with our text.

And that is going to be the place at which we hand off control from our application

to the iOS software that we have brought in through the social framework.

We're gonna release our thoughts to the world.

The Twitter integration's gonna take over for us.

And our thought is gonna go out as a tweet onto the network, and

control will return back to our application.

So that's at high level how we're gonna go about doing it.

But there are a lot of steps to make this happen.

You may recognize some of these from our peer review projects

from previous courses.

The first thing that we're gonna do is we're gonna make the project, and

then we're gonna build and constrain the interface.

We're gonna make sure all the components are lined up well, and

we'll try it in the simulator and make sure it looks good.

We're gonna have a Toolbar and a UITextView, we're gonna connect those

components to our code, to our view controller so that we can access them.

We're gonna do a little bit of stylizing of the interface so

that it looks the way we want it to look, we'll bring in the social framework,

which is what's gonna give us the ability to send out our tweets to the rest of

the world, and then we're gonna create the tweeting actions.

And finally, we're gonna test and debug it,

and see what this looks like in a simulator.

So let's go ahead and get started.

Let's start by making our project.

To do this we're gonna go to Xcode.

You'll see that I'm using the Alfred tool in order to bring up Xcode.

So let's bring up Alfred.

[INAUDIBLE] So

let's go ahead and start Xcode, and let's create a new project for ourselves.

So let's start Xcode by using the Alfred tool that we have.

So let's use

the Alfred Search

tool that we've

talked about before

in our previous

courses, and

lets go ahead and

start Xcode.

A lot has changed over the last few days actually,

with the release of new versions of iOS 9 as well as OS X 10.11,

and so now we'll see that new scores,

we're starting off with the version of Xcode that's 7.01.

It's constantly being updated, so you may see slight changes in the user

interface or in some of the fields that if you try to follow along, but

it shouldn't be terribly different, just iteratively incrementally different.

We're gonna go ahead and create a new project in Xcode.

And we're gonna make it a single view iOS code.

We're gonna make a new project in Xcode.

So let's go ahead and bring that up.

It's gonna be a single view application.

Go ahead and hit Next and start it and we'll

call this product the TwitterShareProduct.

The organization will just by name for this, and we'll go ahead and name this

organization net.djp3.coursera.02, and we'll call it TwitterShare.

It'll be objective C, it's gonna be universal, and that should be good to go.

We will put it here in our standard iOS workspace on our hard drive, and

then we've got our project all ready to go.

So let's take a look at what our next step is.

The next thing that we wanna do is we want to build and constrain the interface.

So by that I mean we are gonna put the components that we want to have in our

ultimate in our final application and were gonna lay it out correctly.

So let's do that.

Let's go ahead and go to our storyboard.

And bring up R code on the side.

We're not gonna need that right away, so sort of shrink it over.

And the first thing that I like to do is I like to work by turning off size classes,

so I'm gonna turn off size classes.

And the first thing that we're gonna add at the top is gonna be a toolbar.

So I'm gonna come down to our object library, and search for toolbar,

and I'm gonna put that up here, and that's pretty good, and

the next thing that I'm gonna add, is I'm gonna add a UITextView.

Got a spot right now.

And I'm gonna put that down below.

And now, let's see, the next thing that we need to do to these items is we need to

give them constraints, so that they take up the right amount of room.

I want that toolbar to be constrained, so that it reaches the entire size,

the entire width, and is as close to the top as possible.

So I'm gonna come down here to my constraints.

And I'm doing to click here indicating I want it to be 0 pixels from the top, and

I want it to be minus 20 on the left, and minus 20 on the right.

Which means gonna write over the margins that are built into the system.

I'm gonna go ahead and add those three constraints.

That looks pretty good.

And then for this text view, I'm gonna do a similar thing.

I'm gonna go ahead and stretch it out so it fills up the whole screen.

Looks good.

Bring it right up to the toolbar.

And I'm gonna go head and add the constraints there, as well.

I'm gonna have it be 0 from the top, minus 20 and

minus 20 for the margins on the side, and 0 from the bottom.

I'm gonna add those for constraints, I think that's gonna be enough, and

let's go ahead and run it in our simulator.

We're gonna go ahead and run it on an iPhone 6s plus, why not.

Go ahead and run it.

As soon as our project builds, it's gonna bring up the simulator.

We're gonna probably have to resize the simulator,

because it's got more resolution that what my screen capture, here, can recognize.

So we'll see if we can do that.

I think I'm already shrunk, let's take a look.

Scale is 50% so I'm already in good shape.

So now, if I look at my application, I'm pretty happy with it.

That looks good, it looks like it's filling up the screen nicely and

the constraints look pretty good.

Just to be sure now that I got it right though, I'm gonna go ahead and try and

run my code on a different platform.

Let's try the iPad Air 2 and run it, make sure that

those constraints are still working when the screen size changes drastically.

We're gonna rebuilt, looks good, so I'm pretty happy with that.

So let's go back and see what our next step is.

We went ahead and we built and we constrained the interface.

We added a toolbar, and we added a UITextView.

Now, what we need to do is we need to add some connections and

make a few changes to our system so that we get the behavior that we want.

[MUSIC]

[BLANK AUDIO]

Twitter App: Setting up the User Interface

Networking and Security in iOS Applications

Meet the Instructors