1 @Override
2 public void onCreate() {
3 // TODO: It would be nice to have an option to hold a partial wakelock
4 // during processing, and to have a static startService(Context, Intent)
5 // method that would launch the service & hand off a wakelock.
6
7 super.onCreate();
8 HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
9 thread.start();
10
11 mServiceLooper = thread.getLooper();
12 mServiceHandler = new ServiceHandler(mServiceLooper);
13 }
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
}
1 protected abstract void onHandleIntent(Intent intent);
1 public class HandlerThread extends Thread {
2 private int mPriority;
3 private int mTid = -1;
4 private Looper mLooper;
5
6 public HandlerThread(String name) {
7 super(name);
8 mPriority = Process.THREAD_PRIORITY_DEFAULT;
9 }
10
11 /**
12 * Constructs a HandlerThread.
13 * @param name
14 * @param priority The priority to run the thread at. The value supplied must be from
15 * {@link android.os.Process} and not from java.lang.Thread.
16 */
17 public HandlerThread(String name, int priority) {
18 super(name);
19 mPriority = priority;
20 }
21
22 /**
23 * Call back method that can be explicitly over ridden if needed to execute some
24 * setup before Looper loops.
25 */
26 protected void onLooperPrepared() {
27 }
28
29 public void run() {
30 mTid = Process.myTid();
31 Looper.prepare();
32 synchronized (this) {
33 mLooper = Looper.myLooper();
34 notifyAll();
35 }
36 Process.setThreadPriority(mPriority);
37 onLooperPrepared();
38 Looper.loop();
39 mTid = -1;
40 }
41
42 /**
43 * This method returns the Looper associated with this thread. If this thread not been started
44 * or for any reason is isAlive() returns false, this method will return null. If this thread
45 * has been started, this method will block until the looper has been initialized.
46 * @return The looper.
47 */
48 public Looper getLooper() {
49 if (!isAlive()) {
50 return null;
51 }
52
53 // If the thread has been started, wait until the looper has been created.
54 synchronized (this) {
55 while (isAlive() && mLooper == null) {
56 try {
57 wait();
58 } catch (InterruptedException e) {
59 }
60 }
61 }
62 return mLooper;
63 }
64
65 /**
66 * Ask the currently running looper to quit. If the thread has not
67 * been started or has finished (that is if {@link #getLooper} returns
68 * null), then false is returned. Otherwise the looper is asked to
69 * quit and true is returned.
70 */
71 public boolean quit() {
72 Looper looper = getLooper();
73 if (looper != null) {
74 looper.quit();
75 return true;
76 }
77 return false;
78 }
79
80 /**
81 * Returns the identifier of this thread. See Process.myTid().
82 */
83 public int getThreadId() {
84 return mTid;
85 }
86 }
HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，它有个Looper成员变量。这个Looper其实就是对消息队列以及队列处理逻辑的封装