Transcript
>> My name is Chris Kane and I'm an
engineer with the Cocoa Frameworks team.
Today, I'm going to be talking about what has changed
in Foundation for iPhone, not iPhone OS 4, iOS 4.
iOS 4's Foundation represents the
first major update to Foundation
that you folks working with the iOS SDK will have seen.
In iPhone OS 2 and iPhone OS 3, we saw a Foundation
in the system which was essentially the system,
the Foundation that was in the Mac OS X, 10.5 with, you
know, a few changes here and there; some APIs were missing
and there were a few of the little additions.
In iOS 4, now we have a Foundation which more or less
corresponds to the Foundation in Mac OS X, 10.6 with,
you know, some things that are, you know,
different still, including some new APIs
that haven't yet appeared in Mac OS X itself.
Now there have been a lot of changes.
I can't cover all of them so I'm going
to be covering the highlights here.
I'm going to begin by talking about blocks and new
block-based APIs that we've added to Foundation
and then I'm going to cover some
additional changes that we've done.
So I'm beginning with blocks.
Why? Well, blocks are a very interesting,
new functionality that we've added
and they're a very important new functionality as well
but another key reason that I'm beginning with blocks is
that as we, we'll see a little bit today but also going into
the future, block-based APIs are going to be very important.
And as we move forward, it's very likely
that a block-based API may be the only way
to get access to certain functionality.
So it's very important that you understand blocks
and understand how to use them properly in order
to access all the available functionality in the system.
Well, for those of you who may not have seen
all of the public materials that we've had,
out since at least Snow Leopard was released back in August
last year, I'm going to do a little review of blocks.
So what are blocks?
Well, a block is an object which represents a chunk of code.
A block is used much like a function.
If you're familiar with say functional
programming languages, you may have seen closures.
In C++, you may have run across things that,
constructs that are called function objects.
You know, certain ways you write C++ classes
and those things are very similar to blocks,
not quite the same though but very
similar in spirit to blocks.
Well, blocks are objects with some code,
that know how to execute some code.
The key interesting thing Ob-C
is that they are like NSObjects.
They respond to all the NSObject methods.
But blocks are not simply an Objective-C
bit of functionality.
Blocks are available to all the C-based languages
for which Apple ships a compiler, that's C, C++,
as well as Objective-C and Objective-C++.
Now, as I say blocks are bits of code.
Blocks are used a lot like function pointers.
Here, I'm going to demonstrate the basic syntax of
using a block or declaring a block, I should say.
First, I have a variable there on the left
called myBlock and in front of it is a carat.
The carat is the signal to the compiler
that you're intending to declare a block.
Block-type declarations look a lot
like function pointer declarations
with the star or the asterisk replaced with a carat.
In this case, the block returns an int, so that's the return
value, the return type I should say, there on the left
and it takes one argument, which is also int.
So a very simple block.
On the right side of the assignment operator, we have a
block literal and you'll see, you'll be seeing these a lot
and you'll be writing these a lot in your code.
At the left side of the block literal,
we have the carat sign followed
by the parenthesized argument list
just like a function argument list.
In this case, we have of course the one argument
which is called num and then inside the curly braces,
just like a function has, you know, curly braces surrounding
its body, we have all the statements of the block.
myBlock in this case is very simple.
It's just got one return statement in it and all
the return statement does is multiply num by,
which is the argument, by this variable called multiplier.
Now, this particular case, the block is very simple but
you can have many lines of code within the curly braces
but for the purposes of my talk, I have to keep
the blocks nice and short to fit on the slides.
So I'm not going to be showing a lot
of multiline blocks in this talk.
Well, I didn't explain what this was.
I said it was a variable called multiplier which,
you know, you can obviously see for yourself.
Well, all this is, is a local variable.
One of the most interesting things about blocks is that they
can access and capture variables' values that are in scope.
So in this case, I have a local variable called
multiplier which the block can sort of access out.
It doesn't have to be declared within the block.
In this case, it's being declared outside the block but
the block can still get at it because it's in scope.
Now, if I want to use myBlock which I've
declared, I call it like a function.
So in this case you see myBlock with
the parenthesized list of arguments.
In this case, I'm going to pass
in 3 for the integer argument.
Now, if I change multiplier after declaring
the block, nothing's going to happen.
That has no effect on the block.
That's the reason I talk about this as being
capture, capturing the values that are in scope.
So at the point where the block has been
declared up there on the line above,
the value in multiplier was 7 and that value is captured.
Now in this particular case, I just have a constant
value there but it doesn't have to be constant.
I could have gotten multiplier by, initialized by,
you know, calling a function or something like that.
But at the point where the block has
been declared, the value is captured.
So I can change multiplier after that
and it will not affect the block.
In this particular example, I'll always get 21.
That is 3 X the multiplier 7 as a result of my printf
statement, even though I've changed multiplier afterwards.
Blocks can be used, of course, then as arguments to
Objective-C methods and now we're going to begin seeing
where we've added new APIs within Foundation.
In this case, I have a new method,
enumerateObjectsUsingBlock.
This method will call the block, invoke the
block once for every object in the collection.
So here we see the first bug in the
slides if you're paying close attention.
The method is called enumerateObjectsUsingBlock and
then there's a block argument following it with a type.
Well, that blue box in the second line which is
enclosing NSUInteger index should be extended really
over all of the parenthesized material.
That is the whole type of the block,
that big long mess in parentheses there
and then on the far right we just
have the name of the argument block.
Well, within the block type, we have the return value, void.
We have the carat then and then we have the
parenthesized argument list, just as if you would pass
in a function pointer to the method as an
argument, the first argument being an object,
the second argument being an NSUInteger and
the third argument being a pointer to a BOOL.
So let me give an example of how
I would use this new method.
As I say, this method will be invoked once, oh, I'm sorry,
the block will be invoked once for
every object in the collection.
In this case we have an array.
So first, I begin, I have a nameToSearchFor,
some sort of NSString and for every object
in the collection, I want to ask the object for its name.
I'm going to assume that the, or I know that
the objects will respond to name and I'm going
to compare that with the name I'm searching for.
So I may be searching for the name
Bob, for example and I'm going to look
at all the objects and find the objects whose name is Bob.
In this case I'm going to do something
trivial, I'm just going to NSLog out the index
so that's the second argument that
I'm getting in this block.
I'm just going to NSLog the index
of that object within the array.
Well, that's very boring.
Instead, what I really want to do is I want to search for an
object whose name's Bob, say, and then I want to remember it
and do something with it after the method returns.
So what I've done is I've added a new local variable
called found, and in this case I've initialized it to nil.
And within myBlock now, I'm going to set found to be
the object that I find and I'm going to set stop to yes,
and I'll explain what that means in a minute.
But if I do that, I'm going to get a compile error because
as I said before, the local variables which are outside
of the block which are being captured by the block are sort
of, in the sense having their values copied into the block.
So I can't write to that because essentially what
the compiler's done is it's captured the value
of nil and put that in the block.
So this is like writing nil equals object
and that's going to give me a compile error.
To tell the compiler that I want to,
really do want to write out as it were
to the enclosing scope, I need
to add a new keyword, __block.
This is a new type qualifier that tells the compiler that
found should be compiled in such a way that I can read it
in the block but also write out to it as well.
Now that stop parameter that I'm using at the
bottom of the block, let me explain that briefly.
What that allows me to do is stop the enumeration.
So I'm writing through that pointer that myBlock has been
given and I'm writing yes in order to stop the enumeration.
If I have say a million element array and I,
you know, find after element 3 that I don't need
to continue the enumeration, well, it's very nice
to be able to stop it rather than having to proceed
through all million elements of the array.
So that's all that BOOL and stop parameter is for.
After this method returns, if found is no
longer nil, I know that the block set it
to something and I can go operate on it then.
Well, there are many new collection
APIs that are using blocks.
These are various methods on the collection
classes, arrays, dictionaries, sets and index sets.
We've seen one example so far, which is one
example of the enumeration class of new methods.
Enumerations are, enumeration methods are there to
invoke a block once for each object in a collection.
Before I go on, let me do an aside here which will help,
you know, make you understand or allow you to understand,
you know, some of our naming conventions
with these new block methods.
Well, in the case of an array, you have objects in the
array so the method is called enumerateObjectsUsingBlock
and in the case of Dictionary,
dictionaries have keys and objects
and so the methods are obviously called
Keys, enumerateKeysAndObjectsUsingBlock.
The type signature of the block argument which is taken
by these methods is also different
based on the particular collection.
Arrays are ordered collections and so they
have objects but they also have indexes.
The index of each object is interesting and so we pass both
pieces of information into the block so you don't have to,
you know, somehow compute the index yourself if you need it.
In the case of dictionary, well, dictionaries have keys
and objects so we pass in both of those into the block
so you get them both at once and don't have
to go, say looking up the object as you do say
if you're using the foreign syntax
to enumerate over a dictionary.
Well, in NSArray for example, and this
is true in the other collections as well,
and NSArray is just being an example
here, we also have extended methods.
So for example, there's a method that takes some options.
There are different ways you can enumerate an
array so we provide a method that takes options.
For an array or an index set which are ordered collections,
you can also choose to enumerate only over a subset
of that collection and you do that by specifying an
NS index set for those collections which are ordered.
Well, what are those enumeration options I mentioned?
Well, for an array or an NS index set, of course sometimes
it's interesting to be able to enumerate the collection
in reverse so there's an option for that.
But the more interesting option is NSEnumerationConcurrent.
This allows you to enumerate a collection but
concurrently, that is your block may be invoked
on multiple threads simultaneously as the enumeration
algorithm enumerates, that is calls the block once
for every object in the collection but it may
call it once on multiple threads simultaneously.
And this can result in a nice little
performance boost because you can, you know,
do things simultaneously for every object in the block.
Now your block when you use this
option needs to be thread-safe.
You need to take care of the thread safety of what the block
is doing and what the block is accessing inside the block.
Well, in addition to enumeration, we have other
classes of new methods which are used in blocks.
One class is searching.
I've already illustrated searching
but using the enumeration API.
Previously, we were searching for a name whose
object or whose name matched a certain value.
Well, we packaged that kind of
thing up into other sets of methods,
one example is this NSArray method,
indexesOfObjectsPassingTest.
The interesting thing about this method is
that instead of void, the block returns a BOOL.
So the block is going to be given the same arguments,
that is it's going to be given the object in the index
and the Boolean point or stop value but what the
block is supposed to do in this case is it's supposed
to test each object and return yes if the object matches
some sort of test that you want to apply to every object
or return no if the object doesn't match.
The NSArray algorithm in this case behind
this method is going to collect all
of those objects' indexes for which the block returns yes.
It's going to collect them all and when the enumeration
is done, it's going to return an NS index set
and so then you have the indexes of all the
objects which match your particular predicate.
The enumeration objects' options
apply to these methods as well.
So for example you can do this
searching concurrently if you want.
Blocks can also be used in typedefs so you can create
a new type which is a block type using typedef.
In this case, we have a new API which I'm
going to illustrate called NSComparator.
This is a new type in our API which takes
two parameters, two objects and it's supposed
to compare them and return an NSComparisonResult.
An NSComparisonResult, that's an
existing type that is an enumeration
which is either less than, equal to or greater than.
So basically a comparator block is
given two objects and it's supposed
to return whether the objects are less
than, equal to or greater than one another.
Well, where do we use this?
Clearly, an interesting place is in sorting.
So an NSArray has several sorting methods
and we've added some more using blocks
as the comparison function essentially.
One example here is the sortedArrayUsingComparator method.
This returns a new array which is the
sorted version of the receiving array.
I have an example here at the bottom of the
slide showing how I'm going to call that.
Suppose I have an array called myArray FullOfStrings.
Well, I'm going to call sortedArrayUsingComparator
and pass in a comparator block.
So the block begins with the proper declaration for an
NSComparator, that is the two parameters have to be id
of the block and within the block, in this case, all I'm
going to do is I'm going to pass the two strings essentially
to the localizedStandardCompare method
and return whatever its result is.
So in this case, my block is fairly simple but you
can see here the power of the new block syntax.
Instead of having a comparator function or comparator
selector which is implemented off somewhere else
within the API, you can put the comparison logic right there
with the sorted array, you know, method that you're calling.
So the logic doesn't have to be separated, the logic that's
being used for the comparison doesn't have to be separated
from the actual creation of the sorted array itself.
Well, just as with enumeration,
there are some sorting options.
The first option, you can sort
concurrently if you want and this again,
just like with enumeration can
provide you with a speed boost.
If you pass in this option, again, your
comparison block needs to be thread-safe
and what this does then internally is it
invokes a completely different algorithm
for sorting which sorts concurrently.
It uses, you know, up to all the cores
on your machine in order to do the sort.
There is also a new option we've
added which has long been requested,
one for stable sorts, if you want to do a stable sort.
We've also provided a new option for that.
Another new API we've added, in this
case to NSArray is binary search.
Here we have indexOfObject inSortedRange options
usingComparator and you pass in again a comparator block
to do the comparison in order to
implement the actual binary search.
So this is an example of a new API for
which there isn't a non-block alternative.
Strings can also be enumerated.
We've added a new API to enumerate
pieces or chunks out of a string.
The new enumerateSubstringsInRange options usingBlock method
takes a block which gets several arguments passed to it
as you can see there and you can choose
to enumerate the lines in a string
or the paragraphs but also the words or the sentences.
Now clearly for words and sentences, some form
of linguistic analysis is going on because
of course the string might have different kinds of
languages embedded within it, texts of different languages.
And so some linguistic analysis is
going on and that's another new piece
of functionality that's been added to iPhone iOS 4.
So that's blocks.
Now I'm going to go on to some of the other new
functionality we've found, we've added, sorry,
in iOS 4, beginning with regular expressions.
Regular expression has long been a requested
feature and now we are getting around to adding it.
The new NS regular expression class
represents a regular expression.
Basically, you can think of it as compiling the regular
expression if you've used other regular expression APIs.
So we have in this example, a new regular
expression being created with the pattern of ..d,
that is any character followed by any character
followed by d and that will be our regular expression.
So that regular expression will match any two
characters followed by the literal letter d.
Well, what do you do with regular expressions?
Well, the most important thing is you find matches to the
regular expression within a string and so in this example,
I have a string called, with the contents good
food today and I'm going to look for matches
for my regular expression pattern in this string.
So I ask the regular expression for, to return me
the matches in string options and give it the range,
in this case the entire range of the string.
And what does that return me?
Well, that will return me an array with three matches
in it and here I've shown the regular expression
above the resulting matches within the string.
Well, how are these, what's in this array?
How are these matches represented?
Well, we do that by using a new, another
new class which is NSTextCheckingResult.
So the array will contain three NSTextCheckingResult
objects and these objects represent the,
describe I should say, the overall
range and the ranges of capture groups.
Capture groups are an advanced functionality of
regular expressions that I can't go into today.
Well, instead of getting an array back with a
list of all the matches, you can with a block
and this new block-based API, enumerate through all
the matches of a regular expression in a string.
And so that's what this new API is for and it also
gets passed in NSTextCheckingResult to represent,
to describe the range of each match and some
additional bits of information in the flags.
The second most common thing that you do with a regular
expression is you replace the matches that have been found.
Well, one of the new methods, not all of them
but one of the new methods that allow you to do
that is this new string by replacingMatchesInString method.
This takes a string that you give it, that's the first
argument there and will return you the new resulting string
after all the regular expression matches
have been replaced with the template.
Now it's called a template because it's not
simply a literal string that you can replace in,
that you can replace all the matches with but if
you are using capture groups and that functionality
within your regular expression, the
template can also be used to, you know,
say where you want each capture group to be substituted.
But in this case I'm not using capture groups.
I'm just using a very simple regular expression and
I'm going to replace with a very simple string #.
Now I don't know why you'd want to take the regular
expression like any character, any character,
d and replace it with #, but if you do that,
you get something like this and a g# f# #ay.
Well, and a string also has some new
convenience methods on it that allow you
to access the regular expression functionality that's
primarily embodied by the NS regular expression class.
The rangeOfString method now takes a new option called
NSRegularExpressionSearch and that says to the method
if you pass that argument in or that option in, that
says to the method, hey, the pattern I'm looking
for is actually a regular expression not a literal string.
And that was actually added in,
if you were paying close attention
to the iPhone 3.2 SDK, that was actually added in 3.2.
That also applies though to 4.0, of course as well.
The new option also applies to all the find and
replace methods in iOS 4 although it didn't in 3.2.
Now that's all I can go into as far as regular
expression although that's a very interesting topic.
So if you want to know more, I'm going to have to pass you
off to Doug Davidson who's giving an Advanced Text Handling
for iOS, I guess that should say, talk later
today, this afternoon at 4:30 in the Nob Hill Hall.
So what are some of the other changes
that we've done in Foundation?
So I'm going to do some surveying of
some of the more interesting changes.
The first is delegate, I want to
talk about delegate protocols.
Historically, we used to describe delegate protocols,
that is the methods that a delegate object
could be sent by using a category on NSObject.
So you would see this kind of thing in the header, where
there was @interface NSObject followed by the category name
and then a list of methods and that was supposed
to document the methods that a delegate,
in this case an XML parser delegate, could receive.
Well, we've switched that to using
formal protocols in iOS 4.
And so now what you see in the
header is a @protocol declaration,
in this case for a protocol called NSXMLParserDelegate.
And again, with the list of methods that
the, you know, delegate can receive,
most of those methods being optional methods.
Occasionally there might be a required
delegate method that you have to implement
but usually delegate methods are optional.
We've also updated the types that the delegate method
returns and the set delegate method takes as far as the,
you know, what the type of the delegate is.
So this is telling the compiler, hey, check to make
sure that the delegate, that this person setting
on this object actually conforms to the new protocol.
Well, what you may have to do in iOS 4 then is update
your delegate objects to conform to the new NS, well,
in this case, NSXMLParserDelegate protocol.
Of course, every delegate has its own protocol but you might
get compiler warnings that you can only shut up by making,
declaring that is the delegate
as conforming to the protocol.
In NSPropertyListSerialization, we've
introduced some new methods that return NSErrors.
The older methods in NSPropertyListSerialization which
allow you to parse and create flattened property lists,
the older methods used to return
NSStrings by reference as errors.
So the new methods return NSErrors
by reference, if there's an error
and this allows much more rich error
information to be returned to you.
We've also introduced new stream-based methods
so you can pass in say an NSInputStream
and have the NSPropertyListSerialization
class parse a property list off of the stream.
In this particular example, I'm going to use the
propertyListWithStream method, I'm passing there
and NSInputStream which I've created and opened and
so it's got the contents, presumably has the contents
which should be parsed, you know, ready to go.
And I'm going to, you know, let me pass in other arguments
including the pointer to the error that should be filled
in non-error and if I get back non
nil from this, everything worked.
But if plist is still nil after this method
returns, then there was an error and I should go off
and look at the error argument or the
NSError variable that I passed in.
NSData has a new method.
Just like you can search for a string within another
NSString, now you can search for bytes within NSData
and you can search for one data within another data.
Just like with string, where you can search for a string,
you can pass in a few different arguments, or I'm sorry,
a few different options as one of the arguments.
In the case of data, we support the Backwards and Anchored
options, Backwards of course allowing you to search
from the end of the data to find matches and Anchored
allows you to, say, hey, only tell me that there's a match
if the match occurs at the beginning or in
the case of backwards, at the end of the data.
NSString has a new compare method.
I actually used this in an earlier example
in the talk, localizedStandardCompare.
We've added this method in order
to encapsulate what we consider
to be the standard comparison of the system, if you will.
So if you want to sort something in the UI, usually it would
be sorting for the, you know, UI presentation to the user,
you could use this new method to compare your strings.
Now the exact behavior of this method
is not strictly defined because we,
of course may want to change what we consider to be the
standard system sorting behavior from release to release.
So you can't use this if you really need
to depend on a specific sorting order.
What you're using this method for is if you want to
match what, you know, say Apple's apps are showing
when they present sorted lists to the user.
NSAttributedString is a new class that we've added.
We actually added this in iPhone OS 3.2
but it's still there of course in iOS 4
and NSAttributedString represents a string plus ranges
of attributes that apply to various chunks of the string.
The easiest way to think about this
is in terms of say mark-up text.
In this particular example that I'm going to show you,
I'm going to use various text and font attributes.
So I have a string here, which is this text is green
and bold and the last half of the string has some sort
of green text color attribute added to it.
I don't know what that attribute is.
I'm not going to define any such attribute.
You just have some sort of attribute
which has changed its display to be green.
The last word, the word bold has had, has some sort of
bold font attribute added to it or applied to that chunk
of the string and so the word is also
appearing in bold as well as green.
So you can see the ranges of mark-up can overlap as
well and so that's what NSAttributedString is for.
Another class that we've added is NSFileWrapper.
NSFileWrapper exists in the AppKit
over in Mac OS X where we've brought it
into the phone and, but added it to Foundation.
File wrappers are generally used to represent
a collection of files as a single file
or as a way to group multiple files together.
For example, you have a directory which contains multiple
files, the main primary document file along with a set
of subordinate files which are like
associated somehow with that main document
so that for example, as I say here, images.
So if you have a document with some associated
images that, you know, go with the document,
you can group them all together into an NSFileWrapper
directory and use NSFileWrapper to access those.
One of the key advantages of using an
NSFileWrapper and any file wrapper API is
that it offers fast incremental saving of a document.
So if you've only changed say one file within a document,
NSFileWrapper document, and you need to resave it,
the saving is much quicker than rewriting all of the files.
NSOperation has had a few new methods added to it.
For an NSOperation, now you can wait until
it is finished, if you really need to.
What this does is simply blocks the current thread,
waiting for the NSOperation to go into its finished state.
Now as with all blocking, we caution you against using
this without some careful thought because any sort
of blocking can ultimately involve, you know, chains of
things blocking against one another and thus deadlocks.
If you want, another thing we've added to NSOperation
is if you want to have some block of code run
when the operation finishes, we've added a convenience for
that, a new property where you can set a completion block
and after the operation goes into its
finished state, this block will be executed.
So that can be a convenient way to say do some final
work for the operation or to start new operations
as a result of this operation having been finished.
We've also added a new subclass of
NSOperation called NSBlockOperation.
Just like NSInvocationOperation class takes an
NSInvocation to execute as the work of the block
and NSBlockOperation takes one or more blocks to execute.
And those blocks become the work of the
operation, when those blocks are all done
after the operation has been started, when they're all
done then the operation goes into its finished state.
So this is a convenience method to
create a block operation with a block
but you can also add many blocks
to an operation, a block operation.
If you add many blocks, all those blocks are going
to be executed concurrently and so this is a way
to have an operation do a kind of little
fan-out of work across multiple cores
by executing multiple blocks simultaneously.
When all of those blocks have finished, then the
operation as I say will go into its finished state.
NSOperationQueue in iOS 4 has been re-implemented
in terms of grand central dispatch or GCD.
Now I, unfortunately, I don't have time to go into
GCD today but there will be another talk tomorrow
on grand central dispatch if you're curious about that.
Two new methods that we've added to NSOperationQueue
are operationCounts and addOperations:waitUntilFinished.
What we've found for the first one that a lot of people were
asking an operation queue for its list of all its operations
and then just asking that array for its count, to
get the count of operations in an operation queue.
And then they were throwing, of course the array away
so rather than do all that work to create the array
of operations, we provide direct access to
that piece of information now via a new method.
The second method there allows you to add, do a sort
of bulk add of many operations at once and if you wish,
you can pass in yes to the waitUntilFinished argument
and this method will wait until all those specific,
those specific operations that you added have finished.
Because, you know, we've added a lot of block API, of
course, we felt that we should offer a convenience method
to add a block to an operation queue so you
don't have to create an NSOperation object
and so we offer a new convenience
method, addOperationWithBlock.
And it takes a block, if the block doesn't take
any parameters, it doesn't have any return value.
It's just a chunk of code to be run and eventually that
will, you know, percolate through the operation queue
and be executed by the operation
queue on some thread rather.
We also added two new special queues to the system.
The first is we've added a method
to return the current queue.
Well, the current queue isn't any particular special
queue but when code is running within the context
of an NSOperation, that is an NSOperation is calling
some code, well, that NSOperation has a queue.
And so, this method, currentQueue will return non nil.
It will return that queue that the code is running in when
that code is running in the context of an operation queue.
Of course, you might have a method which
can be called outside of an NSOperation
and then this method might return nil because
it's not running in the context of an operation.
But this can be a useful way to get a hold
of the current queue if you, you know,
need to do some more work with the current queue.
The second new method is mainQueue.
The mainQueue does represent a special queue.
It's a special queue that only executes
its operations on the main thread.
Of course, because there's only one thread involved,
that is the main thread, this is a serial queue.
And so you can use the mainQueue method to get a hold of a
queue which will execute its operations on the main thread.
So this is a way, a new way to execute
stuff on the main thread if you need to.
Well, one place you sometimes need to execute code
on the main thread is in response to notifications
and so what we have here is a new method
that allows you to pass in a block
as the observer essentially of a notification.
So in the last argument position there, we have the block.
The block just gets the NSNotification object
and essentially what you do is you're asking the
system add an observer to the notification center
for me using this block and the system will do that.
The system then returns that observer in effect in the
return value, that is the return value being id here.
This is the observer essentially that the system
has wrapped the block with and is returning to you.
So the return value in this case is retained by the
system so as long as you don't remove this observer
from the notification center, the block will receive the
notifications, the notification name that you've asked for.
To remove or stop the block from getting called, you need
to use the removeObserver method with that return value
as the parameter to removeObserver in order
to unregister, that's cancel the registration.
The third interesting thing about this new
method is that strange queue parameter.
So you can pass in nil to this parameter
and nothing different will happen
from the existing addObserver method
that you might already be familiar with.
But if you do pass in non nil, that is you pass in a
valid NSOperationQueue, what will happen is that when it,
when that notification is posted, your block
that you've passed in here will be executed
on that queue, or in the context of that queue.
Essentially what will happen is the
NSNotificationCenter implementation will say oh,
you know, this block needs to be invoked.
This notification is being posted and
here's a block that needs to be invoked.
Well, the block will simply be thrown on the queue by the
NSNotificationCenter implementation and then the block,
or the notification center will continue
looking for more observers to notify.
So what happens is that queue arguments open up the
possibility for asynchronous handling of the notifications
or also concurrent handling of notifications, that is if
there are many different observers registered with a block,
they might all end up having their block run
simultaneously on different threads, you know,
to do their handling of the notification.
But posting, that is the, there is a
thread which is posting a notification
and of course the observers have
to receive the notification.
The posting thread is still blocks in the posting operation
until all the observers have completed
their handling of the notification.
So even though the block here is being en-queued off on
a queue and eventually will percolate through the queue
and then ultimately get run by the queue,
hopefully that happens quickly but not necessarily.
The posting operation still has to block waiting for
all of the observers to have handled the notification,
to have seen it before the posting can
continue and return control to you.
Other changes that have occurred in
Foundation, well, in NSDateFormatter,
we've added two new bits of long-requested functionality.
The first is that given a set of components
that you want a format string for,
we now have a new API that will return you an
appropriate format string given those components.
So currently, we offer these different styles, you know,
short, medium, long, and full styles for formatting dates.
But sometimes you have a specific set of components
which you want to appear in your format strings,
in your formatted dates, but you don't of course
want to depend on the short format always, you know,
say providing those specific components that
you wanted, or the medium format.
Those things can change over time.
Instead, if you have say in this example, I want to
display the month and the day and the hour and the minute.
So I specified the format specifiers
Mdjm and of course, you may say j,
well that's not an hour specifier if
you're familiar with NSDateFormatter.
J is a special character that says well, I want the hour in
there but I don't know whether I want 24-hour or 12-hour.
Just give me whatever is appropriate for the locale.
So j is a special character for this particular method.
So having asked for, now my locale is U.S. English when I
run things on my computer so what I get is a date format
which is the U.S. English form that is the one
that contains month and days, hours and minutes.
You notice at the end that there's an a.
The a is the AM/PM designator and it
gave me the 12-hour h-format specifier.
So even though I didn't ask for the AM/PM designator,
the method is smart enough to add it in there
because it knows it should go with
the 12-hour hour format specifier.
Well, once you have one of these format strings, typically
you turn around and you set it in a date formatter in order
to format your date so in this case, I've set it in
the date formatter and I'm going to call stringFromDate
with the current time and if I'm on schedule for this
talk, the current time is around 11:02 AM on June 8.
The other interesting bit of functionality we've added to
NSDateFormatter is yesterday, today and tomorrow formatting
of the date so rather than say, you know,
always saying 6/8 is the date, which is today,
the text today for, you know, U.S. English would appear.
Of course, if your user is running in, say Japanese
locale or Thai locale or what have you, you know,
of course the appropriate thing
for that locale would appear.
So if you have say dates which
are appearing like this normally,
instead if you turn on the doesRelativeDateFormatting
property, what you'd get would be something like this.
And of course, don't assume that a locale
has three special dates that is today
and then the day before and then the day after today.
Some locales actually have special formatting for today
plus or minus two days or plus or minus three days
so it's not always just today plus or minus
one day where special formatting might occur.
Finally, we have a new class called NSCache in Foundation
and this is a class to help you with caching of objects.
Now sometimes you have some expensive objects, objects that
were expensive to create and you want to keep them around
but you don't want to induce so much memory pressure
that you're app is going to be jettisoned for example.
So NSCache will discard automatically some of the older
or least recently used objects if there's memory pressure.
So while an NSCache is like an NSDictionary in that you put
objects in it with said object for key and you get objects
out by using the objectForKey method and the objects
are still retained just like in an NSDictionary,
if there's memory pressure, the objects
may disappear from the cache automatically.
The other interesting thing about NSCache is that NSCache
is naturally thread-safe and so you can access them
on multiple threads safely, simultaneously.
Well, that brings me to my conclusion.
So I talked a bit about blocks.
I've introduced blocks and then a bunch of
other of the new Foundation API changes.
Now, I didn't, I wasn't able to go into a lot of the more
interesting things about blocks within this short time.
For example, I didn't talk at all about
block life cycle, where blocks live in memory
and how you hold on to them and how you destroy blocks.
So you have to go to the documentation to get more
information on those things or there's also some links,
if you want to find out more about some of
the other API changes that have occurred.
There are some links for this particular session
in the session database, some bits of, you know,
information like the complete API dif have been linked in
there, if you go to say the developer.apple.com website
and look at the information for this particular session.
So there are some related sessions which
are interesting and I want to point out.
Now, at 9:00 AM this morning, there was a What's
New in Cocoa session over in Mission here.
If you missed that, you may want
to catch the repeat of that.
This particularly focuses on Cocoa Touch and
what's new in Cocoa Touch on iPhone OS, iOS 4.
I've already mentioned the Advanced
Text Handling talk later today at 4:30.
If you want to know more about
Objective-C or delve more into Objective-C,
there's an Objective-C talk in
Pacific Heights tomorrow at 9:00 AM.
If you want to know more about blocks or grand
central dispatch, there's an Introducing Blocks
and Grand Central Dispatch on iPhone talk
tomorrow at 11:30 AM in Russian Hill.
Now, because this of course is a new, is a major update
to Foundation, you might find yourself being burned
by assumptions you made about how Foundation APIs behave
and so if you do find yourself having been burned,
one talk you may want to go to,
to maybe find out some more things
about how it can be a little bit more perhaps
robust is the Future Proofing Your Application talk
on Thursday at 2:00 in Pacific Heights.
Finally, there's a related talk which will talk about
some of the API decisions and some of the naming patterns
that we've used in Foundation called API Design for Cocoa
and Cocoa Touch and that's in Marina on Thursday at 4:30 PM.
And that talk may give you some insight into, you know,
why we have adopted some of the kind of conventions
and what the conventions are that we've
adopted in creating these Foundation APIs.