1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.android.compatibility.common.util;
17 
18 import java.util.concurrent.Semaphore;
19 import java.util.concurrent.TimeUnit;
20 
21 import android.util.Log;
22 
23 import junit.framework.Assert;
24 
25 /**
26  * class for checking if rendering function is alive or not.
27  * panic if watch-dog is not reset over certain amount of time
28  */
29 public class WatchDog implements Runnable {
30     private static final String TAG = "WatchDog";
31     private Thread mThread;
32     private Semaphore mSemaphore;
33     private volatile boolean mStopRequested;
34     private final long mTimeoutInMilliSecs;
35     private TimeoutCallback mCallback = null;
36 
WatchDog(long timeoutInMilliSecs)37     public WatchDog(long timeoutInMilliSecs) {
38         mTimeoutInMilliSecs = timeoutInMilliSecs;
39     }
40 
WatchDog(long timeoutInMilliSecs, TimeoutCallback callback)41     public WatchDog(long timeoutInMilliSecs, TimeoutCallback callback) {
42         this(timeoutInMilliSecs);
43         mCallback = callback;
44     }
45 
46     /** start watch-dog */
start()47     public void start() {
48         Log.i(TAG, "start");
49         mStopRequested = false;
50         mSemaphore = new Semaphore(0);
51         mThread = new Thread(this);
52         mThread.start();
53     }
54 
55     /** stop watch-dog */
stop()56     public void stop() {
57         Log.i(TAG, "stop");
58         if (mThread == null) {
59             return; // already finished
60         }
61         mStopRequested = true;
62         mSemaphore.release();
63         try {
64             mThread.join();
65         } catch (InterruptedException e) {
66             // ignore
67         }
68         mThread = null;
69         mSemaphore = null;
70     }
71 
72     /** resets watch-dog, thus prevent it from panic */
reset()73     public void reset() {
74         if (!mStopRequested) { // stop requested, but rendering still on-going
75             mSemaphore.release();
76         }
77     }
78 
79     @Override
run()80     public void run() {
81         while (!mStopRequested) {
82             try {
83                 boolean success = mSemaphore.tryAcquire(mTimeoutInMilliSecs, TimeUnit.MILLISECONDS);
84                 if (mCallback == null) {
85                     Assert.assertTrue("Watchdog timed-out", success);
86                 } else if (!success) {
87                     mCallback.onTimeout();
88                 }
89             } catch (InterruptedException e) {
90                 // this thread will not be interrupted,
91                 // but if it happens, just check the exit condition.
92             }
93         }
94     }
95 
96     /**
97      * Called by the Watchdog when it has timed out.
98      */
99     public interface TimeoutCallback {
100 
onTimeout()101         public void onTimeout();
102     }
103 }
104