in Android Developer Tools. My name is Xavier Ducrohet.

>>> I think we have a few things to show. >>Xavier Ducrohet: Maybe. So Android Studio.

So when we released the first SDK in 2007, we released some tools with it and since then

we've done a lot of progress in and outside of the IDE based on Eclipse and we are going

to keep on doing that, but one thing that we could never really do is really improve

the whole workflow of being an Android developer inside the IDE, and we really wanted to improve

that. So when we wanted to concentrate on Android-focused

IDE, we decided to go with IntelliJ. IntelliJ is a great Java IDE, but it's also based on

a very extensible platform. It's the same platform that borrowed some of the other IDE

from JetBrains, like (indiscernible), Python IDE or Javascript IDE. And the extensibility

is really available throughout. Some of the core components like product support, build

support, the support that powers all of the refactoring, all the way up to the UI where

everything is customizable. >>Tor Norbye: And the build support, that

extensibility is the most important part given what we're going to show you.

>>Xavier Ducrohet: So this is going to allow us to create a lot of very advanced features

that we couldn't really do before, but also creates an experience that is really focused

for Android. And when we did something in the IntelliJ

platform that is not extensible we worked directly with JetBrains to make sure that

Web extension point so we don't fog that platform. We're just basing all IDE on their platform.

We're using everything that they're doing. In fact, we're actually building on top of

their existing Android support. So it had support for building, editing, debugging and

not just extending that. So in the past few months we've mostly worked

in our internal repository because we wanted that to be a surprise, and today we're moving

back to the open source project, so it's live now in AOSP and since we're doing that we

figured out we would also give you a preview. So today it went live, not too long ago. You

can go download Android Studio, it's version 0.1. It's a bit rough around the edges. The

IntelliJ part is mostly stable. >>Tor Norbye: There are some parts that are

rock solid and other parts that are not. >>Xavier Ducrohet: Yes, but we want to have

a lot of feedback. We want to make the best IDE possible. We're going to integrate very

quickly, fix bugs, add new features and gather feedback from you. So please try it and send

us feedback. Now, I realize that probably some of you,

you know, have never tried IntelliJ before and so we wanted to give you a quick overview

of IntelliJ before we show you some of the Android Studio specific features.

So I'm very happy to introduce on stage Dmitry Jemerov, the CTO of JetBrains to give you

an overview of IntelliJ. >>> Hello, everyone. So my name is Dmitry,

the CTO of JetBrains. I'm very excited to be here and thanks for the warm reception

during the keynote. And I'd like to tell a bit about our side of this story.

So we have been long watching the work that the tools team has been doing on the Android

tooling and we have been very impressed with the quality of that work so we are sure that

our Android plug-in is in good hands now. From our side we fully support that effort.

We provide the necessary extensions in the platform that the guys here need from us and

so it's all versed together very nicely. From our side we're also going to ship all

of that stuff as part of our release as part of IntelliJ Idea itself. And for those of

you not familiar with our products, we have actually two editions of the product. The

IntelliJ IDEA Community edition is the free and open source version which is what Android

Studio is based on. And we have IntelliJ IDEA Ultimate, the commercial edition of the IDE,

which also includes support for server side development, starting with CSS and JavaScript

and proceeding to the Java enterprise frameworks like Spring Hibernate, Java EE and stuff like

that, database support and so on. So if you're working on a pure Android project,

the Android Studio is the best tool of choice for you and if you have a project that has

a service side component or simply if you're working in a more distributed environment,

then you might want to look at IntelliJ IDEA Ultimate.

So now I'm going to give a quick demo of the features in IntelliJ. It's not going to be

Android specific so that will be Tor's part of the demo. I'll just start with a general

overview. So the motto of our company is "Develop with

Pleasure." And one of the key things from which pleasure comes during development is

not having to worry about routine tasks, so stuff happening -- as much stuff as possible

should happen automatically, should be done automatically for you.

So for example, like routine stuff like saving files or managing imports, this is all done

for you by the IDE automatically on the fly. Another part is that IntelliJ IDEA has a wide

array of refactorings and quick fixes for the problems that you can encounter in your

code. And we do not see them just as tools for fixing errors or fixing code that is broken.

We see them as an integral part of the code-writing experience inside IntelliJ. And I'm going

to show a little bit of how this works in practice.

So I'm going to start writing -- this is a simple Android app, a little more than Hello

world. And I've written a method and told that does not exist and so now I'll use a

quick fix to create it for me. Now I'm going to call the regular find ULD

method which all of you know, and now I'll use refactoring to save this as enter variable.

So I introduce the variable refactoring and I enter the name of the variable.

And by the way, notice this all happens in place. There are no dialogue box popping up,

nothing like that. Now it has the wrong type and it's actually

a text use so I'm entering text use here. Of course it can also insert the necessary

type cast for me. Now I'm going to write some control structures,

2013, and now this statement is incomplete. It lacks parenthesis and stuff, and I'm going

to use an action called complete statement that is going to turn this into a complete

statement for me essentially. So I'm invoking from the menu, but -- you

always use the keyboard for this, but in order for you to see what I'm doing, the menu is

more clear. So now this is an unresolved parameter and

I'm going to create this now, create parameter, and this actually triggers another refactoring,

the change signature refactoring. And this is going to go through all of the

calls of the method from -- of which there is only one and it will actually introduce

the necessary value into the call. Now, set text, Hello I/O. Of course, this

is an Android app so this is supposed to be a resource and we have a fix for that, but

that's part of Tor's demo, not mine. Another thing showing is in IntelliJ IDEA

we have two code completion actions. There's the regular code completion which you have

seen a number of times already and we also have the smart app completion. And the smart

app completion actually restricts the options on the completion list to the values of the

correct type. And it's actually not something that you always

want, but when you do want it, it's very easy and accessible using keyboard shortcut. And

if you press the same keyboard shortcut again it will have return values of the same type.

Now, actually, it looks like I'm -- I'm not really going to need this so I'm going to

use another nice coding assistance action called unwrap remove to get rid of this statement

for me. I select the option to unwrap gift and, poof,

it disappears. Now this parent is no longer used and, of

course, there's another quick fix to get rid of it. And remove parameter. It's gone. By

the way, I mentioned background code analysis and I would like specifically to highlight

some of the (Indiscernible) features. Some of them are pretty smart.

For example, this is my favorite, inspection. So when you are writing UI code you can often

make the error of mixing up the coordinates, mixing up X and Y or height and width or something

like that, and we have built in something especially for that. In this case I'm having

the max width value and set the height. IntelliJ IDEA highlights that problem and

I'm probably doing something wrong and probably I have messed things up and I should correct

them. The next thing I would -- I want to look at

is our version control integration. An important thing to note that in IntelliJ IDEA all the

version control plug-ins such as gifts (indiscernible) and a few more, they're all bundled in the

distribution of the product so you don't have to hunt for plug-ins. All the plug-ins have

a consistent user experience and work in a similar way.

And the key part of the version control integration is our changes view.

This is the view that shows the list of all the things that you have modified or added

to the project or removed from the version control, and it's automatically updated on

the fly. And you can always access the diffs and see

what changes exactly have you made. You can also use this view to trigger the

commit action so you select the files that you want to go in and you click on commit

changes and you get this commit dialogue. And because this product is using get, I also

get the option to put the changes in -- no, no, I don't want to do that.

I get the option of push the changes to the server immediately.

Now, if you want to look at what other people in the project have been doing, you can use

the get log view for that. So if you switch to that tab it shows a nice

graph for commit so this part does not have any complications in branch structure, but

if it had it would be displayed right here. Of course I can also show diffs to see exactly

was changed and you can pull the latest changes to my machine.

And another nice thing we have for get is this branch chooser pop-up. So right now I

am under my diff branch and I can use a new one that I'm doing or merge this into the

master branch or something like that. Now, of course, I could be talking for hours

about different features of the IDE, but we don't have that much time, so I'll switch

to giving you some useful pointers on how to explore the IDE further.

So first of all we have this tip of the day thing. And unlike some other products it actually

contains useful and relevant information so you can go look through those and learn something

useful. Another useful thing is the find action keyboard

shortcut. So for example, some of the things that I

have used you can type in complete and it will show the complete commit statement and

shortcut for it so that you can invoke it that way and learn the keyboard shortcut in

the future. We also have a blog with a lot of useful information

on our product. You can follow us on Twitter. And finally, we have a booth in the developer

sandbox and we will be there for the whole three days of the conference and if you have

any questions on what's going on with IntelliJ or how is it better than Eclipse or stuff

like that, please go there and ask us and we will be happy to answer it -- answer those

questions. Now I'm handing over to Xav for the communication

demo. [ Applause ]

>>Xavier Ducrochet: Thank you. We're really excited to build Studio on IntelliJ.

It's really a fantastic tool. Now I want to talk a little about project support because

this is something we really want to do well. If you look at the current situation you will

-- in Eclipse we have some custom builders. We have an end script somewhere. IntelliJ

has its own builder and they may not all do the same thing and it's really a problem and

we wanted to fix that. We want to have a single system, a system

that's flexible and customizable so that it can adopt to all your needs, and some of you

have some very specific needs. And we want to make sure also that whether

you're working in the IDE or whether you're building in your continuous integration server

then you should have exactly the same results. If you have some customization and you're

working in the IDE and you don't get the same result because the IDE doesn't understand

the customization, that's a problem. So for a little under a year now we've we

started working on that, we started an implementing a new design build system. It's based on Gradle

and it's very extensive, customizable and very extensible and it is deeply integrated

into the IDE. That means that in Studio the different behavior is when you create a new

project it will create a Gradle project using our Gradle plug-in and then it will get imported

into Studio using the great Gradle support that JetBrains is adding into IntelliJ.

And when you're building from studio it's going to actually delegate the build to Gradle

and have Gradle do the build so that whether you're inside your IDE or on a build server,

the same result every time, and that's really important.

We have a concept of a build variant in this build system. There was a talk during the

keynote talking about beta test and alpha test and being able to deploy that to users

so we have the ability to have different build environs whether you want to do release build

or maybe a bit hub build. We also have support for debug, for instance. So here we have a

build file that has two product flavors, paid versus free, then it has a new build type

bit hub. And you could configure it different ways.

I have a new panel here that shows build IM that shows I am working right now on the paid

debug version. That means when I click launch it's actually launching your paid debug version.

If you look at the source folders on the left here, the blue source folder, Java here and

then it's source main Java and source paid Java are your main source folders, so in that

paid Java folder it would put code specific to that version.