When the app is running, and you do an instant run from Android Studio, it will try doing the hot swap. The app crashes and immediately relaunches (and it's the same build). All the while Android Studio is monitoring the app task and waiting for the hot swap to take place. It keeps checking, times out after a few seconds (realizing it didn't update successfully), and then it deploys and launches the new APK, as a last resort.
My point is to be careful when testing if you're getting the double launches, because the first time it is launched, it's still the old APK.
I've actually ended up writing a lot of platform specific code as I found the cross-platform stuff to be kind of janky. But it basically lets me write an iOS app, using iOS APIs (and even iOS sample code, if I apply myself)... in JavaScript. It's not bad at all.
Yup I think I'll stay as far away from that as possible! Sounds like a recipe for a 10 hour debugging binge. I think managed APIs are pretty essential when doing interop.
https://www.youtube.com/watch?feature=player_detailpage&v=YY... (lifestream timestamp is probably inaccurate)
It's the second speaker, a woman right after the man that comes first.
It works well most of the time. Sometimes it can cause some nasty crashes. I guess it's expected since you can't just replace some object instances and expect it to work.
The settings does have an option to also restart the current activity when it does the hot swapping. I guess it's to account for those cases when hot swapping doesn't work as expected.
I've generally found with this feature in various IDEs that it's good for changing a constant in some drawing code but not really much else, and then it just turns into frustration as you get constant popups reminding you it won't apply some change live. I think the problem is that in the timeframe companies like Google and Microsoft allocate for such a feature, it's extremely difficult to produce something that works 99% of the time. If we could get there (and improve step backwards functionality, as well) we would probably just abandon the divide between programming and debugging mode in IDEs and always have an updated copy running (or mostly, paused) alongside ready to context-switch into.
This could be awesome, if it works as advertised.