Path: csiph.com!x330-a1.tempe.blueboxinc.net!usenet.pasdenom.info!news.albasani.net!fu-berlin.de!uni-berlin.de!individual.net!not-for-mail
From: Dirk Bruere at NeoPax <dirk.bruere@gmail.com>
Newsgroups: comp.lang.java.programmer
Subject: Re: Threads and UI in Android
Date: Mon, 04 Apr 2011 06:23:14 +0100
Organization: Dirk Bruere at Neopax
Lines: 76
Message-ID: <8vt2tjFcvhU1@mid.individual.net>
References: <8vrrsdF6urU1@mid.individual.net> <8vs005F5tmU1@mid.individual.net> <inark9$gr4$7@lust.ihug.co.nz> <inb4mo$2br$1@dont-email.me>
Reply-To: dirk.bruere@gmail.com
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
X-Trace: individual.net OLkxZQ3Burl9jQkndlvjCwJhz4j3Tm9tEB45S1exjA50HKdnV9
Cancel-Lock: sha1:+aDs/8XHWIzcZGxjxD3A/KBZihs=
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2.15) Gecko/20110303 Thunderbird/3.1.9
In-Reply-To: <inb4mo$2br$1@dont-email.me>
Xref: x330-a1.tempe.blueboxinc.net comp.lang.java.programmer:2833

On 04/04/2011 01:51, markspace wrote:
> On 4/3/2011 3:16 PM, Lawrence D'Oliveiro wrote:
>> In message<8vs005F5tmU1@mid.individual.net>, Dirk Bruere at NeoPax wrote:
>>
>>> It would seem the answer is in here somewhere
>>> http://developer.android.com/resources/articles/painless-threading.html
>>
>> Seems like AsyncTask is the way to go: it automatically divides up
>> execution
>> between a background thread and the UI thread, and takes care of all the
>> synchronization between the two for you.
>>
>> How much more painless can you get? :)
>
>
>
> Given that the OP want's to "constantly [check] for messages" I think
> the way he's doing it now is fine. runOnUiThread() does the
> synchronization that he needs, and it seems cleaner than trying to wrap
> his deamon in an AsyncTask object and constantly call publishProgress()
> whenever he gets a packet.
>
> Modern threading is getting sophisticated, and one sophisticated thing
> to do is to limit the number of threads so as to not overwhelm the OS.
> Limited thread pools are used for this purpose. I don't know how
> AsynchTask is implemented, but if it uses a thread pool, you could
> easily starve your own app of threads for AsynchTask by permanently
> capturing too many AsynchTask threads, which is what the OP's task would
> do.
>
> "Long running" tasks relative to the UI response time go in AsynchTask.
> "Really long running" tasks, or permanent tasks like the OP's little
> network daemon, go in their own private thread. Seems safest that way.
>

Currently I have this:

public class BlinkDataThread extends Thread
{
	int length = Constants.PACKET_LENGTH;
     byte[] receiveBuffer = new byte[length];
     DatagramSocket socket;
     DatagramPacket packet;

     public void run()
     {
         try
         {
         	DatagramSocket ds = new DatagramSocket(Constants.LOCAL_PORT);
	        DatagramPacket incoming = new DatagramPacket(receiveBuffer, 
receiveBuffer.length);
	        incoming.setLength(length);
	    	String packetStr=new String(receiveBuffer, "UTF-8");
     	
	        while(true)	//Run this as an endless loop
	        {
	        	ds.setReceiveBufferSize(receiveBuffer.length);
     	        ds.receive(incoming);
     	        packetStr = new String(receiveBuffer, 0, 
incoming.getLength(), "UTF-8");
     			if (packetStr != null) BlinkAPI.updateIncomingData(packetStr);
	        }
		} catch (IOException e1) {}
     }
	
}

Where linkAPI.updateIncomingData(packetStr); is the offending bit since 
it triggers updates on the UI thread.

That would be where I use runOnUiThread()?

-- 
Dirk

http://www.neopax.com/technomage/ - My new book - Magick and Technology