[ 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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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, 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.
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 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 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.
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.
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; 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.
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; 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 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.
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.
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, 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 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.
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.
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, 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.
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.
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, 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.
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 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.
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 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.
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.
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.
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.
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 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.
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.
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 ...
Numbers. So, we hit return and open the document in Numbers.
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.
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?
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.
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.
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.
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.
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.
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.
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?
They're all here.
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, 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.
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.
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.
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.
[ Applause ]