What’s new in Android development tools (Google I/O ’18)
Articles Blog

What’s new in Android development tools (Google I/O ’18)

August 11, 2019

[MUSIC PLAYING] JAMAL EASON: Hi. Welcome to What’s New in
Android Development Tools. I’m Jamal, a product manager
on the Android Dev Tools team. TOR NOBYE: And I’m Tor. I’m the tech lead
for Android Studio. JAMAL EASON: So
we’re excited to show you some of the new features
that we’ve been working on inside of Android Studio. As you know, Android
Studio is the official IDE for developing apps for Android. Before jumping in,
I just want to spend a few moments highlighting some
things you might have missed since we last spoke with you. So last year at I/O, we
launched Android Studio 3.0. And that included things like
new performance profilers, Kotlin language
support, adaptive icons, and a new Android emulator with
Play Store integrated plus 20 new features. Earlier this year, we
launched Android Studio 3.1. Let’s talk about it. So Android Studio
3.1 was focused on performance and quality. We fixed over 800 bugs
and stability issues. 40% of our time
was fix on issues reported by you, so thank you
for your patience and feedback. Now, we’re certainly
not done with quality. We’ve heard loud
and clear from you that performance and
quality is essential, so we’re continuing
to invest in that. But even with our focus on
quality in Android Studio 3.1, a few bugs slipped past us. And so thank you for those
who report those issues to us to allow us to fix those issues. In addition to quality,
we know that build speed is also critical for you. So inside of Android Studio
3.1, we worked on that. So for example, when using
D8 with the Sugar integrated, we drove upwards of 60%
build speed improvements on full builds without caching. So that’s a great improvement. So in addition to build speed
and quality in Android Studio 3.1, we worked on a
few different features, including SQL code
editing support. So this has code completion
and project navigation. So if you’re using any
of the room database APIs or any of the SQL Lite APIs,
this would be a plus for you. So last year, we
announced Kotlin as a first class language
on the platform inside of Android Studio. Since that point,
we’ve been continuing to invest in to Kotlin. So inside of Android
Studio 3.1, you can not only do Kotlin
checks in the ID but also on the command line. So if you do a lot of
automation tests with Kotlin, now you have that support built
in inside of Android Studio. Now, for those of you
who have C or C++ code, here’s also a treat for you. We added a C++ CPU profiler. And again, it allows you
to drill into your C++ code and understand the performance
impact of your C++ code. And of course, that’s on
the unified timeline inside of performance profilers. And speaking of
performance profilers, we also updated the
network profiler. So we know that many of you
have multi-threaded network threads in your app. So now you can look at
each individual thread and see the performance
of that aspect, and of course, you can
drill into the call stack and see, down to your source
code, what’s happening. And of course, with each
version of Android Studio we tried to include the latest
version of IntelliJ in there. So one of my favorite features
in this version of IntelliJ is actually this new feature
called an SVG previewer. And why that’s cool is that
as I’m importing and managing my SVG assets and converting
those to vector drawables, it’s very convenient to be
able to double click back into the source asset
to see the SVG file. So that comes along with
the IntelliJ update. And of course, with
Android Studio 3.1 we also worked on some updates
to the Android emulator. One of the pain points
we heard from you is that the emulator
is too slow to boot up. So as we saw this morning
from [? staff’s ?] keynote, we enabled quick boot. And quick boot allows you
to launch the emulator in under three seconds. So if you have a chance to
try that out, please do. All right, so that brings us to
today, the talk about Android Studio 3.2. So our team works closely
with the Android framework and the Google engineering teams
to ensure that all the latest Android technologies and
APIs are tightly integrated to accelerate your
development flow. So for example, with
Android Studio 3.2, you can test and validate
and integrate all the latest Android APIs from the
P developer preview. And as announced
this afternoon, we have a brand new format
called the Android app bundle. So with Android Studio 3.2
you can build this bundle, and in a course of time you
can deploy a customized APK to users using Google Play’s
dynamic delivery system. And lastly, Android Studio
is a major component of Android Jetpack. And again, Android
Jetpack is a set of libraries, developer
tools, and a set of opinionated guidance to help
you quickly and easily scale to make great apps for Android. Now, for Android Studio 3.2, we
worked on a range of features across each development
flow in your process. So instead of me talking
about each individual feature, I’ll actually have
Tor give us a demo and tour all the cool features
of things you can do inside of Android 3.2. And I’ll come back and
talk with you afterwards. With that, Tor. TOR NOBYE: All right,
so it’s my pleasure to show you all the
new features that we have built over the last year. So the first thing
you’ll notice is that we have this new
window on the right. It’s the What’s New Window. So in this window, we’ll
be showing it to you once per release, and we’re
sort of highlighting the important things
for you to know, changes and new features
in that release. And if you look at 3.2,
the number one thing that we’re profiling is the
new Android app bundle support. So let’s get right into that. So the key takeaway
about app bundles is that it lets you package and
upload your app in such a way that the Play Store can
create many different versions of your app for each combination
of chip architecture, screen size, and even locale. And that makes the
downloads smaller, right? So in studio, all you have
to do is rebuild your app. So if I go to our generate
signed APK wizard, you can see there’s
a new option now for generating an app bundle. And here I can sign it. And it’s really important to
understand that for Google Play to do this it has
to sign your app. So you have to give it your
encryption key to do that. So I’m going to choose to
export the encryption key. Note also that it’s not
exporting it into the bundle, OK? So if you look at the
little notification here in the bottom
right, there’s a little link that we added
so you can see where we stored that key so you can upload it. The UI needs a little
work, so we’ll tweak that. So now that we’ve
created this bundle file, we can take a look at it. So the key analyzer also works
on bundle files, naturally. And if you look at this, it
should look pretty familiar. So dynamic delivery is
really, really easy to do. It’s basically, you know,
upload your key and rebuild. And that’s in production today. We also are previewing
dynamic feature modules. And so if you look
carefully at my bundle file, there’s actually this other
thing called Article Composer. That just happens to be a name
I chose for a dynamic feature in this app that can
compose articles, right? So how did I do that? I went to the new module menu. We have a dynamic feature
module module type. And here– it
doesn’t want to go. JAMAL EASON: Select. TOR NOBYE: Oh, OK. Here I basically get to
choose the name of the feature and also– enter target. I see that’s the problem. I have network issues. I’ve already created
this module, obviously, since you see it
in my bundle file, so let me show you how
it’s all wired together. So first, I have
a new module where we apply this new special Gradle
plug-in for dynamic features. We have a manifest in that
module where I can basically say that I want this
to be on demand, and we want the Play
Store to fuse it so that it can build APK
case for older devices that don’t support this. And in our main app module, we
link to these dynamic features. So creating a dynamic
feature module is a lot more work for you. You’re going to have
to use the Play core library to react to download
and installation events. But it’s really useful if you
have some large functionality in your app that not every
user is going to want. So you can have your base
app be small and then do the on demand installation
of these other features. One other thing we’ve added
to the run config dialog is the ability for you to choose
which features are included when you are testing locally. Now, to test download
and installation stuff, you’ll need to use the
Play console testing track. All right, so
that’s dynamic apps. Let’s take a look
at the profiler. So we have several new
features in the profiler. I’m going to open it up. And I have an app running. This is the Plaid app. So the first thing you notice
in the bottom left here is we have a session’s view. So you can record multiple
profiling sessions, and then you can go in and
sort of compare results. One thing I’ve already
recorded earlier is a new feature we’ve
added, which is systrace. So systrace is this
really powerful profiler. It looks at data from the
kernel so I can see what’s going on on different CPUs. There’s thousands of tracing
events from the kernel that’s being recorded. That’s probably hard
to see on the screen. There’s some faint
graduation of colors here to show you
all these events. So that’s the CPU tracer. I’m sorry, that’s systrace. Let’s go back into our CPU view. Now, let’s assume–
actually, let me start. These were all
prerecorded sessions, so let me now attach to the
current running session. So here’s our telemetry view. So now I’m going to go
into the CPU profiler. And let’s say I’m
interested in recording why my UI is so
slow when I click on this thumbnail on the right. Until now what I would do is
click on this record method trace button on the left, and
I would try to quickly press it after doing the action. Well, what I can do now is
actually trigger it from code. So in 3.2, we have
this ability for you to call the debug method. This is a standard SDK method,
Android dot OS dot debug. So I’m telling it I want to
start method tracing here at the beginning on create. At the end, I’m going to
say stop at the tracing. Right? So now, then I’m going
to click on the UI. Take a look at what
happens in the CPU view. So you can see it captured
exactly the range of code that I’m interested
in, and I can now drill in and figure out what’s
wrong with my layout inflation. So that’s the CPU profiler. Let’s move on to the
network profiler. So let me scroll out a bit. So as Jamal mentioned, we
have two new features here. We have a threads
view so you can see which thread is doing what– some random picture
from this app. We are also showing
requests and responses for the network profiler. In the memory profiler,
our biggest new feature is the ability to show you JNI
references and the allocation trace from the JNI references. And last but not least is
our new energy profiler. Let me zoom out a bit. So the energy profiler
helps me figure out what’s going on with my battery life. So if I take a look
earlier in the app here, you can see we have
this legend on top. And this is showing me that I
have fairly light CPU usage. But it’s telling me if I’m
touching the network, if I’m getting location requests,
if I’m running alarms, and if I have wake locks. And if you see there’s this
big red bar on the bottom, that’s showing there’s
a wake lock in effect. A wake lock means that the
device cannot go to sleep. This is obviously really
bad for battery life, right? So let’s look at this range. And here it actually shows
me the real wake lock names. We can see our
first wake lock was alive for about four seconds. That’s normal. But the second wake lock– still unreleased and
going for 50 seconds. That’s not good. So what I can do is
click on that wake lock, and we drill down to where
the wake lock was acquired. You can see obviously
this is a bug I added. This is not the
Plaid app’s fault. This is just to
show the wake lock. So the wake lock detector
and the whole energy profiler is new in 3.2 and hopefully
very useful to you. All right, so that’s
it for the profiler. Let’s talk about the
emulator for a bit. Let me stop profiling. All right, so here we
are in the emulator. We have the new snapshots
that you saw earlier, and we actually have
a whole UI for this. So I can see here that my
quick boot obviously looks like the lock screen, right? But I’ve also recorded
a session in the middle of searching a Google Maps. So I can just click the
snapshot, press play, and my emulator’s instantly
in that exact state. I also recorded a snapshot
while running the clock. So again, if I
press play, you can see it’s instantly in
that state, 15 seconds into recording the snapshot. And recording a snapshot is
as simple as clicking the take snapshot while you’re
running your emulator. And then you can bring it back. You can see there’s also
a special quick boot snapshot, right? That’s the one that emulator
is going to come back into when you restart it. So if I exit the emulator
right now and bring it back up, you should see that– yes. You know it comes
back really quickly. We’ve added a few other
features to the emulator. So by popular demand– screen recording. A lot of you wanted this. This lets you record
a video of what’s happening along with audio. And we’ve also
enhanced the camera. So let me start the camera. Yes, yes. All right, so what
we’ve done here is we are now feeding the
camera and the emulator sensors the fiction that
you’re in this 3D world here. Actually, I don’t
have to hold Alt key. So I can move around
in this 3D scene, and this is really,
really important when you’re building AR apps. And speaking of AR, we
have some support back in the IDE for that. So let’s see. This is a GLTF file,
and we have a plug-in– let me see, settings. We have this scene form plugin. So you’ve heard about the
scene form in the keynote– a scene form plugin which helps
you preview your 3D models. So here’s this GLTF file. I can go in and import
this as a scene form asset. We support GLTF files. We support OBJ. We support FBX files. And so when I run
this import, it’s going to create a Gradle
task for me, which is creating these SFA SFB files. That is core to scene form. And then I can open my SFA file,
and the important part here is that we have a viewer. Ta-da! So now I can explore what’s
going on, in a 3D sense, what this model is doing. All right, so that’s scene form. Let’s switch gears a bit
and talk about Jetpack. So if you look at the package
names in the editor here, you can see that we have
Android dot Support. We have some V4, some V7. These are super misleading
version numbers, right? And so we decided we need to
clean up our legacy a bit, and so we are
repackaging everything from Android Support
over to Android X. And to help with
that migration, we’re providing all of our libraries
in both the old namespace and the new namespace
for now, as well as a automated refactoring tool. Let me show you how that works. And by the way, this
also applies to XML files where you have these class
names, and even Gradle files, because we are also repackaging
the group IDs and artifact IDs for these libraries. So I go to refactor,
refactor Android X. It’s going to look
through the code. Then it’s going to offer
to preview the changes. I’m feeling lucky. So you can see here– actually,
let me open up the git view. And I highly, highly,
highly recommend that you all make backups
and use version control, both preferably,
before you do this. So you can see that
we’ve actually replaced a bunch of the code here. And it should work, but
we are aware of some bugs already in Canary
14 and in Canary 15. So we would really like
you to try this and give us feedback on what’s
broken so that we can make this working smoothly
for everyone before 3.2 goes to stable. All right, so Jetpack
is about a lot more than cleaning up legacy code. We are adding a number
of new libraries. And one of the most important
ones, for the tools anyway, is the navigation library. So the new navigation
library does require you to architect your
app for the navigation library from the beginning. So this is not magically machine
learn intelligence figuring out what your app is doing, OK? This is a navigation graph
we have created for this app. So let me show you how the
navigation library works, the plumbing
underneath it, first. So I have a launcher activity. I point that launcher activity
to a sort of root layout. And in that layout, all I do
is I put a navigation host fragment. And this navigational
host fragment will do the dynamic
dispatching at runtime. And then we put the
navhost fragment to this navigation
resource file. That’s a new resource
type that we’ve added for this specific library. So now we’re looking back at
the navigation resource file. It’s just an XML file, but we
have a nice visualizer for it. Let me actually go
ahead and run the app. So if you look
carefully, you can see that near my mouse pointer
there’s a little Home icon. That tells me that
this page is the start destination in the app. I can just go to
the title screen instead and click on
set start destination. And when I run it again, you’ll
see that now the app instead starts on the title screen. I didn’t change the launcher
activity or anything else. All I changed was
the navigation graph. So that tells the nav
fragment where to begin. All right, so next I’m going
to click the Play button, and it does nothing. Why is that? Well, the Play button is just
a button in this layout, right? So if you look at
this layout, there are two arrows coming
out of it, right? The first one, on top
here, has the action, play. That’s one of the things
we want to navigate. When the action play happens,
we want it to go to this page. When the action
leaderboard happens, we want to go over here. Let’s go take a
look at the code. So I’m going to drill into the
layout by just double clicking. So here’s our
button, and I’m going to jump to the onclick
handler for that button. It’s called onPlay. And I’m going to
uncomment this code. So what we’re
doing here is we’re finding the nav controller. That’s from the
navigation library. And this is Kotlin so we have
an extension method right there on the view. But in Java you could just
call the navigation helper. So we get the nav
controller, and we say, navigate to the action play. All right, so now I’m going
to deploy that to the app. And once that gets there,
I can now press play. And you can see it
goes where we want. So I can now go back into
the navigation screen. And instead of jumping
when I press play, instead of jumping to
the register thing, I’m going to have it jump over
to our in-game screen instead. So I’ll just make that change. Notice the code doesn’t change. The code just says,
take the play action. All right? So now when I press
play, instead we go right into the game. So the routing table is here. Another thing we can do is to
select this transition and say, you know what? I’d like an animation
on this transition. So I’m going to choose the
rotate cross to tick animation. And again, I’m going to
deploy that to the device. And when I press play
now, look at the screen. You can see it rotates. So there’s a lot of
features in the Nav Editor that I’m not getting into. For example, passing arguments
in a safe way from one screen to another,
or nesting graphs. I’ll just show one last thing– deep links. So I’m going to press
the plus button here to create a deep link. And let’s pretend for a moment
that I own the Google.com domain. So if I look at the
manifest file here, all I’ve done in the manifest
is register my activity with the launcher intent. And also I reference
a nav graph. But now let’s take a look at
the merged manifest, right? This is what we
compute on the fly when you build, and we
also compute it in the IDE, obviously. If you look at the
bottom here, we create intent filters
for you that are handling this deep link, right? So you just put that deep
link in your app file, and now your app will
respond to deep links. So that’s the Nav Editor,
which is new in 3.2. Let’s talk about the
Layout Editor for a bit. So as you can see, you get this
nice graphical view of the app. Well, the reason that works
is that we have a highly visual app here, right? So you can sort of see from
the outline what it looks like. Sometimes you’re not that lucky. But what really helps is you
can sample data to your app. We’ve had the plumbing for
sample data for quite a while, but in this release we made
it a lot easier to use. So first of all, I can go
over in the property sheet. And you can see next to the text
property we have this design time property. I’m going to bring
up the customizer. And here I can explore all
the different sample data types we have. So for this one, I’m going
to choose a full name. I can also select a widget
in the design surface. And if you look carefully,
whenever you select something, there are four buttons under it. Right? The fourth icon is a wrench. That means design
time attributes. So I can click on that, and
I can also set design time attributes from here. And the reason it’s important
to know about that trick is that it’s particularly
useful with lists. So let me open up a blank layout
and drag in a Recycler View. And that looks really
unimpressive, right? This is what you get
with the Recycler View. But now notice that
below the Recycler View we have our wrench again. So I’m going to press it. This is our design time helper. And for list views
and Recycler Views, we offer to customize the
item list layouts for you. So if I press next, I can
cycle through various list item layouts here. So we create one that looks
sort of email list like, one liners, two liners, three
liners, we even have a grid. So the design time
helpers should help you make your
layouts look better from the Nav Editor at least. The last thing I’ll mention
on the Layout Editor is that we also have some
support for material theming. So here’s a pretend composed
window in an email app. So we have the new chip widgets. We have the bottom
nav layout you can see with this
sort of rounded curve. And everything I’ve shown you
so far is in Android Studio 3.2. Now, I’m going to give
you a sneak preview of a feature for an upcoming
release– might not even be 3.3. So I’m going to open up
a new layout for that. And the problem
we’re trying to solve is making animation easier. So what I have
here is a subclass, I think, of constraint layout. It’s sort of next generation
constraint layout, which lets you do motion. So I can select my widget, and
it has two constraint sets. So in the beginning, it’s
attached to bottom left. At the end, it’s
attached top right. So I can play,
and you can see we can animate between these
two constraint sets. Let me actually go and
turn on motion paths so we can see what’s going on. So now we can see where
this thing is going to go. Now, the important part is I
can go in and add keyframes. So I’ll add a Cartesian
position keyframe, and I will– we can drag it over
here, for example. And I’ll add one more
keyframe to rotate. So we’ll set a random attribute. Actually, I want to
do it somewhere else so that it’s more obvious. So I’ll add a new
keyframe over here. So let’s see– new attributes. And I have to select it. And then we will say
rotation should be– yeah. 45 is a good default.
So you can see now, when I’m
dragging through, you can see we both rotate and
shift the x and y-coordinates. And the real power here is
when we start combining these. So here is a more
complicated animation demo. You can see here– let me make
the time line a bit bigger. Here we have a number
of things happening. So at the beginning, we
have a number of widgets. At the end, you can see we
moved the motion layout. We’ve faded out the
Google Cast icon, and we made the header smaller. So you can see as I’m
pulling through we get pretty fancy effects. And this library
also lets you respond to touch events, which makes
it a lot easier to use. So that’s Motion Layout. No promises on when
it will be done, but you know we’re
very excited about this and working hard on it. So now, thank you. So now, if we switch
to the other demo machine for a second? All right, so what
you’re looking at here is a Pixel Chromebook. And the really
exciting part for us is that if I click on
this button down here, you can see we have Android
Studio running on it. Yeah. So we have Layout Editor. We have Kotlin code, building
works, a lot of stuff works. But there’s a couple of
things that don’t work. So there’s no ADB yet. So you can’t run, deploy, debug. You know, some of you
don’t need to debug. You can upload straight
to the Play Store and hope for the best. Anyway, so I think at
this point you still need to sort of tinker and be
very comfortable with Linux, but it’s a very exciting
development I think. So you know, I look forward
to that getting done. And with that, I’m going
to turn it back to Jamal. JAMAL EASON: Yep. So that’s exciting? Good work, right? Exciting stuff. All right, so Tor touched
upon all the visual changes we’re making to Android Studio. I also want to spend
a little bit of time talking about some changes
to the build system that you might want to be aware
of inside of Android Studio 3.2. Now, the biggest
change you’ve made is supporting the Android App
Bundle, which you heard about earlier this afternoon. Now, you saw in Tor’s demo
we have a new little drop menu in the IDE where
you can create a bundle and sign a bundle. Now, if you want a
little bit more control, we actually added some
additional flags inside your build dot Gradle file. And so in this example you have
on the screen here, I have– slides? Do I have slides? Slides. Great, all right. All right, so for
example here, I’ve got a new bundle section in
your build dot Gradle file. And so for instance,
I have a split on density, screen
density, ABI, and language. So these are a
few flags that you can configure to have some
control of what’s actually inside your bundle. All right, so next is
AndroidX refactoring. So Tor gave you an example of
how it works inside the IDE. And again, what happens from the
build system’s perspective is that we will
convert your legacy, Maven dependencies, and convert
those to the new AndroidX namespace. We’ll cache those and use
those for subsequent builds. Now, again, if you want
a little bit more control of what happens to
your Gradle properties, we have a few things we added
to your Gradle properties file. And so in this example,
I have the enable dot enable Jetifier set to true. This is actually the
default behavior. And again, what that does is
it takes your legacy Maven artifacts and converts
those to the new AndroidX namespace and caches
those for new builds. Now, let’s say you have
a brand new project. Or perhaps you say, hey, look,
I have all my dependencies already converted to AndroidX. I don’t need this step. So in that case,
you could actually change this flag to false,
and we can skip this step. And what that would
do is actually enable you to have
faster build speeds than working with AndroidX. All right, lastly,
D8 and R8– so D8 is our new default Dexer
inside of Android Studio. We actually launched D8 last
year in Android Studio 3.0. We’ve been iterating on that,
and now it’s the default, and it’s the
replacement for Dex. R8 is new. It is a new optimizer
and shrinker inside the builds toolchain. And it’s a long term strategy
to replace Proguard with R8. So it might be exciting
for some folks. So again, to try it
out, all you have to do is go to your builder– sorry, your Gradle
properties file and go to enable R8, set to true. Again, this is
experimental, so we do not recommend you actually publish
out to the Play Store just yet. However, please give us
your feedback and let us know how it’s working
for you, and we’ll let you know when it becomes
stable inside of Android Studio. All right, so that was just
a few things to talk about in the Android build system. If you want an even
more in-depth session, we have a whole
session for tomorrow called What’s new with
the Android built system, presented by Jerome and Xav. I would also check
out Best practices when using compilers in Android
Studio, presented by Jefferey. We have a few more classes
as well on Android Studio. We have one more called
Improve app performance with Android Studio profilers,
presented by Esteban. That’s also this week. And lastly we have
a class on What’s new with Constraint Layout
and the Android Studio design tools, presented by Nicolas and
the Android Studio Engineering Design Tools team. All right, so
before we conclude, I want to talk about
one last topic. It’s about feedback
for Android Studio. As many of you know, we
release Android Studio on a series of release channels
ranging from Canary, Beta, and Stable. Now, Canary is our bleeding
edge release channel where we have most
of the new work, but a little bit of testing
before it goes out to you. And then at the
other end we have stable, which receives the most
amount of feedback and testing on our end before
it goes out to you. Now, you may say, hey, look,
I can’t rely on Canary. I need to tab my
production curve on Stable. If you didn’t know,
you can actually run Canary and Stable at the
same time in your app project. Now, I want to highlight
one important detail. It’s about feedback. So the thing is the earlier we
receive feedback on the Canary channel, the higher chance there
is actually for us to fix it. So the thing is once we reach
stable with Android Studio, it’s almost too late
for us to fix things. We’re only going to fix
very, very critical issues. Honestly, even if you wait
until the very end of the Betas, that’s almost too late as well. So we really encourage
you to download Android Studio on
the Canary channel and give feedback
sooner than later. All right, to recap– Android Studio has a
range of cool features across multiple flows
and development flow. From onboarding with
Android Jetpack, building your first
Android App Bundle, testing emulator snapshots,
and understanding the battery impact of your app
with the new Energy Profiler. In our course today, we
gave you a sneak peek of the new mushed editor,
and some cool tools around AR development, and
also some cool demos of promo as support for Android Studio. We hope you enjoy this
version of Android Studio as much as we do. All right, we want a little bit
of feedback on this session, so please go to
Google.com/IOschedule to give us some feedback. All right, that’s it. Again, I’m Jamal,
and this is Tor. Thank you for attending
our session on what’s new in Android Studio. [MUSIC PLAYING]

Only registered users can comment.

  1. Jetpack looks good. Seriously by now i think android development should have progressed from what is essentially 3 gen programming. Should be much more high level 4th gen with minimal scripting. The compiler/app builder should generate the low level java code.

  2. god damn, that animation tool, the "design time", and the navigation library looks so cool. I really wish animation tool was released long time ago, animation was a REAL pain in the ass.

  3. Im very excited to see the motion layout !!! Seriously Google that will help a lot.

    For people who dont know, you can use this cool plugin for aftereffect (https://aescripts.com/bodymovin/) that will help you export animation as json vectors, and this cool library to integrate the previous made animations into your projects (https://github.com/airbnb/lottie-web).

    Enjoy !

  4. Cool stuff , finally they invest in good tools ! But why so much excitement over chromebook support for android studio ? I thought the whole Idea of chromebooks is to be used for web browsing … If you need a full working laptop just by one….

  5. ปัญหาการใช้แอปและแอพดรอย รุ่นประจำ ปรับให้มีการพัฒนามากขึ้น

Leave a Reply

Your email address will not be published. Required fields are marked *