Placeholder Image

字幕表 動画を再生する

  • >>Xavier Ducrohet: Hello, everyone. Welcome to I/O and welcome our session on What's New

  • 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.

  • The green version says here that your test code, so the instrumentation test and instrumentation

  • test paid, that's your test specifically to test the paid version. And notice there's

  • a free Java and -- it says free Java here. That's not selected because you're not working

  • on the free version. So here, based on everything that we say in

  • the build script the IDE is aware that you have six different buy-ins and when you switch

  • to free debug it's going to automatically switch those here.

  • So the IDE is really aware of all your configuration. A lot of this is working now. There are some

  • things if you deal with buy-ins -- if you deal with resources and flavor (indiscernible),

  • we are going to fix that, but the point here is that everything that you do in the build

  • script to customize your application will be understood by the IDE and that's very important.

  • I'm not going to talk more about the build session. I have a session at 9:00 a.m. on

  • Friday only about the build session and I encourage you to attend it.

  • And now Tor is going to talk for us. >>Tor Norbye: All right. So I'm going to focus

  • today on -- is my monitor okay? I'm going to focus today on the areas where

  • Android Studio is different than Eclipse because there are many things that are the same, so

  • showing that wouldn't -- we're not trying to prove that we're done because we're not.

  • There's many areas that are missing. So if I can bring up the screen, here you

  • can see the environment. And one of the, I think, most noticeable features is when you're

  • editing layouts you get this preview on the right and we have a little bit of eye candy.

  • We've got Romain Guy's device frame art integrated so you can sort of see the device here. So

  • if I switch, for example, to Galaxy Nexus I can see that art and with drop shadows and

  • everything. And if you don't like that, if you really

  • want your pixels back, which I understand, you can go to the options and turn off the

  • device frame so you can take all the space for the layout, but personally I just sit

  • there and look at the reflection, overlay and love it.

  • [ Laughter ] >>Tor Norbye: So obviously as you're editing

  • you can kind of keep an eye on this. And note that as I'm moving the carat around in the

  • layout you can see the corresponding views getting selected in the layout preview. You

  • can see what you're doing. And likewise I can actually click over here

  • to navigate around the XML, so it makes it easy to navigate around and know what the

  • different parts are. And just like in Eclipse we have the configuration

  • chooser up on top here. You saw me switch devices and you can switch locales. This is

  • what we showed in the keynote demo this morning. And there's a theme to it, which is now a

  • dialogue so you can more quickly search for things. If I'm looking for dark action bar,

  • for example, it will find it right there and then I can click on it to choose it, for example.

  • One of the really nice things about this XML preview is that it's tied in with IntelliJ's

  • XML model, which is really good at fault tolerance. So one of the nice things is if I, for example,

  • go and put a typo into this thing right here, into this switch, what you will see happen

  • is this widget disappeared because it's no longer valid, but the rest of the layout actually

  • completed because it's not starting a fresh render each time. It's sort of hey, I have

  • an error node in the dump. And this also shows the error panel, which

  • is showing up in the bottom right here. So I'm going to create a new layout. So to

  • do that I can invoke the new menu, new layout resource file. So -- oh, and it's locale.

  • I'm going to switch locale back to English. So when I'm entering text here, let's say

  • I enter a button, you can see it's immediately telling me there are some problems here. So

  • it's saying you need to insert a width and a height. There are also links here, so I

  • can click on automatically add all missing attributes and they kind of just appear. So

  • there are a bunch of error recovery links right there.

  • If there's a typo, for example, it will figure out what you probably meant button, and it

  • will fix it. If you use fragments -- let's do it. I'll

  • add a fragment and we're going to need sizes again.

  • So for fragments it's saying, hey, you probably want to have a class associated with this

  • fragment, right? So I can invoke the chooser for that and pick one. Countdown fragment,

  • maybe. And now it's saying that maybe at design time you want to have a layout because the

  • whole point of fragments is it's a Java class and that class can decide based on the time

  • of day and locale and whatever, logic, whatever to actually use, a design time you can pick

  • different ones at different times. So I will pick a random one and now the layout is using

  • that fragment. You can see here in the layout this special

  • tools attribute, this is where we store metadata. You can safely ignore those. In fact, AAPT

  • will also ignore them, so there's not runtime benefit. This is how we put stuff in the model,

  • and we do the same thing in Eclipse for fragments. One more thing on the device art, we've also

  • integrated this with the screen shot action, so in the Android window I don't have a device

  • connected, but if I did, you could basically click on the screen shot from your live device,

  • get a screen shot and then add whatever art you want.

  • All right. So let's switch to the layout editor. So I'm going to -- in fact, I'll switch over

  • to this layout right here. This is a simple form.

  • So now we're in the layout editor. And I'll say right away we are not feature complete

  • here. Not everything that you had in Eclipse is ready here. I will show you the few things

  • where we are ahead, and that would be grid layout support.

  • So the grid layout support in our Eclipse plug-in is very complete and it's much better

  • here. As you can see, I can see the rows and columns

  • here and I can, for example, drag on these things to re-order them.

  • If I want to pull in new widgets, here's the palette and I get the predictable grid and

  • I can put it between. If you're doing grid layout editing I would

  • already use this, but there are some other areas where we're still working on it.

  • The good news about this preview, by the way, is that they have a really good update mechanism.

  • At least on some platforms it downloads a small patch file and restarts the IDE so it

  • takes 30 seconds, and we plan to use this to have this be a rolling preview. We talked

  • about every week. We're publicly committing right now to consider our update interval.

  • So that's the layout editor. Let's see. The next thing I want to show you

  • is code editing. So here's the feature we demoed this morning

  • in the keynote, and that is the resource folding. So one of the really cool features in IntelliJ

  • is they have this folding feature where it collapses code. So when you have a static

  • interclass, you have a run, one line for the override annotation, another line for the

  • public void run, a couple more lines for the opening and close breaks, they will fold that

  • all into a single line. So we've just used that feature and combined it with Android's

  • resources to do what you see here. This is not the default color that we have

  • for folding regions, but for the dark theme the default one was a bit hard to spot for

  • the keynote with the large screen so we made it more blue. But in general you can see here

  • -- let me click here to open all folds. So this is what the code really looks like.

  • So you don't have to know the key binding I just hit because by default you open a file

  • and it does one of these get string calls. We just show the string. When you hover over

  • it you basically get to see the real code. Like this.

  • And take a look at this last one here. I'm going to jump into this resource. And you

  • can see that what this is doing is it actually has formatting arguments. All right?

  • And when I go back and I look at the folded string, you can see that it's showing the

  • actual parameters that we have in the code, sort of in line with the strings. So it makes

  • it really easy to see what logically your code is doing.

  • So now you may wonder, okay, so have you hard coded this for get string? We have not.

  • So if I look for -- let's see -- set text, for example, what we do is we use an annotation

  • for this. So now I'm going to jump into the Android framework source code. Hopefully there's

  • nothing proprietary here. If you look, this is the TextView class. And

  • there's a new annotation on here and this is a bit TBD. We haven't actually integrated

  • this, but I think there is consensus that this is what we're going to do. This is a

  • resource data annotation. And it's saying, hey, this integer parameter right here, we

  • expect that to be a resource in. So that's the actual thing that the code folding is

  • using is this method. So when you call set text, even if you don't call get string, if

  • you just pass r.string.fu it will actually do this resolution.

  • So since we're talking about annotations, let me show you a few others that we're adding.

  • If I go to context, you can see not null. We're also adding nullability annotations,

  • and IntelliJ can actually show those. So if I open up the project configuration for my

  • SDK, there's this annotations setting where we have basically bundled Android annotations.

  • So it can basically read annotations from an external file, not part of the SDK, and

  • that's how we can actually take these annotations and associate them with older SDKs and it's

  • using this on the fly. So if I now jump down to the bottom of the

  • file here -- let's see here, for example, this line is highlighted because it shows

  • that get current focus, which is an inherited method from the framework, can return null

  • and therefore this line could potentially return -- cause a null pointer exception.

  • If I jump into the other annotation here, service name, I'm going to jump to source

  • for that. And this is making a local annotation saying that service name has to be one of

  • these identifiers. So in fact, if I go back to my Android Studio,

  • you can see we have another annotation here saying that you're passing in the right to

  • set layout direction, but it's the wrong right. Even though these are both ints and the compiler

  • is happy to do it for you, we know it's wrong. And that's because again we have this information

  • now in this external file that basically records what constants are allowed for integer parameters.

  • At that's in this external file that basically records what constants are allowed for integer

  • parameters, and in the case of the system service here, strings. And we use this not

  • just for semantic analysis. If I, for example, go in to get system service

  • and press control space for completion, you can see it notes the strings there, too. So

  • especially for integer APIs, it's kind of nice. You don't have to know exactly what

  • the strings are. At this point, I'm going to jump in and show

  • you a few other IntelliJ editor features. So when I was showing you the resources earlier

  • here, we have references to notification icons and those are being previewed on the left.

  • This is the actual size we show them in. I think we max them out at 14 pixels. In the

  • keynote we had them bigger to be visible, but this is what they'll get scaled down to.

  • So these graphics -- these aren't just for icons. If you have a 128 by 128 icon, it will

  • just be shoved into this editor margin. And colors are previewed as well.

  • And if you open up the show documentation view, I think it's F1. If not, we have an

  • expert on stage -- F1, yes. This is the documentation for this resource. We show you all the translations

  • right there in the popup. And if I do it on an icon, I can see all the icon versions.

  • And I think -- yes, it's computing what the actual pixel sizes are at the different densities.

  • All right. So we've also integrated lint. There was already

  • a lint integration in IntelliJ but it now does more the inspections. And lint actually

  • does analysis on both XML, Java and class files. And the last part is tricky because

  • one of the things you'll discover in Android Studio is it doesn't do background compilation

  • in the way you're used to. There's an explicit compile action. So because of that, lint doesn't

  • have the class files to look at. So we've implemented the most important one,

  • API check, using IntelliJ's own AST APIs. And so if I look for API check, here's an

  • example of this. So if I hover over this, it's telling me that

  • this API requires 14, and you're current min SDK is 7, and that's a potential runtime problem.

  • So what you can do is use an annotation to basically say you know this method will only

  • be called when we've already validated that the platform is at least 14.

  • The way people typically do that is what you see on the next slide. You actually have an

  • SDK check. And it was very tricky to do this with sort of flow analysis in the class file

  • but it was easy with AST. So this is something we haven't run in Eclipse or the command line

  • lint yet, but in IntelliJ it knows not to flag these two lines because they are inside

  • this version check right there. We also have a couple of newlin checks.

  • Is there a talk on the right-to-left text stuff here at I/O? If not, at least we have

  • a couple of new lint checks related to right-to-left and they are disabled by default but they're

  • a bit experimental, but if you're trying to target API 17 and you're doing right-to-left

  • text, you can check out the lint options. So in the search box you can just search for

  • lint. You'll find all the inspections. And you can see the ones that don't have a check

  • box next to them are off by default and you may want to turn them on. For the basic Java

  • code analysis in IntelliJ, there are some off by default that we've gone and bumped

  • up. On our team, for the tools, for example, we make override annotations mandatory. You

  • can't actually override without setting the override annotation.

  • All right. This part I want to show you a couple of IntelliJ

  • features that Dmitri didn't get into. So the first one is scopes.

  • So here I have a library project, and I can go ahead and create -- and I'm using action

  • brochure lock because I'm trying to have an action bar in an older version of Android.

  • So I can go ahead and open up the scopes feature. And I can go ahead and make a new scope, a

  • new local scope and I'm going to call it action bar.

  • And then I can say that I want this to basically match all of action bar -- I just closed the

  • dialogue. Sorry about that.

  • And now I can basically say that I want to add everything from -- I don't know, I'm making

  • a mistake here. Project. Okay. I'm going to choose everything in the

  • action bar Sherlock and include recursively. So now we have a new scope. Now I can go to

  • file colors, and I can basically add a new color scope for my new scope. So I'm going

  • to make everything related to action bar orange. And now if you look in the project explorer,

  • everything here is orange. And if I open these files you can see the tabs are orange. And

  • in, in fact, in the recent file dialogue, things are orange. So this is really good

  • if you have projects that you're trying to use and they're in your work space but you

  • don't want it accidentally edit them. You're jumping into resource and you find, ah, this

  • is actually in the library. I can't change this. This feature is really useful for that.

  • My favorite feature in IntelliJ is open symbol. So if you are exploring a new API, if you're

  • not particularly familiar with something in an API, open symbol lets you jump to a method

  • name or field name. So if you're not sure which class to look in, instead of searching

  • with Google, which you should do, you can use open symbol here.

  • So I'm going to use the go to action feature that Dmitry showed you. So if you don't know

  • any key binding, basically you can open this dialogue and just search for it and it will

  • basically match. Open symbol. Okay. So this is the open symbol action.

  • And now let's say I want to find out the parent activity name or something like that. So I

  • can type parent activity name. And actually I want to go to this one. So

  • nav util contains a method called get parent activity name (indiscernible) in the context.

  • Another cool feature is injecting languages. So here I'm showing a method called inject.

  • And so if you look carefully you can see there's a green shine to this area. That's telling

  • me that it knows there's a sort of different language inside this string. And if I open

  • up the quick dialogue, it says this is a regular expression and I can, for example, open a

  • regular expression tester and I can type in text to see if it matches.

  • And so -- [ Applause ]

  • >>Tor Norbye: -- so on the next line, you can see I'm actually -- I'm going to go on

  • the third line here. This looks like XML; right? I can say inject language and I can

  • pick the language I know this is. I'm going to say this is XML. And now this is going

  • to be treated as XML. So, in fact, let me make a mistake in the

  • XML. So now it's saying, hey, this looks invalid to me. It's saying there's no attribute value

  • here; right? So it's basically validating my string escaped

  • as XML. And I believe this is really useful when you,

  • for example, are doing database queries. I think IntelliJ has a database plug-in so if

  • I were to treat this as SQL, for example, you can get additional language help that

  • way. And I am almost out of time.

  • The last tip I'll give you is that in a lot of dialogues, in the IDE, you can just start

  • typing. It's not going to tell you you can do this. It's just something you know.

  • So my favorite key binding is, other than alt enter, is control T. Control T is basically

  • the action to refactor this. So if you can't remember the key binding for,

  • you know, renaming or moving or whatever, just control T, refactor this.

  • And so here's this dialogue. Notice that there's numbers at beginning of these items. I can

  • just hit the number on the keyboard to invoke that action but more importantly I can just

  • start typing. So if I type change -- actually, that was a bad word.

  • Okay. Constant. If I try typing C-O-N, you can see it matches. So it's a very quick way

  • to navigate and this works in lots of places. For example, if I want to go create a new

  • resource folder here, add new resource directory, if I, for example, want to go and add a language

  • to my animation folder, let's change that to layout instead because I like layouts.

  • Oh, that's the name. Layouts. If I add in a new language, you can see we have region

  • art here. So if I just start typing Norway, you can

  • see it's now matching from the whole list of hundreds of regions down to the region

  • that I'm trying to add here. And then I can add my resource photo like that.

  • All right. I'm out of time but there's more stuff, so, you know, keep looking at our blogs

  • and posts for additional tips. [ Applause ]

  • >>Tor Norbye: Thanks. >>Xavier Ducrohet: Thank you, Tor.

  • So one other thing we wanted to do is to cover more than just, like, regular Android applications.

  • I mean in the context of Android application. A lot of your users are going to have more

  • than one device that have a phone and a tablet. And if they install your application on their

  • device they are going to expect those two installations to be synced together. So we

  • wanted to add support to really help you build applications that are connected like that.

  • And so I'd like to invite on stage Brad Abrams, the PM for app engine, to tell you about this

  • feature. >>Brad Abrams: Awesome. So the best Android

  • apps are powered by the cloud, and customers tell us that google's cloud platform is really

  • ideal for mobile back-ends. And that's why we were very happy to invest in the Android

  • Studio project. So what I thought we'd do is actually cloud

  • connect the stopwatch application that you saw earlier.

  • So what we're going to do in just a couple of minutes is build out a completely synchronized

  • stopwatch application. So somebody at the front of the race can have the stopwatch.

  • Someone at the end of the race can see exactly start/stop time of that.

  • So in order to do that, one stopwatch will click start. That will send a rest request

  • up to our server running in app engine. That will send a message to GCM. Beeping is going

  • on. GCM will send a tickle down to another Android application, and then that will do

  • a rest request back up to app engine and get the actual state. So let's flip over to the

  • demo and see that, which is here. So what I have is the Android Studio, and

  • I have the exact project that we've been using, the stopwatch app. And I thought I'd start

  • exactly where Tor left off in the keynote today.

  • Tor did a great job in the keynote, didn't he? It was pretty good?

  • [ Applause ] >>Brad Abrams: So let's start where he left

  • off. We'll come in and say generate back end. So what this is going to do is -- those values

  • you can fill in later. What this is going to do is generate for us a project, a server

  • project that you can easily go deploy to app engine that already knows about this client

  • side code. So if we look in this server project, there's

  • a few pieces of code here, and you see we have a couple of end points. We have a device

  • end point and a messaging end point. The device end point encapsulates all the plumbing needed

  • to do GCM. Google Cloud Messaging. How about of you have actually done GCM before?

  • And there was probability some drudgery in getting that to work especially on the server.

  • So we've taken care of all of that for you and that's encapsulated in there.

  • What we want to do now is add our own custom end point that's going to be exposed as a

  • custom interface. So in order to do that, I'm just going to

  • copy in a stopwatch state class, and this is a POJO. This is a plain old Java object.

  • I've marked it up a little bit, but all it's storing really is three bits of information:

  • the device ID, the time stamp, and then whether or not we're running or not.

  • So we've got this -- and you can see it's just got basic accessories on it.

  • Now what we want to do is take this and we want to generate a rest interface based on

  • that POJO. So what we're going to do is just generate

  • a cloud end point for that. And if we flip over into this end point, you can see we've

  • already got the code for listing all the entities for doing -- that includes paging, by the

  • way, in case you have a lot of these. You can get the stopwatch state, you can insert

  • the stopwatch state and whatnot. So all of that is already done for you. It

  • stores the data in app engines. No SQL data store.

  • But now what we want to do is go and add a little bit more logic into here, so I'm just

  • going grab import, and I'm going to do some of the GCM code.

  • So what we want to do is when there's an insert -- so we'll come down here to insert. Right

  • now when we're inserting, we're just storing the data in data store. But what we need to

  • do in addition to that is send a tickle out over GCM.

  • So we have some utility code for doing that, that I'll put in here, and we'll post this

  • code later so you can take a look at it. And then we just need to add a little bit

  • of code to actually do the send. So right after the -- we persist it. What

  • we're going to do is get -- enumerate through all the devices that have registered.

  • Now, we may have a hundred people with a stopwatch application wanting to be updated in real

  • time. So we enumerate through all of those. We just check to see if the -- if the one

  • we've gotten to is the same one that sent the request, so we don't want to reset ourselves.

  • So we exclude that one, and then we just send that tickle.

  • And then to make this compile, I need to -- throws I/O exception. And it's nice to decorate that

  • because actually we're going to propagate even exceptions and errors all the way down

  • to the Android app, as you'll see in a little bit.

  • So we basically got the server side of our application done, and you can see it's done

  • in the same IDE, in the same language, very easy, seamless to move between that.

  • Now what we can do is come in and upload this application to app engine. Go ahead and deploy

  • it directly from the IDE. In the interest of time, I've already deployed that for us

  • a little bit this morning. So let me bring that up.

  • What you'll get by default with this project is a simple test page. It shows you all the

  • devices that have registered. In this case, nobody has registered yet. And then it will

  • let me send a message. But to explore those end points, if you go

  • to underscore ah/api/explore, you can actually explore all the interfaces we just defined.

  • So you can see there's the rest interface for C2DM and here's the stopwatch one we just

  • added. I can come and interact with this. I can test authentication. You see the rest

  • responses and whatnot I get out of here. So this is a good way to make sure your server

  • side logic is working exactly the way you expect before you start moving to the client.

  • Okay. So back in the client, what we need to do now, we have our rest interface. We

  • need to be able to call from the client. So in order to do that I'm going to come back

  • in here and I'm going to generate a client library. And what this is going to do is take

  • the same discovery document that we -- that powers that API explorer and use that to generate

  • strongly tied to Java code that's Android optimized, mobile aware code, and stick that

  • in our client project for us. So to make it very seamless for us to access

  • this server code. So now you see it created this new folder.

  • We're back in the client side of the app. It created in new folder with these three

  • end points. On it. Now let's take a look at how we go and call

  • that. So I've just made a few modifications to the code to be able to call the end point

  • we defined, and we'll go ahead and overwrite those.

  • And the main thing that we just did, we added some helper class, but the main thing we did

  • is make sure all the network operations happen on a background thread. So either by spinning

  • up a thread or, in our case, we're using an async worker so that ensures as I'm doing

  • that network traffic, the UI is not hanging and freezing and whatnot.

  • So that's that basic code. Now, the last bit is I just need to come in

  • and wire it up. So when I hit start and stop, the actual methods get called.

  • So I've already got a handy dandy added to my method this send state with end point,

  • and you can see it's grabbing the current time. So I'm actually going to take the current

  • time. I'm going to send whether or not this is running and then my ID. And this is going

  • to send it up. And notice I call that in this method startstop.

  • So whenever I hit start or stop I do a rest request up to the server.

  • So I think we've got it basically working. You guys want to see this thing running live?

  • Okay. So let's go. I think I hit this. Okay. So I've got two phones here. Whoop.

  • That one can't go yet. So the first thing I want to show you -- are

  • we seeing it? Yeah. The first thing I want to show you is when

  • I launch this app, by default the project that comes with Android Studio, it will give

  • you this registration screen. This is your indication that the GCM registration was successful.

  • You're able to contact your app engine back-end and it was able to register this device ID

  • with GCM. Obviously when you go to deploy this app,

  • you can remove this screen. So we've registered. Hopefully they're both

  • up. Let's reset and start this one. Okay. Notice when I started this one, the

  • other one stopped -- started, and when I because this one, this one pauses at exactly the same

  • time. Pretty cool, huh?

  • [ Applause ] >>> So let me just switch back here.

  • And one more slide to leave you with. We're very excited on the cloud team to support

  • Android Studio. As Xav mentioned, we've done the work to make sure you can do builds of

  • even the server side stuff outside of Android Studio, so you can do it in your build tool

  • of choice. And you can find more information about the cloud at that URL. And I'm giving

  • a little bit longer version of the talk later at this place. So love to see you there.

  • Thanks. [ Applause ]

  • >>Xavier Ducrohet: Thank you, Brad. So, you know, it's an Android idea. We're

  • going to add a lot more features, including features like the cloud stuff. That's not

  • where I wanted to go. So we're still (inaudible) Eclipse and I want

  • to show you a feature that's new in Eclipse that about bring to ID.

  • You saw during the keynote we translation on the play console, and I want to show you

  • that now. So here -- so this is my account, you know,

  • and I have an app. It's called sample app. And I can create a new translation.

  • So I already have some French translation that are ready to go but I'm going to create

  • a new version. I'll call that test. My original translation is in English. Continue.

  • All right. And here I can use the plug-in. If you have a complex project, you're going

  • to have a lot of strings and you probably don't want to go them and upload them manually

  • so generally in the plug-in you can say use plug-in and then you're told what to do, which

  • is useful. And then you can to Eclipse where we have

  • this new plug-in. It's not part of the bundle, the bundle that we have with ADT and Eclipse.

  • It's available. If you go to developer.android.com you have the instruction right next to the

  • ADT instruction to install it. And from here you can very easily -- I think

  • from here translation manager, you can just do request translation.

  • So I already -- there you go. So I already logged in with my same account,

  • and it discovered that I had my, you know, test project that is waiting in my browser.

  • And so I can just click next, and then it knows all the strings that I have so you can

  • go and look and make sure those are the strings that you want and then you just upload them.

  • In that case here, just a single string, but if you had a lot of string file, it would

  • just upload all of them, which is really convenient. And when you finish, you go back into the

  • console here, you click continue, and then you say, well, I want to translate them in

  • German, for instance. You click okay. And then you choose your translation. And

  • then you choose some translator. And then you click confirm, and then you get, you know,

  • a week later, your translation. And then of course we want same thing; right?

  • Because the format you get back from the translator may not be exactly the format that we want.

  • So here we go and easily click download, and here I have some translations here that are

  • ready, and so I click next. There they are. I click download, and on the left here on

  • the values, I have my -- you show here which string you just got. And you got your string

  • translated directly. So the whole work flow is directly integrated

  • into the IDE. We'll have (indiscernible) Studio, of course. It's available now. I think you

  • have to go and sign up for the pilot to be able to do that.

  • All right. And this is, you know, the end. We have a couple of -- well -- no.

  • So we are taking questions. You know, so feedback again. (Indiscernible). We have a mailing

  • list, (indiscernible) @Google groups, and then we'd love feedback on Android Studio.

  • All right. [ Applause ]

  • >>> The translation is a nice feature. A question is what if you translated it once and then

  • you added a couple strings or changed a couple? Does is it know to just ask for translating

  • what changed? >>Xavier Ducrohet: I think it deals with that.

  • There is a talk on Friday at 12:00 p.m. that will talk a lot more about that, and you should

  • go and check it out. They will probably have the answer. But I think the (indiscernible)

  • already been translated and they only translate the new things.

  • >>> I'm looking forward to your weekly updates. I want to get a clarification on the direction

  • between Eclipse and the Studio and kind of validate where we're going with the two IDs.

  • >>Tor Norbye: We suspected that question would come up.

  • >>Xavier Ducrohet: Yes, we are going to keep supporting Eclipse. You know, that's something

  • that we won't be able to do in Eclipse because it has, you know, the language framework is

  • not as good, or as extensible. So it's harder for us to plug into it.

  • But we are going to keep supporting Eclipse. Right now we're focusing a lot on studio because

  • we have to bring a lot of the features from ADT into studio but we're going to keep supporting

  • both. At some point we're going to integrate Gradle directly inside ADT also so you have

  • a single build and (indiscernible) to be able to build with that.

  • >>> One of the things -- First of all, thank you for using IntelliJ. It's a great IDE.

  • >>Xavier Ducrohet: Yes. >>> One of the things that I missed from Eclipse

  • is merge manifest. Do you know when that's going to be available for --

  • >>Tor Norbye: It's a feature of the new build system.

  • >>Xavier Ducrohet: Yes, the new build system merged the manifest so you don't have to do

  • anything. We still support the old builder in IntelliJ in case you have an older IntelliJ

  • project that you are using so you can open it and use it, but the default behavior is

  • to use the new build system, and the new build system deals with merging the manifest.

  • >>> Is that available now? I already use IntelliJ. >>Xavier Ducrohet: Yes, it is available now.

  • >>> So just on -- >>Xavier Ducrohet: Yeah, if you get Studio,

  • you'll have automatically create a new project and you'll see the new build system and it

  • does manifest merging. >>Tor Norbye: In the new -- in Android Studio,

  • you can't create -- in the Android Studio version, not with plug-in in IntelliJ, you

  • can't create old style. You can only create Gradle-based projects because we're really

  • trying to get that part working beautifully. >>> Translation question. My apps are all

  • translated by volunteer users. I'd love to see crowd sourcing in your framework. Anything

  • on that? >>Xavier Ducrohet: Again, session at 12:00

  • on Friday, the people who deal with that will give you a big LMO and they can answer that

  • question. >>> Thanks for the switch to IntelliJ.

  • >>Tor Norbye: Last question. >>> That's really appreciated. I'll have to

  • get used to Gradle, I guess, because I'm using Maven to do all the builds.

  • I have a question about compiling with multiple APK loops. You mentioned action by Sherlock

  • before. That's commonly used and it is not uncommon to use it with Holo Everywhere and

  • Holo Everywhere Preference. Maybe with your own APK lib as well.

  • So in some of my projects, I'm building with four APK loops all at once. At the moment

  • that takes a long time because you have to run ADTs through all of them.

  • Where are you progressing on that? >>Xavier Ducrohet: So we have better support

  • for that. I think it's a lot dependent on text merging to be able to help with that,

  • but we have a new feature to merge resources that's more incremental, so that will be faster.

  • (Indiscernible), we're improving that a lot. It may not be just there yet, but we're improving

  • it a lot. Also, one thing is because of Gradle, you won't necessarily need to have all those

  • projects open in Eclipse before you have to. You have (indiscernible) open, so here you

  • can just focus on one module, and that makes things faster anyway.

  • >>Tor Norbye: So we're unfortunately out of time, but we're going to be out there.

  • >>Xavier Ducrohet: So we're going to be at the office hours and we'll be there as long

  • as people have questions. So, you know, just come and talk to us.

  • >>Tor Norbye: And that's right now. We're going there right now. All right. Thank you.

  • >>Xavier Ducrohet: Thank you very much. [ Applause ]

>>Xavier Ducrohet: Hello, everyone. Welcome to I/O and welcome our session on What's New

字幕と単語

ワンタップで英和辞典検索 単語をクリックすると、意味が表示されます

B1 中級

Google I/O 2013 - Android Developer Toolsの新機能 (Google I/O 2013 - What's New in Android Developer Tools)

  • 93 12
    winiex に公開 2021 年 01 月 14 日
動画の中の単語