如何在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!");
}
}
}
答
处理程序应该绑定线程的Looper。使用此构造函数来指定线程的Looper
Handler handler = new Handler(Looper.getMainLooper());
而现在,您可以发送消息给主线程
答
没有什么错在使用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*/);
// ...
}
}
实施