A few weeks ago ztomi had a tutorial about ADB wireless. You propably already have your favourite way of rooting your phone (superoneclick etc), but what if you don't want or can't use the usb port of your phone?
When you run a background operation using a Thread, or AsyncTask in most of the times it is needed to be able to interrupt it.
In lot of cases, when the user starts a sceen in our application, a thread is started in the background, to load its content. Hoever if the user leaves the screen before its loading is complete, the loading process should be interrupted. Even if the loading prosess can not be interrupted immediately, or it would be too mutch troube, it shold detect that the display of the result is no longer needed.
So how do you stop a thread exactly? You can see in the documentation that Thread class has a stop() method. This method offered an "easy" way to interrupt threads in older android versions, by killing the thread. It is deprecated now, do not use it, it may left things in inconstent state, among other problems, so this was an unelegant way.
In android it is highly important to use transactions when working with databases.
First, in android database operations - especially writing - are very slow. Batching them into transactions will make them much faster.
Second, the database remains consistent under any circumstances. The database system makes sure to all the operations in a transaction take effect, or on error, rollback all of them.
If you are used to other platforms like PHP+MySQL where the code usually runs on a powerful server, witch is not likely to stop execution "unexpectedly", you can be surprised how much it affects the performance in android.
The android system can kill apps/threads/activities and so interrupt database usage, the battery can discharge or can be removed etc.
The implementation is very simple, using 3 methods in the SQLiteDatabase class:
Sometimes you don't want to store any data on the sd card, but you have to, because your apps resources would take up too much space int the internal memory.
Here is a method on how to store your data securely.
Today I'm going to show an easy way to add divider items to your ListView.
First off, you need your own ListView Adapter which extends SimpleAdapter. If you don't know how to create a new class for your own SimpleAdapter, please go and visit: http://developer.android.com/resources/samples/ApiDemos/src/com/example/...
Previously I wrote about, that slow operations must be runned in threads. Now I would like to present some example code, how to use threads in Android.
Under the android system an user interface element can only be accessed from the thread that created it (the main UI thread). Thats where handlers and messages come in.
The user interface defines a handler like below:
Handler handler =new Handler(){
@Override
publicvoid handleMessage(Message msg){
int arg1=msg.arg1;
int arg2=msg.arg2;
MyClass myObject=(MyClass)msg.obj;
//do something in the user interface to display data from message
}
}
Then the thread, which can not touch the user interface, sends a message to this handler instead.
The following example code, that implements file downloading from net, represents how I usually use the threads:
If you got sick and tired of the default style/behavior of the title bar in your apps, or just need something different, than here is a little snippet for You.
First of all, define what do we mean under "speed": in one hand its the time that the code needs to execute, on the other hand its the time the user needs to wait for the user interface. The two things can greatly differ, of course you must optimize the code performance, but the most important is what the user sees from it. Don't make the user wait, unless its necessary.
Do not pull back the ui thread
The very basic principle is to never run slow operations on the user interface thread! If you do this the interface will freeze until the operation is executed, which is not a nice user experience. If the execution takes too long the android system will detect it and offer the opportunity to the user to force close the frozen application:
One of the strange things with android is that there is no "the user has closed the application" event. Applications activities often just go to the background, and the android system may kill them whenever it wants, even when another activity of the application is still running in the foreground.
You can not be sure that activities you started and sent to the background are sill there storing their state, and if you are just an android user, you can not be sure that applications that you left simply by pressing back button are completely destroyed.
To make it more complex, using intents it is even possible to start an activity of another application.
For unit testing you can use the built in JUnit framework just like in "standard" java applications.
A unit test is to test some low-level part - usually a single class - of a project, working individually.
The only trick is to extend AndroidTestCase in your test case instead of TestCase some Android specific methods, like getContext() which is often required by android functions.
Lets see a very simple example using eclipse:
- Create a new project to test, create a new class in it, with a simple method that , like this:
publicclass ClassToTest{
publicint add(int arg1,int arg2){
return arg1+arg2;
}
}
- Create a new test project: File/new/Other.../Android/Android Test Project
Add the previously created project as the test target, the other fields can be left as they are auto filled.
When you run a background operation using a Thread, or AsyncTask in most of the times it is needed to be able to interrupt it.
