Core Data: Wiring the UI to CoreData

Loading...

En provenance du cours de University of California, Irvine

Networking and Security in iOS Applications

233 notes

Explore Related Videos

At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you

University of California, Irvine

Networking and Security in iOS Applications

233 notes

Cours 2 sur 6 dans Specialization iOS Development for Creative Entrepreneurs

You will learn to extend your knowledge of making iOS apps so that they can securely interact with web services and receive push notifications. You'll learn how to store data securely on a device using Core Data. You’ll also learn to securely deploy apps to the App Store and beta users over-the-air. The format of the course is through a series of code tutorials. We will walk you through the creation of several apps that you can keep as a personal app toolbox. When you make your own apps after this course, you can bring in these capabilities as needed. When necessary we pop out of the code tutorials to talk about concepts at a higher level so that what you are programming makes sense. Upon completing this course, you will be able to: 1. Post Facebook, Twitter, Sina Weibo, Tencent Weibo messages to social media using single sign-on on behalf of a user. 2. Use OAuth 2.0 to securely authenticate to Instagram and retrieve photos on behalf of a user 3. JSON 4. Describe JSON’s syntax 5. Write well-formed JSON 6. Work with JSON data objects in Objective-C 7. Appropriately set the security settings for App Transport Security in iOS 9.0 8. Use http, https and https with perfect forward secrecy to fetch web resources 9. Obtain permissions to receive local push notifications 11. Write an app that can send and receive local push notifications 12. Obtain permissions to receive remote push notifications 13. Write an app that can receive remote push notifications 14. Authenticate using Apple’s cryptographic services such that the developer can use 3rd party infrastructure to send remote push notifications to their app. 15. Securely store data on the user’s device. 16. Authenticate using Apple’s cryptographic services such that they can deploy an app to the app store

À partir de la leçon

Storing Data

In this week we look at method of securely storing data on the iOS platform called Core Data.

Core Data: Introduction17:20

Core Data: Setting Up Your Project8:25

Core Data: Building the Model16:26

Core Data: Wiring the UI to CoreData19:15

Enrichment: The Full Core Data Example 131:09

Enrichment: The Full Core Data Example 216:02

Rencontrer les enseignants

Don Patterson
Associate Professor
Informatics and Computer Science
Sam Kaufman
Partner at Gradient

[MUSIC]

Okay, let's put the code together now to

connect our interface to our managed object context.

So that we can allow our user to create some data,

then we can persist it for them.

All right?

To do that, we're gonna need to make the interface,

which is going to collect the data.

Then, we're going to also have a way to list the data in our interface.

We will add a method to delete the last entry in our interface with

another button.

And then, we will write code to add an entity as well.

Write the code to show our data, and then write the code to delete the entity.

So, to connect it all together, all right?

So, let's go back to our project.

[COUGH] Excuse me.

Let's go to our story board and let's set it up for ourselves.

Turning off size classes.

And then, I'm gonna

add a text field where we're going to enter in the chores that we'd like to do.

Go about halfway out,

because we're gonna be building it out for the rest of the interface soon.

We'll add a button, add a button below it.

And we'll make it the same width.

And we'll say, make that button say Add A Chore.

All right, and then we're gonna make a label and

that label is just gonna be someplace where we can show our persistent data.

Now there are gonna be better ways of linking our persistent data to user

element items that we'll look at in the future, but for now, this will work.

All right.

And I wanna set some properties of that.

For example, I would like it to be centered and

I would like it to display more than one line.

Let's just say 50 lines and we'll scroll, I guess, if we don't like it.

Then, I want the label to be constrained to the bottom.

So, we'll constrain the label to the bottom.

And we will take this element and

we will say it is going to be that distance from the top.

And this element will be [SOUND] Did I get that right?

And this element will be centered horizontally and

have the same vertical spacing.

Okay.

Now lets see the interface that we have available to us with our View Assistant.

And what we're going to do is we're going to have a chore tapped

function that we're gonna add here.

All right, what our chore tapped function is going to do is it's going to be when

we type Add a Chore, we're going to use our app delegate, the app

delegate that we initialized when we first loaded our interface controller, and we're

going to ask our app delegate to create our chore managed object and return it.

Now, we're getting an error there,

presumably because it doesn't know about the chore managed object,

which is strange because we have already included our AppDelegate.h.

But when we created our chore, when we created our createChoreMO method,

in our AppDelegate.m, we didn't put a interface,

a declaration in the .h file so that other functions could use it,

would know about it, so the Xcode would know about it.

So, we come back here to appDelegate.m.

These are the three functions that we added, three methods we added.

I'm gonna copy them.

And then, I'm gonna go to our header file for the app delegate.

We can see that some other things are already here.

These were created by Xcode primarily.

Let's get us a little more space.

[NOISE] Can we please

These are the things that were added by Xcode.

Let's go ahead and

add our functions that we had that we want the rest of the world to know about.

Actually I kind of like to put them below the properties.

That is just a style item.

All right, now these are the actual code.

All we wanna tell people about are the interface.

We don't wanna tell them about the implementation.

[NOISE] So,

by putting these declarations into our .h file,

anyone who includes this .h file will be able to use these functions.

Now within this .h file, we still don't know about these objects,

so we also need to import ChoreMO.h in this file, and

import PersonMO.h in this file, and import ChoreLog.h in this file.

If all goes well, ChoreLogMO.h.

If all goes well, everything will compile okay.

Great.

And now, we can go back to our storyboard and bring up our assistant again.

And we can ask,

where did our interface go?

Hm, that's kind of weird.

Okay I'm not sure why our interface disappeared there, but

I'll rebuild it, and we'll go from there.

All right.

So let's run it, see if our layout looks okay.

All right.

While the simulator is coming up, we'll come over here to choreTapped.

There it is.

Okay.

Great, that looks fine.

All right, so now when we come over to choreTapped and

our interface is back in place, we can see that we have this variable c.

We've called create chore managed objects,

so c is going to become a managed object that we're gonna be able to work with.

And that managed object, we need to have its name.

So, we're gonna need to get the name for

the chore, from whatever the user entered in.

So, we want to get that here.

Get that here.

And we'll call that Chore Field.

So, when the user enters in the name for the chore we're gonna add it.

So, we need to get that text.

And now we have this managed object.

And this managed object, remember, was created from our entity.

And remember, we had this thing, this element called chore name, which we set up

in our managed and our entity builder.

So now, we can just get the chore field text and assign it to that managed object.

Now this managed object, there's a reference to it in our scratch pad.

So, as we write it, it's being managed for us by our managed object context.

So, after we set the chore name of that object to what we want it to be based on

what the user entered, we're going to go back and we're gonna get a reference to

our appDelegate, and then we're gonna call saveContext.

And that's gonna make all of our managed objects that we're working with,

wherever they are in their application, they're gonna be persisted.

They're gonna be saved to disk.

So after I run this line,

any change that I need to see will be there when we restart our program.

If the program were to crash for

some reason in the millisecond between the time when we set the chore name, and

before we saved it, that chore name would not be remembered.

That would not have been saved.

In fact this object that we created would not have

been saved even as an empty object.

Then the last thing that we're going to to is we're going to update

all of the names of chores that we're gonna put here down here in our label.

So what does that look like?

Well let's see.

Let's save everything so we don't lose it.

And what I'd like to do is just get a little bit more space here.

Here we go, okay.

So what Update Log List is gonna do is fill out our label at the bottom for us.

So again, we're going to get our managed object context, because what we wanna do

is we wanna get all of the chores that are available to us and

put them in the bottom.

So, in order to do that, we have to have an iterator that's going to go through

every element in our database so that we can do something with it.

In this case, what we're gonna do is,

we're gonna pull out the name and we're gonna add it to our label text.

So, we're going to have a fetch request.

We're gonna fetch. What are we gonna fetch?

Well, we're gonna fetch all the elements of our chore entity

that is referenced from our entity builder.

And then, we have some code here where we're going to get the results,

we're going to execute that fetch in our managed object context.

And as long as we have some results,

as long as we receive some results back, if we didn't, there's an error.

We'll abort our program which is bad for

production code, you don't want to do that in production code.

Instead you'd want to do something more graceful, but for teaching it's okay.

And then what we're going to do is we're going to create a mutable

string that's going to be initialized with nothing.

And we're going to go through each element in our persistent data, and

we're going to add the name of the chore to our string.

So we're gonna be doing that through a fast enumeration method,

going through each of our results, where each element in our results is a chore

managed object that we've gotten from our persistent storage.

We're going to append to our tour-managed object a new line character

in the name of the chore from that particular persisted object.

And then when we're done, we're going to save that in the label,

which we'll call persisted data.

But we haven't called it that yet, so let's come back here to our storyboard.

Great, it hasn't gone away, happy for that.

And lets give our label a name.

Our label's going to be called persisted data because it's going

to show the data that has persisted.

Very good.

Let's go ahead and put a constraint on it so that it's tall enough so

that we can see.

The results.

So, when we tap the chore, we're gonna create a new object.

We're gonna set the name of the chore to the name that the user has entered.

We're going to tell our manageObject context to save everything.

And then we're gonna update our log list based on what has been saved.

And since we would like our application to start out with the newest data

that's from, and that's been persistent, when we first start our application,

We're also going to update our log list, so that when we start our application

everything that's in persistent storage will be there.

I'm gonna delete this template code here for clarity.

The last thing that we'd need to do is we didn't actually connect our button to

that, so we're gonna connect our button to that action.

I need to do it with the right

Here we go. No, the other way.

Okay.

Now, if we run our program, we should be able to add chores to our list.

We should be able to stop our program and that data should be persisted.

And that's an example of securely storing data using core data.

Let's see if it works.

All right, here's our application.

Our label down here is empty because we don't have anything in persistent storage.

If we would like to add a chore we can add washing dishes.

We'll add a chore which will ask for a new persistent, a new managed object.

We'll set the name of it.

We'll save that persistent, we'll save all the persisted objects.

And then we'll update our list.

Yay, it's there.

And then let's see, let's do wash the dog.

We'll add that chore.

Same thing happened.

Now, if we stop our application, and we actually swap it out of memory.

And then we run it again.

We'll see that our chores have persisted across multiple runs.

All right, so

the only thing that we have left to do is to write the code to delete an entity.

To do that, we do the same thing.

We access our managed object context.

We find the entity that we want to delete, and then we can execute a deletion.

So let's do that.

Let's go to our interface, stop the running application.

And let's just add a delete button.

And we'll add a function.

That is deleteTapped.

And in this case, we have to identify what is the element that we want to delete

And to do that, we're just going to do very similar.

Request.

We'll just request everything and we'll delete the first one.

No, we'll delete them all.

How's that? That's good.

[SOUND] So we're going to here lets get a single view again.

All right.

We're gonna get our manage object context

that we've stored from our app delegate when we started our view controller.

We're going to request.

We're gonna create a request, a fetch request for all of the elements and chore.

And we're gonna execute that request and as long as we don't have errors,

we're gonna have this result object.

And then we're gonna go through each one of these.

I'll copy it from down here.

And rather than printing something out or rather than collecting data,

what we're gonna do is we're going to send a message to our managed object context

to delete an object.

And the object we're going to delete is going to be C.

And then, the last thing we'll do after we do this, is we'll update our list again.

So, by pressing that button.

We will go through and we will delete all the chores and

in order to make them persist, we also need to make sure that we,

after that that we reflect those changes in our persistent storage.

So we'll have to do, save context.

So that, and the scratch pad, or managed object contacts,

knows that those elements have been deleted.

But it's our scratch pad, in order for our scratch pad status to become persistent,

we have to say, save contacts.

Whether that involves making a new object, or deleting objects.

Okay, so that should be good.

So last thing we need to do, is we need to wire it to our delete button.

And now if we run,

we'll see those elements before that were there when we ran.

And if we hit Deete, they're all gone.

Now, let's add some more chores.

And then what I'm going to do is, I'm gonna exit this.

And I wanna point out that if you completely remove an app from your phone,

and you get this warning that says, delete all the data as well, what that means now,

and maybe it's a little bit more clear, is it's gonna delete the SGLite database

that's associated with your persistent object.

So if we actually delete the app entirely and then we rerun it.

We'll see that in this case the data didn't persist, that's because we didn't

just stop the application, we actually removed it entirely from our phone.

And when we remove it entirely from our phone, that assumes the users

uninstalling the app and wants the space back that it was using to store data.

Okay.

So in summary, core data has a special set of tools for creating models.

We've seen that.

And once built Xcode will write the code for us to manage the models and

to persist the data.

But we have to wire the interface in order to create a new object, in order to

put it into the database and in order to delete it if that's what we wanna do.

Thank you.

[MUSIC]

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2019 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play