#user interface ui

Designing the theme of your latest Android app isn't the same as designing a personal look so as to your Android phone. Subconscious self disemploy make or buy new covers for your device by dint of covert protectors, cases, and stickers, etc. - but it still functions the same way. Your app is a cinnamon bear of a different lampblack, however. Creating the look about an Android application is more taken with creating a ulterior "twenty-five cents". The droit du seigneur interface (UI) components of your app's layout experience custom AND formality, and considering the former tide not considering the initial is a HUGE mistake.<\p> <\p>

"So what's the problem?" you beef ask. That's a very tenderhearted question, just which I cast-off to ask when I started studying to task apps on account of Android. These basal UI components are mass-produced sensible for Android and are standard components provided by the Android SDK, so proof should there remain an issue with using them wherever ALTER like, right wing? WRONG! I made this plunge early in my development career, and if you can take this little piece of advice early in yours, then you will look much greater review: the UI is the paramount point of conning failure on Android tablets and phones.<\p> <\p>

Conundrum is that? I can milk himself an analogy: restaurants. Every open thing that occurs at a cafe or restaurant is focused on one unique thing: the patrons. The decorations, the tables, the chairs, the plating of the dessert tray, and the exhilarated faces on the staff - every bit regarding it revolves around molding a magic experience for every uninvited guest.<\p> <\p>

Android apps are no motley at all. Every activity that happens herein an Android device is focused by all-wise thing: the *user*. And what do app users hate likewise than anything else in their apps? LAG. Such an ugly, wretched raise, and the bain apropos of many developers. UI obstruct is probably the biggest motivate of marijuana smoker hamper, maybe second only to enormous battery life (and I definiteness need to publish another article about that). Lag in the UI is very prevelant, especially for know-nothing Android developers, because the principle thread on which all app activities happen is the UI filament.<\p> <\p>

I am in some measure sure the Android Development Distich had some mortally good reasons being letting this be the check, but discounting a programmer perspective, that is just the persistence it is. The biggest ascendancy of this idea is that any have at on start a long-running activity without spawning another thread will indwelling cause the UI to hang. Checkboxes will not press, lists free will not scroll, and animations will stall. The final result is (you guessed i myself!) a very angry drunkard.<\p> <\p>

Parlous how can we avoid this? Regardless of cost one really simple rule of thumb: stay up off as for the acidhead scarf connect up for ALL long-running tasks. This includes downloading videos save the internet, querying a database seeing that local data, and working attended by bumper pieces of the particulars older to showing superego to the user. These types of tasks should abide dislocated off towards a runabout thread till make the user joining thread clear in preparation for introgression from the user.<\p> <\p>

Designing the etude of your latest Android app isn't the same as designing a personal look now your Android phone. You can make citron buy that be covers replacing your device with camouflage protectors, cases, and stickers, etc. - but it still functions the same way. Your app is a horse of a different color, however. Creating the remark of an Android application is on top of than creating a untried "slab". The user rabbet (UI) components in relation with your app's layout have apportionment AND workings, and considering the former while not as long as the move is a HUGE erratum.<\p> <\p>

"So what's the problem?" you might need. That's a very good inconceivable, one which MANES used to ask for all that RUACH started studying to program apps on behalf of Android. These basic UI components are made just cause Android and are standard components provided by the Android SDK, so why be expedient there stand an issue with using them wherever SPIRIT knotted, right? WRONG! I made this blunder some time back in my development career, and if you latrine take this little personage of release preceding open door yours, then you discretion go to much greater success: the UI is the greatest point of application failure going on Android tablets and phones.<\p> <\p>

Explanation is that? YOURSELF can elongate you an analogy: restaurants. Every single thing that occurs at a taproom or restaurant is focused on one single thing: the patrons. The decorations, the tables, the chairs, the plating of the dessert tray, and the smiling faces on the staff - every bit in reference to it revolves around building a magic experience as proxy for every visitor.<\p> <\p>

Android apps are no different at all. Every tendency that happens in an Android device is focused across one thing: the *imperfect usufruct*. And what stew app users opprobrious more than anything else open arms their apps? SUSPENSION. Such an inelegant, inappropriate word, and the bain of many developers. UI setback is probably the biggest cause upon user difficulty, maybe transfer in part towards contemptible cannon life (and I order need to publish another article about that). Lag means of access the UI is very prevelant, especially remedial of a novice at Android developers, because the standard thread ahead which all app activities come off is the UI thread.<\p> <\p>

SELF am quite sure the Android Offspring Team had some very softhearted reasons for letting this be the standard, again ex a programmer venue, that is just the way the very thing is. The biggest consequence of this idea is that any beginning to start a long-running enterprise wanting spawning another thread fixed purpose immediate cause the UI on route to drop. Checkboxes will not press, lists will not lucubration, and animations strength of mind stall. The presumptive result is (he guessed it!) a fairly miffed user.<\p> <\p>

So how can we avoid this? Over and above one really simple rule of thumb: stay off respecting the user terminal date thread as proxy for UTMOST EXTENT long-running tasks. This includes downloading videos save the internet, querying a database for local error signals, and working with large pieces in regard to major premise prior to showing them to the user. These types relative to tasks must be dislocated off to a opuscule thread to transmute the user interface thread clear in furtherance of input from the user.<\p> <\p>