Well, one of the difficulties of Android development is one of Android's strong points as a user - multiple device configurations. If Android were like iPhones (x models, each with precise specs), life would be much easier - you wouldn't need all the LayoutManagers - everything can be written with precise pixel specs (although you'd have to upgrade your code when a new model comes out).
My biggest gripe is more to do with the language. It's somewhat surprising how a company which can invent a simple language like Go created a monstrosity like the Android API, and while I understand that in the first couple releases they had no choice and no experience, I would have expected them to rethink their API model in post-lollipop.
My personal gripes:
1. Lifecycle management - how many entry points are there into your app?
There should be an entry point (app started) and one exit (app ended). And don't get me started on Fragments.
2. Callbacks - Why Why Why WHY?! I understand that closures are a new feature and were not available for most of Android's cycle, but inner classes are so ugly, I'd rather write it manually (using a single on-event function with a switch/case on events firing) than use inner classes.
3. Not fully OO. Why can't I pass object around? Why only strings?
4. File/Stream dichotomy - Some things are done by file, others by stream.
5. Library - Practically, almost all modern "Native looking apps" (meaning, not Q or OpenGL based) rely on appcompat, and will always require appcompat (Google recommends using AppCompat even if you're not targeting old phones, since they fix bugs in AppCompat which they can't in Android). So why make a "native" library? Keep the basic "native" library small and keep the code in appcompat?
My biggest gripe is more to do with the language. It's somewhat surprising how a company which can invent a simple language like Go created a monstrosity like the Android API, and while I understand that in the first couple releases they had no choice and no experience, I would have expected them to rethink their API model in post-lollipop.
My personal gripes:
1. Lifecycle management - how many entry points are there into your app?
There should be an entry point (app started) and one exit (app ended). And don't get me started on Fragments.
2. Callbacks - Why Why Why WHY?! I understand that closures are a new feature and were not available for most of Android's cycle, but inner classes are so ugly, I'd rather write it manually (using a single on-event function with a switch/case on events firing) than use inner classes.
3. Not fully OO. Why can't I pass object around? Why only strings?
4. File/Stream dichotomy - Some things are done by file, others by stream.
5. Library - Practically, almost all modern "Native looking apps" (meaning, not Q or OpenGL based) rely on appcompat, and will always require appcompat (Google recommends using AppCompat even if you're not targeting old phones, since they fix bugs in AppCompat which they can't in Android). So why make a "native" library? Keep the basic "native" library small and keep the code in appcompat?