WWDC2013 Session 306

Transcript

X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
[ Silence ]
>> Dave Van Tassell:
OK, good morning.
Welcome to iTunes Connect,
What's New in iTunes
Connect [applause].
I'm Dave Van Tassell,
Engineering Manager,
iTunes Connect.
Let's get started.
This year, we are excited to
go over three new features
that are some of the more
highly requested features
from you for us.
First one is enhanced score
and leaderboard management.
Second, app transfer.
[Cheering and applause] Yes.
Third, enhanced command
line automation.
And then at the end
we want to go
over some App Review
dos and don'ts.
OK, score management,
what is this?
Well, let's look at some high
scores from different games.
Angry Birds Star Wars
let's take a look here.
We can see the highest
score for their total game.
That's a good score.
What about Harry Potter.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Let's see here, this is the
number of studs collected,
and Hogwarts has
never looked so clean.
Now, we have Scrabble.
This is the most wins, and
you must really love your iPad
to play that many games.
So, what do all these
scores have in common?
This is a big number.
I got to be honest, I didn't
know exactly what it is
in English.
I had to look it
up 9 quintillion.
Most of you in this room should
be thinking to yourselves,
I've seen that number, I
know what that number is,
it looks familiar, Max
Int, something like that.
So these high scores,
are they high scores?
Or, are they unearned scores?
I think people have
been cheating.
So, how do we prevent this?
Well, at iTunes Connect,
we have score range.
You can enter in a
min and a max score,
and if any score is posted
outside of that range,
then we don't post it to the
Game Center leaderboards.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
New this year is score signing
to help make those
scores more safe.
And, there was some information,
there was a Game Center
session yesterday,
and there's another one today to
talk more about those features
and enhancements we've
made with both of them.
But that's great.
How do we fix these
existing scores?
Well, that's what leaderboard
score management is all about.
Exactly what it is, you
log into iTunes Connect,
and you click on a leaderboard.
Once you do that, you
want to manage the scores.
You'll be presented with the top
100 scores for that leaderboard.
You can choose at that point to
either delete the invalid score,
or you can block a user and
all their invalid scores.
So, let's focus on
deleting a score right now.
What this does, it just removes
the score from the leaderboard.
And the user is able
to play the game again
and post another score,
and hopefully this
time a real score,
and it will show
up on Game Center.
No other leaderboards
are affected by this.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Blocking a user.
This will remove the score
not only from that leaderboard
but all leaderboards
on your app.
Not only is the score deleted,
but the user is then blocked
from posting any new
scores for that leaderboard
and all the leaderboards
on your app.
If your app happens
to be grouped,
then the same thing applies
to all the leaderboards
in that group.
The scores are wiped from all
the leaderboards in that group,
and they are blocked from
posting any new scores
to those leaderboards.
So, that's leaderboard
score management.
You can delete unearned scores,
you can block the cheaters.
It's a great way to
offer customer service
to your customers, and it will
be available later this year.
But I'm going to remind you,
with great power comes
great responsibility.
And, I think you know
where I'm going with this.
These are your customers;
they're our customers.
Let's treat them fairly and
with the respect they're due.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So that's score management.
Let's talk a little
about leaderboard
management, leaderboard sets.
If you attended yesterday's
Game Center session or played
around a little on
iTunes Connect this week,
you've seen leaderboard sets.
And what this is, is a way to
collect similar leaderboards
and give them a common
name, a shared icon.
It gives you better
leaderboard navigation.
We're also giving
you the ability
to have a display
name localization,
so each leaderboard can have
a custom name in these sets.
And the great thing
about leaderboard
sets is you're allowed
to have 500 leaderboards
per app.
So, we talked about
leaderboards today.
So, we have our Touch Fighter
2 game with four leaderboards.
They kind of just flow
down in front of the user
when they go to Game Center.
Level 1 High Score,
Level 1 Fastest Time.
Level 2 High Score,
Level 2 Fastest Time.
What we want to do now is create
a couple of sets for them.
So, we'll take those first
two Level 1 leaderboards
and create a set called Level 1.
Take the second two
leaderboards of Level 2,
and there they go
into Level 2 set.
Talk about display
name localization.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Again, we have these
four leaderboards.
We create our set.
Level 1 High Score can rename
to just High Score in this set.
Level 1 Fastest Time
is just Fastest Time,
similar to the Level 2 set.
Take their High Score and
Fastest Time leaderboards
and then you get
the display name
of High Score and Fastest Time.
And if we introduced a third
set where you mix and match,
we can change that Level 1 High
Score now has a display name
of just Level 1.
Level 2 High Score,
display name of Level 2.
Again, leaderboard
sets: The great thing
about it is 500 leaderboards
per game, and you can mix it --
you can put your leaderboards
in as many sets as you want.
However, once you do put
your leaderboards into a set,
then all of your leaderboards
in your app will
need to be in a set.
There's no mixing and matching.
This works for both grouped
and non-grouped games.
You add your localization
in iTunes Connect,
and it is available
in sandbox mode today.
With that, I'd like
to turn the time
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
over to Daniel Miao
[phonetic] to give us a demo
of this feature in
iTunes Connect.
>> Daniel Miao: My
name is Daniel.
I'm an engineer on
iTunes Connect.
And, now that you've heard about
some of the new features we have
in iTunes Connect,
let's take a closer look
at leaderboard sets
and score management.
So, here we have the
Touch Fighter 2 app page.
We're going to go into the
Manage Game Center Flow.
And many of you will recognize
this page as where you go to set
up your leaderboards
and achievements.
Now, you'll notice we
have two new buttons here.
Move All Leaderboards into Sets
and Manage Scores and Players.
For the purposes of this demo,
we have four leaderboards
set up.
We have two Level 1 leaderboards
and two Level 2 leaderboards.
We're going to go ahead and add
these into two leaderboard sets,
one for Level 1,
and one for Level 2.
So, in order to start
this process,
we're going to click
Move All Leaderboards
into Sets, right here.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And this page is asking us what
we'd like to call our first set.
So, let's go ahead
and call that Level 1.
Then we'll give it an ID of
Touch Fighter Set Level 1.
Click Continue.
And here on this page, we'll see
that so far we have
one set created,
and we're currently
editing it, the Level 1 set.
And we'll go ahead and add
a leaderboard to this set.
So we'll click Add
to Display Set.
We'll choose a leaderboard.
In this case, we'll
choose Level 1 High Score
and give it an English
display name.
We'll just call it High Score.
Now, as Dave had mentioned,
display names designate what
we'd like this leaderboard
to show up as, inside
of this set.
So, in a Level 1 set, the Level
1 High Score leaderboard will
show up as just High Score,
so Level 1 High Score.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So hit Save and save this
leaderboard to this set.
Then we'll go ahead and
add our second leaderboard.
We'll choose Level
1 Fastest Time,
add an English display
name again.
We'll just call this
one Fastest Time.
Now we'll add a localization
for this set.
We'll choose English.
And we'll just call this
one Level 1 in English.
And there's also an optional
image that you can add
to these leaderboard sets.
We'll hit Save to save
this localization.
And now we're finished
setting up our Level 1 set.
So, let's add our Level 2 set.
Click Add Display Set.
Call this one Level 2.
Give an ID.
Hit Save to create it.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And we'll see up here that
now we have both Level 1
and Level 2, and as you create
more sets, they'll be listed
out here and you can switch
between them to edit them
at any time during this process.
So, on our Level 2 leaderboards
now, we'll click Add
to Display Set, and the first
thing you'll notice here is
that now we have two sections
now; one for leaderboards not
in a set, and one for
leaderboards in a set.
As Dave had mentioned earlier,
if you're moving leaderboards
into sets, all your
leaderboards have to be moved.
You can't have some
leaderboards in a set
and some leaderboards
not in a set.
So, this helps us to track
which leaderboards we have
yet to move before we can finish
this initial migration process.
So here we'll move our
Level 2 High Score.
Add an English display
name again.
Call it High Score.
And then we'll add our
second Level 2 leaderboard.
Choose an English display name.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Call it Fastest Time.
And now all our leaderboards
have been added to sets.
Now, we'll add a language.
In English, we'll
call this Level 2.
And now we're finished.
We've added all our
leaderboards into sets,
and we have our two sets
with four leaderboards.
So hit "Save" in order
to complete this process.
And we'll see that
we have our two sets,
and we still have the
four leaderboards below.
And if we want to preview which
leaderboards are in which sets,
we click View Leaderboards
in Display Sets, right here.
And we'll see here that we
have two Level 2 leaderboards
in a Level 2 set, and two Level
1 leaderboards in a Level 1 set.
And of course you can put
each leaderboard into more
than one set as you go on.
So those are leaderboard sets.
So we're going to go
ahead and take a look
at To Manage Scores
and Players now.
In order to do that, we
click this button right here.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And this brings up a list
of our live leaderboards.
From here, let's say we want
to take a look at the scores
in Level 1 High Score.
Click Manage.
And we have five
scores posted so far.
Now, this first player,
we'll notice,
has a score of course
that's way too high
to be achievable in this game.
And not only is it
on this leaderboard,
but we've seen this player post
it across all our leaderboards,
and even on other
games that we publish.
So what we'd like to do is --
obviously, there's an
abuse of the system here,
so we'd like to block
this player
and clear all of his scores.
So, in order to do that, we
click Block, we confirm that,
and now his score is gone
from this leaderboard
and all the leaderboards
in our game,
and he can no longer
post any scores
to the leaderboards
in this game.
Now, the second player,
who's now in the first spot,
also has a score
that's too high,
but this one's not his fault.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
This one's due to the
fact that we had a bug
in our game a few versions ago
that was having trouble
calculating scores properly and,
you know, a few of the scores
slipped through and ended
up being posted to
the leaderboards.
So we'd like to clean
this one up.
So what we'll do here is
we'll just click Remove
and remove that one.
And that specifically
removes that score
from this leaderboard, but this
player can continue posting
and playing this game as usual.
And now we have a clean
leaderboard with fair scores,
and our players are happy
because now they can compete
on the same playing field.
And that's score management.
So, we hope that you enjoy these
new features, and I'm going
to hand it back to Dave.
And thank you.
>> Dave Van Tassell:
OK, thank you, Daniel.
So that was score and
leaderboard management.
Next, let's move
on to App Transfer.
So this is a story
many of you know.
You create your app.
It's on the App Store.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
It's doing very well and now
you -- somebody wants to buy it.
So, how do you do that?
Well, we thought this
was a good idea as well,
so here's our blue button
from iTunes Connect.
What we did is we
managed to just push them
down a little bit, leaving
a little bit of space,
and then we put Transfer App.
But what does this actually do?
Basically, App Transfer
changes ownership
from one developer to another.
It's fairly -- it's
transparent for your user.
In fact, the customer
reviews and the ratings,
they actually go
with the ownership
of the app to the new owner.
The App Store has
very minimal changes.
That developer name in that
upper left-hand corner,
hat will change,
as well as the URL,
support privacy marketing URLs.
In Game Center, if you are
using cross-app compatibility,
then we will move that
compatibility with other apps
as part of the transfer.
And if your app is grouped, then
it will be ungrouped and put
in with the new owner as
a stand-alone game again.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
The app ID is also transferred.
And even though the app itself
transfers from one developer
to another, that 10-character
prefix, which is the team ID
of the original owner,
transfers with the app ID
into your member center.
So, let's take a
look at the flow.
You're the current owner.
You log into iTunes Connect.
You're going to give
us some new information
about who the new owner
is so that we know
who to transfer the app to.
At this point, you need
to sign a contract,
and this is a good time to tell
you that it will be need --
it will need to be the
team agent who does this,
as they will have the
rights to sign contracts.
Once they do this, our app
is pending app transfer,
and the new owner will receive
an email letting him know this
transfer process has started.
They too log into
iTunes Connect.
They enter in the required
metadata to be able
to transfer the app,
those URLs and so forth
that we were talking about.
And, again, this same person
needs to be a team agent,
as they will need to sign an app
transfer contract on their end.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Once they do that, we begin
to process the app transfer.
Once we transfer this app from
provider to the next provider,
off it goes to the new owner.
A couple of rules for
the current owner:
You need to make sure all of
your contracts are up-to-date.
We've just released new
contracts this week;
I encourage you to go sign them
for this and for every reason
to get your apps on the store.
You do need to have
approved app version.
If your app has never been
approved, is not on the store,
there's no reason to go
through App Transfer.
And also, if you have any
updates that are in review,
get them through the
review queue before you try
to transfer the app.
Same thing for In-App purchases;
if you have any In-App purchases
that are currently in
review, they need to be
through the review queue
before you transfer the app.
What you need to bring.
Like I said, you
need the Apple ID
of the recipient's team agent.
And you'll also need
the recipient's team ID,
which is that unique
ID that everybody has,
and you can find it
in the Member Center.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Once you transfer the
app, it will no longer be
in iTunes Connect, so any app
history that you want to get,
you need to download that
before you transfer the app.
If you want a new catalog
report with that information,
do that before you
transfer the app.
The source code and
binary is not handled
through the app transfer
process;
you need to make
special arrangements
between the two developers
on how to do that.
Once the app transfer is
begun, you are allowed
to change the price of
your app, you're allowed
to change the price of
in-app purchases; however,
the rest of the metadata
is locked down.
And you have 60 days to
complete the transfer.
Either the new owner or the
current owner can cancel it
at this time; however, after
60 days, if it hasn't finished,
then you'll have to
start all over again.
For the new owner,
what's their checklist?
We need that new app metadata.
We also need to know who to
contact if we have questions
about the app: Name,
phone number, email,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
those fields you see
in iTunes Connect.
If your app uses encryption
and export compliance
documentation is required,
you will need to have that
before you can sign the contract
that transfers the app.
At this point, once you've
signed your contract,
App Transfer has begun, it's
processing App Transfer,
the pricing is locked down,
and it cannot be canceled.
The app will begin to move
from the current owner
over to the new owner,
and then it shows
up in the new owner's
iTunes Connect.
You have a few steps to take.
If you are the new owner, once
this app has been transferred,
there's a couple things to do.
If the app makes use of Apple
Push Notification Service,
then you'll need to log
into your Member Center
and provision the newly
transferred app ID
for the service.
Also, if the app uses
Keychain, you need to discuss
with the previous owner
how they did that,
as when you update the app with
a new version, it won't be able
to access that same data.
That is App Transfer.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
It's available today,
and we're very excited
to see how you use it.
[applause] Dave: With that,
I'm going to turn the time
over to Nick Oogloff
[phonetic] to talk
about our automation
enhancements.
>> Nik: I'm Nik Uglov,
Engineering Manager,
iTunes Store, Content
Management.
As Dave said, I'm going to talk
about command line
automation with Transporter.
Well, what is it?
What's in it for you?
Why should you care?
With command line
automation with Transporter,
you will be able to address your
most repetitive interactions
with iTunes Connect
without having
to go through the web GUI.
You will be able to
manage your data in bulk,
and you can integrate
that management --
you can integrate
iTunes Connect --
with your backend content
management systems,
whatever those may be.
Ultimately, it's
about being efficient
in publishing your
app on the store.
And the time savings that you
gain, you'll be able to reinvest
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
into making your
apps even better.
So, I'm going to introduce
a command line tool called
Transporter, which
manages the interaction
between your environment
and iTunes Connect.
And it does that by using
an app metadata XML feed.
The feed covers the areas of
version level localization,
rights and pricing for your
app, the in-app purchases
and Game Center achievements
and leaderboards.
Through Transporter, you can
also get your catalog reports
on a command line.
So, let's start by reviewing
how you currently edit this data
in iTunes Connect.
This is the screen that
you usually go to for this,
and there are seven fields
to fill in, and there are
up to five screenshots
per device type
that you support to supply.
It certainly pays to
supply multiple screenshots
to show your app in the
most advantageous light.
Also, the stores available
in up to 28 languages,
so in order to appeal
most effectively
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to your customers worldwide, it
pays to provide that information
in the language that
they can understand.
So, there are up to 28
screens like that to fill in.
And a lot of you have
multiple apps to maintain,
which is wonderful, but
it increases your burden
in providing all that data.
The GUI as it stands is
fine for a few items.
In fact, that's the most
efficient way to fill
in this information if all
you are doing is changing a
description here and
there, adding a screenshot.
But as you scale up to multiple
localizations and multiple apps,
this gets burdensome, and
it could be error-prone,
because you're probably
copying this data --
copy-pasting it from some
document somebody put together.
You probably don't know
all of the 28 languages.
Some of you maybe do,
but probably not all.
So, you could make a
mistake in this copy-paste.
And ultimately, you can't
automate this process,
because you can't script
the Web GUI effectively.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
You've been telling us about
it; you've been filing a lot
of bug reports, and we
certainly read them.
In fact, last year, we
introduced an XML feed
that covers a portion
of that interaction.
It covers the areas
of In-App purchases,
Game Center leaderboards,
and Game Center achievements.
Well, today, today
we're introducing --
we're building on top
of that foundation
and introducing support for
version-level localization
in a version section,
pricing and availability,
and in the in-app purchase
area, we're also allowing you
to upload the hosted content
packages that you can produce
with Xcode, through the feed.
Let's review the features.
What's available there?
Well, first and foremost
there is Transporter,
which is a command-line tool
for managing this interaction.
And the first thing you
do with it is you look
up the current state, the
current metadata for your app.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
When you do that, it gets
downloaded as a package,
which is really just a fancy
name for a directory named
after the app's SKU
with a .itmsp extension.
You crack it open -- crack
that directory open --
and what you find in there is
a file called metadata.xml,
and that encapsulates
current state of your data
in iTunes Connect,
the data for your app.
This is the file
that you need to edit
to make changes to your app.
You edit it to your heart's
content, and then any assets
that need to go with it, let's
say screenshots, you park them
in the same directory, right
next to that metadata.xml.
You build up the
package this way,
and then you can validate it.
Validation, as a
separate action,
is optional because you could
just go ahead and upload it,
and the validation will also
be performed when you do that.
This is the lifecycle, the flow
overall: download the package;
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
modify XML; add screenshots and
other assets; do the validation,
either by itself or as
a part of the upload;
if there are any errors, you
address them by editing XML
and changing the
assets as needed;
and ultimately you
upload the package.
It gets to iTunes Connect,
and you have your data there.
Here's the first
command you need to know:
Transporter with a
method "lookup metadata".
You provide your iTunes Connect
username and the vendor ID
for your app, which
is your app's SKU.
That's the same thing:
App's SKU is the vendor ID.
You provide the local
destination folder where you'd
like the package to end
up, and what happens,
it gets downloaded
locally as a package named
after the app's SKU
with a .itmsp extension.
And the reason you want
to go with this first,
the reason to do the
lookup and not the upload is
so that you wouldn't have to
come up with this big XML file
with everything about your
app in there, from scratch.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
You could use this as a skeleton
to bootstrap your automation.
It's a lot easier this way.
Next up is validation
with Transporter.
Use the "verify" method, supply
your iTunes Connect username
and the name of the package
that you're validating.
What happens then is we validate
both the metadata and the assets
that you're providing,
and we validate them using the
same rules that are applied
in iTunes Connect,
same conditions.
If there are any errors
during that process,
you get them reported to
you on a command line.
Here's an example.
"No software found with
vendor ID 'bogus'."
Well, not surprising, given
the vendor ID I chose.
What is it that we validate?
Well, quite a lot; there's
a lot of validations.
I wouldn't be able to go through
all of them here in the session,
but you can take a look in the
documentation, which I'll point
out to you in a few minutes.
But to kind of give
you a flavor:
you have to identify your
app properly by the SKU;
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
the version needs to be
in an editable state --
if it's currently in
review, you can't modify it,
same goes for in-app
purchases; the screenshots need
to be appropriate dimensions --
the same ones that
iTunes Connect requires.
Next up, Transporter
"upload" method.
That's the one that actually
sends the data to us.
You supply your iTunes Connect
user ID, supply the name
of the package to upload.
What happens here is the same
validation is performed that's
in the verification step,
and the same, ultimately,
rules as in iTunes Connect.
If there are any
errors, they are reported
to you on the command line.
If everything went fine,
what happens is the
package gets uploaded to us,
and it enters an asynchronous
processing queue that's shared
between all the content
that we process.
That would be music, movies,
and books, and other software.
You could expect there
to be a few minutes
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of delay before your data
is actually reflected
in iTunes Connect.
There is actually another
mode in Transporter
that would let you
look up the status
of your most recent
upload; you can take a look
at that in documentation.
A few other details
before I move on.
The app and the version need to
already exist in iTunes Connect.
You set them up in iTunes
Connect as you do now,
sort of in a skeletal
shape, if you will,
and then you can use the
feed to populate them
with all the rich information.
All the state transitions are
managed in iTunes Connect:
let's say if you're
moving the app to ready
to upload the binary,
or submitting the in-app
purchases for a review.
When you're ready to upload
that binary, you still do
that with Xcode or Application
Loader, no changes there.
And the feed is available
for both iOS apps
and Mac apps equally.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
I mentioned documentation
a little earlier.
This is where you'll find
it: on iTunes Connect
in Manage Your Apps
screen on the bottom.
There are two pieces of
information you need:
the Transporter User Guide,
which lists all the commands
I'm going to go through today
in a lot more detail,
and there's more of them.
And the App Metadata XML
specification, which that's
where all of the tags are listed
with all the requirements
that apply to them.
This was a general introduction
to Transporter and an overview
of the app metadata XML feed.
Well, what does the XML
feed actually look like?
What do you see there?
It looks something like this.
You have the required
elements that kind
of wrap everything else.
And what you have there is you
have a package for your account,
which is identified by team ID.
The package contains software.
The software is for the specific
app, identified by vendor ID,
which is the app's SKU.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And within it the metadata.
Those are required elements.
The rest of the stuff here,
the rest of the sections,
are optional.
Well, what exactly
do I mean by that?
What I mean is that if
you're not making changes
to some component there,
you could omit that.
If you're not making
changes in Game Center,
you can omit the entire section.
Not making changes In-App
purchases, omit that.
I don't mean that
you must omit it.
If you just did a metadata
lookup, made a few changes,
you could just re-upload
the package as-is,
and if there are no changes
in certain sections, well,
no changes will occur
in iTunes Connect.
All I'm saying is it's
optional to include the sections
that don't have any changes.
Let's dive in.
First thing in the package is
you need to specify your account
by team ID, which is a value
that's been provided previously
to you by Apple.
And in the software section,
you have to identify,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
well, what app is it for?
And that's done by
the vendor ID,
which is the same
as the app's SKU.
That's exactly the same value.
Diving in, into the
software metadata section,
what you'll find there is
the versions for your app.
And just like in iTunes Connect,
there are up two versions
that you can address.
The current one; in this example
1.5, identified in the feed
as version string 1.5.
And if you have a new one
that you're building up,
getting ready, then
that's available as well,
version 2.0 in this example,
with version string 2.0.
Diving into the version element,
you'll finally see the locales,
which are all the
localizations for your app.
In iTunes Connect, you do
that by using this pull-down
to identify the language:
English,
U.S. English to be precise here.
In the feed, that's
locale element
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
with the language
identified by name en-US,
and that's a BCP
47 language tag.
BCP 47 is a very wide format
for referring to a language.
You can refer to any language
spoken on this planet this way.
But the store is only
available in 28 languages,
so to see the list of the ones
that are actually valid here,
please take a look
at the documentation.
Let's dive in further
down into the locale,
and what you see there is
finally these fields addressed
that you normally edit
in iTunes Connect.
"Name" is the title.
"Description" is
the description.
And "What's new in this version"
is "version what's new".
Keywords are comma
delimited in iTunes Connect;
in the feed they're
separate elements.
And URLs: three of
them in iTunes Connect;
three of them in the feed.
Screenshots.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Well, screenshots are just
a bit more complicated
because you have to refer to
both the type of the device
that the screenshot is
for and its position
in iTunes Connect and,
ultimately, in the store.
Positions go 1 through 5 because
there's up to five per device.
For 4-inch iPhone, I have
display target iOS 4-inch
in Position 1; and,
for example for iPad,
here it is - iOS
iPad Position 1.
Postions go 1 through 5.
Well, there's one
more thing to note
in the software screenshot
section, with regards
to the requirements
for the elements.
I said earlier that you
could omit the sections
that you're not making
any changes to.
And that's true.
You can omit the entire
software screenshot section
if there are no changes in it.
However, if there are
changes in the section --
let's say you're
adding a screenshot,
you're moving them about,
or you're deleting one --
please supply the
entire section.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Here's why.
If you omit a screenshot
within the software screenshots
section, that's your signal
to us that we should remove it.
So please state the
entire section
if you make any changes
in there.
That doesn't mean that
you'll actually end
up uploading the screenshot
file over and over again,
and that's because for
each screenshot file,
you have to supply the
size in bytes, the filename
of course, and the checksum.
If the size and the
checksum match what we have
for this device type,
in this position,
Transporter will skip the upload
because we already have the
file; we don't need it again.
So, version level
localization tags.
Let's take a look at the rights
and pricing for your app.
In iTunes Connect, that's under
Rights and Pricing button.
And in the feed, that's
in the Products Section.
What you'll see there
corresponds to iTunes Connect,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
in that most of the settings are
applicable worldwide, globally.
So let's go through those first.
You identify the global
applicability of those settings
by using the Product element
for Territory Worldwide.
That's here.
Then what goes in there is
first the availability date
for your app, which is sales
start date; if you have discount
for education institutions,
that's under Allow
Volume Discount,
true or false, a Boolean value.
Also, on the global level,
you have the pricing
information for your app.
In iTunes Connect, that's
a pull-down for price tier;
in the feed, that's
wholesale price tier.
I have it as 3 in this example.
The tiers actually apply in
intervals that let you set
up sales windows ahead of time.
Here I have the interval
section,
and this interval starts
on the start date there;
same concept as in
iTunes Connect.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And the tier end
date is End Date.
What this corresponds to in
iTunes Connect is the ability
to set up the schedule
for the changes
of the prices ahead of time.
So, for example, I have an
app that's normally at Tier 3,
but for the duration of this
conference, it goes on sale
down to Tier 1, and
then comes back to 3
after the end of the conference.
Now you could do the same
in a feed, of course.
This is how.
In the Intervals element,
first interval goes
until June 10, at Price Tier 3.
Then it goes on sale for the
duration of the conference
down to Tier 1 and then
comes back up to Tier 3.
Notice no end date, which means
that this is the tier that's
effective in perpetuity,
until you decide to change it.
These are all the globally
applicable elements.
What could you do on
a per-territory basis?
Well, what you get
to do there is
to state whether your app is
available for sale there or not,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and there are two
ways to go about it:
by exclusion or by inclusion.
The exclusion principle
goes like this.
You start by saying that
your app is available
for sale everywhere: territory
WW; cleared for sale, true.
And then you enumerate
through the product sections,
stating the territories where
it should not be available.
So here's an example of
the app not being available
for sale in Japan.
If you go with the
exclusion principle
and Apple opens app stores
in additional territories,
your app will automatically go
on sale there; nothing you need
to do for that, because, well,
it's not excluded
from sale there.
The inclusion principle
is the exact opposite.
You start by saying that
your app is not available
for sale anywhere: cleared
for sale is false for WW.
And then you enumerate
the Product blocks,
stating which territories
the apps should be available
for sale in.
Here's the example of
the app being available
for sale in Japan only.
So, two ways of going about
that territory settings.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So, these were rights
and pricing for your app.
I'm going to briefly talk
over In-App purchases
and Game Center in the feed.
Briefly, because those
features have been available
since last year.
In-App purchases in
iTunes Connect are
under Manage In-App
Purchases button, of course,
and in the feed they are
under In-App Purchases
section, which is fairly deep.
There's a lot of detail in
there, please take a look
at that documentation
for what's available.
What we are adding here
today is the ability
to submit hosted content
packages that you can create
with Xcode, but now you can
submit them through the feed;
you would have had
to use Application Loader
for that previously.
To remind what that is, if
your In-App purchase happens
to be a non-consumable,
such as say a map or a level
for the game, and if
you would like Apple
to actually host the content
for it, you produce that package
in Xcode, and then you
can indicate in the feed
that you would like Apple
to host it and provide it
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
as an asset in the
package when you upload.
Game Center in the feed works
the same way it's been working
since last year.
In iTunes Connect, that's
under Manage Game Center.
In feed, that's Game Center
section with the subsections
of Achievements and
Leaderboards,
and each of those
is fairly deep.
Please take a look at
documentation for details.
These were the In-App purchases
and Game Center, and this kind
of wraps up the metadata
portion.
As I mentioned earlier,
Transporter could also
obtain catalog reports
for you on a command line.
If you haven't used
catalog reports,
these are tab-delimited,
downloadable reports
that give you a sweeping
overview of the data
that you have in iTunes
Connect for your apps,
the in-app purchases, or
recently added reports
for leaderboards
and achievements.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
You select which ones you want,
you click the Request New
Reports, and you'll get an email
when the report is
available for download.
You could do that
up to once a day.
Well, the same capability
is now present
through on a command line.
There are two modes;
for requesting reports
and for checking
on their status.
You would use the Request
Reports method in Transporter:
supply the iTunes Connect
username, the type of reports --
in this case, I'm
asking for all of them,
or you could specify
one of the four --
and then the location of
a local destination folder
where you'd like it.
And two things might happen.
If the reports are
already ready for download,
you would just get them right
away in the reports folder.
If they haven't been
asked for yet today,
you'll get a message saying
that they will be
made available soon,
and you'll get an
email when they are.
But you don't have to
wait for that email,
because you could
check on the status
of previously issued requests
through the list reports method,
and you get a status
output for each report type
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that you've requested.
So, these were catalog
reports through Transporter.
Well, now, now's your turn.
It's your turn because these
features are available now.
They're out there;
you can use them.
You have Transporter, which
manages the interaction
between your environment
and iTunes Connect.
You have app metadata XML feed
for version level localization,
rights and pricing for
your app, in-app purchases,
and Game Center, and you
can also get catalog reports
through Transporter.
What I'd like you to do today,
a little later, tomorrow,
is download documentation
that we have on iTunes Connect
on the Manage Your Apps screen.
You need two pieces
of information:
"Transporter User Guide," that
goes through all the commands
that we went through today --
and there's actually a lot more,
and certainly a lot
more options for them.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And the "App Metadata
Specification," which goes
into minute detail
for all the tags
and all the requirements
for them.
Armed with this information,
what you'd be able
to do is automate a lot
of your interactions
with iTunes Connect.
You will be able to bulk manage
data, and you can integrate
that management with your
backend content management
systems, whatever
shape they are in.
Even, let's say if you are
an individual developer
and you have one or
two apps in the store,
this is still applicable to
you because you could come
up with this package, you
could put it all together
and upload it in one
shot and be done.
But to get back to the
integration idea, how it shapes
up is really up to
you, because, well,
we don't know what those
content management systems
in your company are.
You know that; we don't.
They suit your flows;
they suit your processes.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
What we're providing is the
ability to integrate with them.
We're providing the tool,
Transporter, and the format,
metadata XML feed, and
the rest is up to you.
But we do have a demo of what
that interaction might look
like, and my colleague, Aravind,
will take you through it now.
Thank you!
>> Aravind: Thank you Nik.
Well, that was an incredible
amount of new information there.
And naturally, the questions
would be, what's next...
how do we get started...
more importantly, how do
we put this in practice.
Good morning, my
name is Aravind.
I'm an engineer in
the iTunes Store.
I'm here today to show you, how
you could keep your app metadata
in sync with iTunes Connect
using command line tools.
So, what we're going to do today
is, first invoke Transporter
with the lookupMetadata method,
which will get all the data
down to your local storage.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
We'll visualize it, make
changes, and when we're ready
to upload, we'll use the
upload method in Transporter
to upload it back
to iTunes Connect.
We'll see the changes
on iTunes Connect.
So let's get started.
Let's in fact start with
what we already know
and are familiar
with: iTunes Connect.
So here we have the iOS app.
It's got two versions.
There's one version
that is Ready for Sale
and another version that
we're preparing for upload.
Let's play today
with the version
that we're preparing for upload.
So we see that it's
got some basic data,
there's no localization, just
basic app default language.
It has a couple of screenshots.
Let's go back up to
Rights and Pricing.
We see that our app is on sale
at price tier 3 and it's only
on sale in the United States.
So, this is the data
that we have.
This is what we're
starting out with.
And this is what we want
to download before we can
start playing with it.
So, we'll invoke a script,
and because this is all meant
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to show case command line
ways of automating your stuff,
everything is scripted.
So, the first script I'm going
to run is, lookupMetadata.
You can see that it's a simple
shell script and it's going
to invoke a bunch of
other scripts and so on.
And the first thing it's going
to do is download the metadata.
We hit return and we see
that it is attempting
to invoke Transporter.
Let's quickly go
over the options
that we're passing
to Transporter.
The first parameter is the
"-m lookupMetadata" parameter
and it's basically
telling Transporter
to download the metadata.
Metadata for what?
If you look at the
parameter called "vendor-id",
that's your app SKU and that
basically tells Transporter
to lookup the metadata
for that particular app.
We pass in the username
and password.
Note that this is not the
actual username and password.
This is another automation
feature that tells Transporter
to lookup your actual
username and password
from environment
variables USERNAME
and PASSWORD, uppercase.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And finally, the "destination"
parameter tells Transporter
where to actually store the
data on your local storage.
You'll also notice
the "-v" parameter
that just tells Transporter
to log only critical messages.
So, I hit return, and,
Transporter does a bunch
of self-checks, and begins
downloading the data.
And it's done.
So, what Transporter did was
create a package directory
called itmsp with the
name of your app SKU
and our script now
takes over and wants
to open the XML document.
Let's hit return, and,
we open it in Xcode.
Now, this is a giant XML
document, and I don't want to go
through it in great detail.
It's not that useful
for human visualization.
But let me just point
out a couple of things.
The thing I wanted to show
you was the identifiers.
The team-id and the vendor-id.
Now, I point this out
because, when you do a lookup,
you get the metadata and these
identifiers are provided to you.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
When you're ready to
send the data back,
you have to provide these
two identifiers as well.
And then there's a whole
bunch of other data.
Now, as I said, this is XML
and it's not exactly
usable or human friendly.
So what we want to do is
transform this to a format
that we can actually
work with and use.
Now, this is where it
gets a little interesting.
For the purpose of this demo,
I've made a deliberate choice
to model this XML
as a series of flat,
simple command separated values.
When you are ready to
integrate iTunes Connect
with your Content
Management System,
you get to make your
choices of how you mode
and how you transform it.
So let's close our Xcode.
Go back to our script.
Our script is ready to transform
this XML to a CSV document.
I hit return, transformation
complete, and it wants
to open this CSV document.
Speaking of CSV documents,
the most obvious choice
for opening a CSV
document is ...
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Numbers. So, we hit return and
open the document in Numbers.
And... Boom!
Just the data, without all
that distracting XML tags.
Ok, so what are we
looking at here?
You can kind of make out
that there are four sections
or blocks of data,
labeled as Entities.
So, the first entity
type is locale.
It's got all the
basic app metadata,
across various versions,
across various localizations.
Currently, of course, as
we saw on iTunes Connect,
it only has English, US-English,
and that's what we see here.
The second section
deals with screenshots.
It's got all the screenshots
across all versions,
across all localizations,
across all device types.
And again, we saw on iTunes
Connect, we have just a couple
of screenshots for version 2.0.
The third and fourth sections,
deal with Pricing
and Availability.
As we saw on iTunes Connect, our
app is on sale at price tier 3,
and it's available only
in the United States.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So, this is the data we saw on
iTunes Connect, we were able
to successfully download
it here,
and we're able to visualize it.
We like the data...
let's change it.
Let's say we want to add a
couple of new localizations.
Let's say we want
to add app metadata
for Spanish and Russian.
We want to make the app
available for sale in Russia
and in Spain in addition
to the United States.
And while we're at it, we
want to make our app er,
put out app on sale at price
tier 1 for let's say a month.
Now, that's a lot of changes.
Now, I could make
all those edits here,
but we don't have the time.
Plus, I don't know
Spanish or Russian.
So, let me close this out.
I have somebody do all the hard
work of translating all this,
so I have another document,
that has all these edits.
Alright, so what are
we looking at here?
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
It's practically, the same
document we saw earlier.
The changes are highlighted
in bright eye-popping
yellow, so you don't miss it.
The ones I haven't
changed are greyed out.
So you can see that we have
some content for Spanish,
content for Russian,
all that nice,
happy looking Cyrillic
characters there...
we have a bunch of screenshots
for every device type,
so we have a whole bunch
of screenshots here.
We see that we're
making the app available
for sale in Spain and Russia.
And we also see the price
tier go down for a month to 1.
So, that's a lot of changes.
Let's upload it.
I go back but this time
use a different script.
This script is going to do
sort of like the mirror image
of what the previous script did.
It's going to take this flat,
comma separated values document,
transform it to XML and then
upload it to iTunes Connect.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
I invoke a script called
upload-metadata.sh.
So the first thing it's doing
is converting the CSV to XML.
Done. Hit enter.
Now, it wants to
invoke Transporter.
Now, these options, should
be familiar to you by now,
except the first option "-m".
This time, we're using
the "upload" method
that tells Transporter to take
your package and send it over.
Where is the package?
That's the "-f" parameter,
that says,
look for the itmsp package here,
and that's the content
that's going
to be sent to iTunes Connect.
I hit return, and the
upload process begins.
Transporter does its self
checks, sends the data over,
and it looks like we failed.
OK. Nik mentioned earlier
that we do all the validations
that you're familiar with
in iTunes Connect, here,
and this is an example.
Every single field validation
that you have and you love
on iTunes Connect is
done here as well.
And some more.
Because of the nature
of the interaction,
we do some additional
validations.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
In this case, it turns
out, version 2.0,
in the Russian localization,
there is something wrong
in the ordering of
the screenshots
for iOS 4 inch device.
The error message
is pretty clear,
so let's go to our original data
and see what's going on here.
I'm looking at the screenshots
section, version 2.0, iOS 4 inch
and here is my list
of positions.
And sure enough, we see that
it's not ordered correctly.
There's a typo, so
let me fix it.
There! That should fix it.
Save it. And let's
try this again.
Invoke upload-metadata.sh,
transform to XML,
invoke Transporter, hit return,
and let's see what we
end up with this time.
The same process happens.
The server does a
bunch of validations,
and if everything is good,
it should accept the upload.
And it turns out,
everything was good.
But we're not done yet.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
The upload is done, but,
what we've uploaded
needs to be processed.
The server takes a little
bit of time to do that.
So let's make use
of that time to look
at what exactly we sent over.
We notice that, that's the
directory we gave Transporter
to upload.
So let me "cd" to that directory
and see what's going on there.
We can see that there'a
metadata.xml.
That XML is essentially the
transformation of the flat,
giant spreadsheet from
before into an XML format.
And a bunch of screenshots.
Now, if you're wondering,
we had three localizations,
fifteen screenshots each,
so forty five screeshots,
but we only see fifteen
screenshots here,
this is a demo, so I'm
reusing the screenshots
across all localizations.
And, while we'e at it,
let's look the metadata.xml.
This is the outgoing
metadata.xml.
Notice that, the format is
almost exactly the same.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
We notice that we're sending the
team-id back, vendor-id back,
and pretty much all
the localizations.
Before we move on, let me
point out just one quick thing.
We made one Transporter
call, got everything down,
all that's relevant
for localizations,
and we made changes
to the format,
and another Transporter call and
uploaded the whole thing back.
Now that's automation at its
simplest and most efficient.
OK, so that was a
lot of changes...
but did it work?
Let's go back to iTunes
Connect, and check.
I'll do a refresh, I guess
it's still working on it.
(Refresh again).
There! We see the price tier
go down to tier 1 for a month,
and then back to tier 3.
Our app is on sale in Spain,
in Russia, and of course,
we didn't change anything for
the United States, so it's still
on sale in the United States.
Let's go back to localizations.
I'll cancel this.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Version 2.0, right!
In English, the only thing we
did was we added a whole bunch
of screenshots and those
screenshots are here.
Ok, how about the
other localizations?
Russian...
very good.
They're all here.
And Spanish....
and... they're all here.
So, that pretty much brings
us to the end of the demo.
What we did was, we downloaded
the metadata, we were able
to transform it to a form we
could visualize and play with,
store etc. and we
uploaded the metadata.
I hope this gave you some ideas
about how you can integrate
your Content Management Systems
with iTunes Connect.
Happy Integration,
and Thank you.
>> Dave Van Tassell:
OK, thank you Aravind.
That's a lot of information.
There will be a test when
you leave the room there.
People in red shirts
have it for you.
So there's our enhanced
command-line automation.
Every year, we like
to ask App Review
if they have any
suggestions for you.
A few dos and don'ts,
so let's go over those.
On the metadata side, if you're
providing a demo account,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
make sure it's full
access to the app.
Please list any hardware that's
required to review your app.
The screenshots and the
description: They have to be
about your app and need to
have the rights for any content
and keywords that
you put in your app.
For the app behavior itself,
high quality experience;
I think that speaks for itself.
Please test the app.
I know I shouldn't
have to say that.
After five years, we
are still reviewing apps
that crash and have bugs.
Appropriate usage of
both background mode
and iCloud storage
is very important,
as is if you are selling any
digital content or services,
in-app purchases
are the way to go.
For privacy, we value
our users' privacy.
Please don't ask
for any information,
unless it is relevant for
the app functionality.
And lastly, iPhone 5 support.
This is the number one reason
that apps upon upload move
into the invalid binary
section, invalid binary state.
It is a mistake with the
iPhone 5 launch image.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
There's a lot of
documentation information online
about how to do that correctly.
Please look it up.
And that is App Review
Dos and Don'ts.
Little bit more information.
Paul Marcos, our
evangelist, the documentation
as Nick showed you, is
all on iTunes Connect,
including the developer guide,
and the developer
forums are a great place
to find more information.
Related sessions.
As we mentioned, there was a
Game Center session yesterday.
There's an iAd Integration
session.
Both great sessions.
In summary, what
is available today?
Leaderboard sets
in sandbox mode.
App Transfer.
These new command-line
automation tools.
And coming later this year is
leaderboard score management.
That's it for today.
I hope you have a good
rest of the conference.
Thank you.
[ Applause ]