如何在Android中从单独的文件中的线程实现处理程序

我想知道如何在android中使用处理程序从单独的线程发送两条消息来更新UI。该线程在另一个文件中声明。我明白使用java线程在Android中不可取，但我放弃使用android方法，它们很糟糕。处理程序消息每隔200毫秒从我声明的线程发送。我找不到一个体面的例子来说明如何实施它。如何在Android中从单独的文件中的线程实现处理程序

这是我的扩展线程。这是从活动中调用的。

import java.io.IOException; 

import android.media.MediaPlayer; 
import android.os.Bundle; 
import android.os.Message; 

public class MPlayer extends Thread { 
    private volatile boolean playing = false; 
    private volatile boolean finished = false; 
    MediaPlayer player; 
    Message msg; 
    Bundle bundle; 
    String filepath; 

    /* other fields, constructor etc. */ 
    public MPlayer(String path) { 
     filepath = path; 
     player = new MediaPlayer(); 
     bundle = new Bundle(); 
     msg = new Message(); 
     start(); 
    } 

    public void seekMPlayer(int i) { 
     // TODO Auto-generated method stub 
     player.seekTo(i); 
    } 

    public boolean getPlaying() { 
     // TODO Auto-generated method stub 
     return playing; 
    } 

    @Override 
    public void run() { 
     try { 
      player.setDataSource(filepath); 
      player.prepare(); 
     } catch (IllegalArgumentException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IllegalStateException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     while (!finished) { 
      while (playing && !finished) { 
       try { 
        Thread.sleep(200); 
        if (playing && !finished) { 
         bundle.putString("progval", songTime()); 
         // msg.setData(bundle); 
         // threadHandler.sendMessage(msg); 
        } else 
         break; 
       } catch (InterruptedException e) { 

       } 
      } 
     } 

    } 

    public synchronized void pauseMPlayer() { 
     playing = false; 
     player.pause(); 

    } 

    public synchronized void PlayMPlayer() { 
     playing = true; 
     player.start(); 
     // call notify() here when you switch to wait/notify. 
    } 

    public void stopMPlayer() { 
     playing = false; 
     finished = true; 
     player.release(); 
     // call notify() here too. 
    } 

    private String songTime() { 
     // TODO Auto-generated method stub 
     if (filepath != null) { 
      int progressseconds = (int) ((player.getCurrentPosition()/1000) % 60); 
      int progressminutes = (int) ((player.getCurrentPosition()/1000)/60); 
      int durationseconds = (int) ((player.getDuration()/1000) % 60); 
      int durationminutes = (int) ((player.getDuration()/1000)/60); 
      String progmin, progsec, durmin, dursec; 
      if (progressminutes >= 10) 
       progmin = Integer.toString(progressminutes); 
      else 
       progmin = "0" + Integer.toString(progressminutes); 
      if (progressseconds >= 10) 
       progsec = Integer.toString(progressseconds); 
      else 
       progsec = "0" + Integer.toString(progressseconds); 
      if (durationminutes >= 10) 
       durmin = Integer.toString(durationminutes); 
      else 
       durmin = "0" + Integer.toString(durationminutes); 
      if (durationseconds >= 10) 
       dursec = Integer.toString(durationseconds); 
      else 
       dursec = "0" + Integer.toString(durationseconds); 
      return (progmin + ":" + progsec + "/" + durmin + ":" + dursec); 
     } else { 
      return ("No File!"); 
     } 
    } 
}

来源

2011-12-16 NJGUY

处理程序应该绑定线程的Looper。使用此构造函数来指定线程的Looper

Handler handler = new Handler(Looper.getMainLooper());

而现在，您可以发送消息给主线程

来源

2011-12-16 02:59:18

没有什么错在使用Android的Java线程，但它是一个有点矫枉过正，只是用它用于发送周期性消息。推荐的方法是使用Handler.postDelayed。本文提出以下方法：将所有更新代码放入Runnable，并将postDelayed调用添加到此Runnable的run()的末尾以再次调度。这种方法消除了后台线程的开销。

但是，使用Handler可以很容易地从其他线程发送消息。据我所知，你正试图发送消息到一些UI组件，以便它可以自我更新。在我的应用程序中，我遇到了类似的问题。我在UI组件中声明了一个处理程序，并将该处理程序传递给构造函数参数中的后台线程。

UI部分看起来像：

class MyActivity extends Activity { 
    Handler mHandler = new Handler() { 
     public void handleMessage(Message msg) { 
      // update UI according to a content of msg from background thread 
      // ... 
     } 
    }; 

    private Thread mBackgroundWorker = new BackgroundThread(mHandler); 

    protected void onCreate(Bundle savedInstanceState) { 
     // ... 
     mBackgroundWorker.start(); 
     // ... 
    } 

    protected void onDestroy() { 
     // we created the thread in this activity 
     // so we should manage its lifecycle here 
     mBackgroundWorker.interrupt(); 
    } 
}

而后台线程像

class BackgroundThread extends Thread { 

    private final mHandler; 

    public BackgroundThread(Handler h) { 
     mHandler = h; 
    } 


    public void run() { 
     // do some processing... 
     mHandler.sendMessage(/*some message to update an UI*/); 
     // ... 
    } 
}

实施

来源

2011-12-16 09:21:16

如何在Android中从单独的文件中的线程实现处理程序

回答

相关问题