android.os.HandlerThread

Here are the examples of the java api class android.os.HandlerThread taken from open source projects.

1. OperationsService#onCreate()

Project: MyRepository-master
File: OperationsService.java
/**
     * Service initialization
     */
@Override
public void onCreate() {
    super.onCreate();
    Log_OC.d(TAG, "Creating service");
    /// First worker thread for most of operations 
    HandlerThread thread = new HandlerThread("Operations thread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mOperationsHandler = new ServiceHandler(thread.getLooper(), this);
    mOperationsBinder = new OperationsServiceBinder(mOperationsHandler);
    /// Separated worker thread for download of folders (WIP)
    thread = new HandlerThread("Syncfolder thread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mSyncFolderHandler = new SyncFolderHandler(thread.getLooper(), this);
}

2. OperationsService#onCreate()

Project: android
File: OperationsService.java
/**
     * Service initialization
     */
@Override
public void onCreate() {
    super.onCreate();
    Log_OC.d(TAG, "Creating service");
    /// First worker thread for most of operations 
    HandlerThread thread = new HandlerThread("Operations thread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mOperationsHandler = new ServiceHandler(thread.getLooper(), this);
    mOperationsBinder = new OperationsServiceBinder(mOperationsHandler);
    /// Separated worker thread for download of folders (WIP)
    thread = new HandlerThread("Syncfolder thread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mSyncFolderHandler = new SyncFolderHandler(thread.getLooper(), this);
}

3. LocalyticsSession#getHandlerThread()

Project: astrid
File: LocalyticsSession.java
/**
     * Helper to obtain a new {@link HandlerThread}.
     *
     * @param name to give to the HandlerThread. Useful for debugging, as the thread name is shown in DDMS.
     * @return HandlerThread whose {@link HandlerThread#start()} method has already been called.
     */
private static HandlerThread getHandlerThread(final String name) {
    final HandlerThread thread = new HandlerThread(name, android.os.Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    /*
         * The exception handler needs to be set after start() is called. If it is set before, sometime's the HandlerThread's
         * looper is null. This appears to be a bug in Android.
         */
    thread.setUncaughtExceptionHandler(new ExceptionHandler());
    return thread;
}

4. RelayService#onCreate()

Project: weechat-android
File: RelayService.java
////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////// status & life cycle
////////////////////////////////////////////////////////////////////////////////////////////////
@Override
public void onCreate() {
    if (DEBUG)
        logger.debug("onCreate()");
    super.onCreate();
    // prepare handler that will run on a separate thread
    HandlerThread handlerThread = new HandlerThread("doge");
    handlerThread.start();
    thandler = new Handler(handlerThread.getLooper());
    connectivity = new Connectivity();
    connectivity.register(this);
    ping = new PingActionReceiver(this);
    EventBus.getDefault().register(this);
}

5. PlaybackActivity#onCreate()

Project: vanilla
File: PlaybackActivity.java
@Override
public void onCreate(Bundle state) {
    super.onCreate(state);
    PlaybackService.addTimelineCallback(this);
    setVolumeControlStream(AudioManager.STREAM_MUSIC);
    HandlerThread thread = new HandlerThread(getClass().getName(), Process.THREAD_PRIORITY_LOWEST);
    thread.start();
    mLooper = thread.getLooper();
    mHandler = new Handler(mLooper, this);
}

6. PlaybackService#initMediaSession()

Project: tomahawk-android
File: PlaybackService.java
private void initMediaSession() {
    ComponentName componentName = new ComponentName(this, MediaButtonReceiver.class);
    mMediaSession = new MediaSessionCompat(getApplicationContext(), "Tomahawk", componentName, null);
    mMediaSession.setFlags(MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS | MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS);
    Intent intent = new Intent(PlaybackService.this, TomahawkMainActivity.class);
    intent.setAction(TomahawkMainActivity.SHOW_PLAYBACKFRAGMENT_ON_STARTUP);
    intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
    PendingIntent pendingIntent = PendingIntent.getActivity(PlaybackService.this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    mMediaSession.setSessionActivity(pendingIntent);
    HandlerThread thread = new HandlerThread("playbackservice_callback");
    thread.start();
    mCallbackHandler = new Handler(thread.getLooper());
    mMediaSession.setCallback(mMediaSessionCallback, mCallbackHandler);
    mMediaSession.setRatingType(RatingCompat.RATING_HEART);
    Bundle extras = new Bundle();
    extras.putString(EXTRAS_KEY_PLAYBACKMANAGER, mPlaybackManager.getId());
    mMediaSession.setExtras(extras);
    updateMediaPlayState();
    setSessionToken(mMediaSession.getSessionToken());
}

7. ReplicationService#onCreate()

Project: sync-android
File: ReplicationService.java
@Override
public void onCreate() {
    super.onCreate();
    WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
    if (wifiManager != null) {
        mWifiLock = wifiManager.createWifiLock(WifiManager.WIFI_MODE_FULL_HIGH_PERF, "ReplicationService");
    }
    // Create a background priority thread to so we don't block the process's main thread.
    HandlerThread thread = new HandlerThread("ServiceStartArguments", android.os.Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    // Get the HandlerThread's Looper and use it for our Handler.
    Looper serviceLooper = thread.getLooper();
    mServiceHandler = getHandler(serviceLooper);
}

8. SmsReceiverService#onCreate()

Project: SMSSync
File: SmsReceiverService.java
@Override
public void onCreate() {
    super.onCreate();
    injector();
    HandlerThread thread = new HandlerThread(CLASS_TAG, Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mContext = getApplicationContext();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(this, mServiceLooper);
    App.bus.register(this);
}

9. TransactionService#onCreate()

Project: qksms
File: TransactionService.java
@Override
public void onCreate() {
    if (LOCAL_LOGV)
        Log.v(TAG, "Creating TransactionService");
    // Start up the thread running the service.  Note that we create a
    // separate thread because the service normally runs in the process's
    // main thread, which we don't want to block.
    HandlerThread thread = new HandlerThread("TransactionService");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
    mReceiver = new ConnectivityBroadcastReceiver();
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    registerReceiver(mReceiver, intentFilter);
}

10. OrgSyncService#onCreate()

Project: NotePad
File: OrgSyncService.java
@Override
public void onCreate() {
    // Start up the thread running the service. Note that we create a
    // separate thread because the service normally runs in the process's
    // main thread, which we don't want to block. We also make it
    // background priority so CPU-intensive work will not disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    // Get the HandlerThread's Looper and use it for our Handler
    serviceLooper = thread.getLooper();
    serviceHandler = new SyncHandler(serviceLooper);
}

11. AppService#backGroundInit()

Project: NBAPlus
File: AppService.java
private void backGroundInit() {
    HandlerThread ioThread = new HandlerThread("IoThread");
    ioThread.start();
    mIoHandler = new Handler(ioThread.getLooper());
    mIoHandler.post(new Runnable() {

        @Override
        public void run() {
            sNbaplusApi = NbaplusFactory.getNbaplusInstance();
            sNewsDetileApi = NbaplusFactory.getNewsDetileInstance();
            sDBHelper = DBHelper.getInstance(App.getContext());
        }
    });
//  ThreadExecutor is not necessary currently
//        sSingleThreadExecutor.execute(new Runnable() {
//            @Override
//            public void run() {
//                sNbaplus = NbaplusFactory.getNbaplus();
//                sNewsDetileApi = NbaplusFactory.getNewsDetileInstance();
//                sDBHelper = DBHelper.getInstance(App.getContext());
//            }
//        });
}

12. NotificationUtils#cancelWithDelay()

Project: MyRepository-master
File: NotificationUtils.java
public static void cancelWithDelay(final NotificationManager notificationManager, final int notificationId, long delayInMillis) {
    HandlerThread thread = new HandlerThread("NotificationDelayerThread_" + (new Random(System.currentTimeMillis())).nextInt(), Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    Handler handler = new Handler(thread.getLooper());
    handler.postDelayed(new Runnable() {

        public void run() {
            notificationManager.cancel(notificationId);
            ((HandlerThread) Thread.currentThread()).getLooper().quit();
        }
    }, delayInMillis);
}

13. FileUploader#onCreate()

Project: MyRepository-master
File: FileUploader.java
/**
     * Service initialization
     */
@Override
public void onCreate() {
    super.onCreate();
    Log_OC.d(TAG, "Creating service");
    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    HandlerThread thread = new HandlerThread("FileUploaderThread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper, this);
    mBinder = new FileUploaderBinder();
    mUploadsStorageManager = new UploadsStorageManager(getContentResolver());
    int failedCounter = mUploadsStorageManager.failInProgressUploads(// Add UploadResult.KILLED?
    UploadResult.SERVICE_INTERRUPTED);
    if (failedCounter > 0) {
        resurrection();
    }
    // add AccountsUpdatedListener
    AccountManager am = AccountManager.get(getApplicationContext());
    am.addOnAccountsUpdatedListener(this, null, false);
}

14. FileDownloader#onCreate()

Project: MyRepository-master
File: FileDownloader.java
/**
     * Service initialization
     */
@Override
public void onCreate() {
    super.onCreate();
    Log_OC.d(TAG, "Creating service");
    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    HandlerThread thread = new HandlerThread("FileDownloaderThread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper, this);
    mBinder = new FileDownloaderBinder();
    // add AccountsUpdatedListener
    AccountManager am = AccountManager.get(getApplicationContext());
    am.addOnAccountsUpdatedListener(this, null, false);
}

15. MuzeiArtSource#onCreate()

Project: muzei
File: MuzeiArtSource.java
@Override
public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
    mSharedPrefs = getSharedPreferences();
    loadSubscriptions();
    loadState();
}

16. AbstractUploaderService#onCreate()

Project: mobile-android
File: AbstractUploaderService.java
@Override
public void onCreate() {
    super.onCreate();
    mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    HandlerThread thread = new HandlerThread(TAG);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper, this);
    mApi = CommonConfigurationUtils.getApi();
    setUpConnectivityWatcher();
    CommonUtils.debug(TAG, "Service created");
    mUploadRemovedReceiver = UploaderServiceUtils.getAndRegisterOnPhotoUploadRemovedActionBroadcastReceiver(TAG, this, this);
}

17. FileDownloader#createSerialHandler()

Project: FileDownloader
File: FileDownloader.java
private static Handler createSerialHandler(final List<BaseDownloadTask> serialTasks) {
    Assert.assertTrue("create serial handler list must not empty", serialTasks != null && serialTasks.size() > 0);
    final HandlerThread serialThread = new HandlerThread(FileDownloadUtils.formatString("filedownloader serial thread %s", serialTasks.get(0).getListener()));
    serialThread.start();
    final SerialHandlerCallback callback = new SerialHandlerCallback();
    final Handler serialHandler = new Handler(serialThread.getLooper(), callback);
    callback.setHandler(serialHandler);
    callback.setList(serialTasks);
    return serialHandler;
}

18. DashClockExtension#onCreate()

Project: dashclock
File: DashClockExtension.java
@Override
public void onCreate() {
    super.onCreate();
    loadMetaData();
    HandlerThread thread = new HandlerThread("DashClockExtension:" + getClass().getSimpleName());
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new Handler(mServiceLooper);
}

19. DarshakService#onCreate()

Project: darshak
File: DarshakService.java
/**
	 * Initialize the Thread handler.
	 */
@Override
public void onCreate() {
    Log.d(LOG_TAG, "onCreate of DarshakService is called.");
    // Initialize the thread handler.
    HandlerThread thread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    // Looper which keeps tracks of the the messages and the runnable added.
    Looper mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
    // Set the intent to be triggered when clicked on notification,
    sNotificationIntent = new Intent(getApplicationContext(), AirplaneModeConfigureActivity.class);
    sContentIntent = PendingIntent.getActivity(getApplicationContext(), 0, sNotificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK);
    sDBHelper = ((Application) getApplication()).getDBHelper();
    sPacketReader = new PacketReader(getApplicationContext(), sDBHelper);
}

20. ServiceStartArguments#onCreate()

Project: codeexamples-android
File: ServiceStartArguments.java
@Override
public void onCreate() {
    mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    Toast.makeText(this, R.string.service_created, Toast.LENGTH_SHORT).show();
    // This is who should be launched if the user selects our persistent
    // notification.
    mInvokeIntent = new Intent(this, Controller.class);
    // Start up the thread running the service.  Note that we create a
    // separate thread because the service normally runs in the process's
    // main thread, which we don't want to block.  We also make it
    // background priority so CPU-intensive work will not disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

21. ScheduleService#onCreate()

Project: CallerInfo
File: ScheduleService.java
@Override
public void onCreate() {
    super.onCreate();
    Log.d(TAG, "onCreate");
    HandlerThread handlerThread = new HandlerThread(TAG);
    handlerThread.start();
    mThreadHandler = new Handler(handlerThread.getLooper());
    mMainHandler = new Handler(getMainLooper());
    mDatabase = DatabaseImpl.getInstance();
    mSetting = SettingImpl.getInstance();
    mPutList = Collections.synchronizedList(new ArrayList<String>());
    mThreadHandler.post(new Runnable() {

        @Override
        public void run() {
            mPhoneNumber = PhoneNumber.getInstance();
            mPhoneNumber.addCloudListener(ScheduleService.this);
        }
    });
}

22. BeaconService#onCreate()

Project: beacon-keeper
File: BeaconService.java
@Override
public void onCreate() {
    super.onCreate();
    HandlerThread ht = new HandlerThread("HandlerThread [" + BeaconService.class.getSimpleName() + "]");
    ht.start();
    mRunningTimeDebug = System.currentTimeMillis();
    mSimpleLeScanner = new SimpleLeScanner(this);
    (mHandler = new Handler(ht.getLooper())).post(new Runnable() {

        @Override
        public void run() {
            if (mStartedSuccessfully = mSimpleLeScanner.startScan(mLeScanCallback)) {
                stopScan(false);
            } else {
                stopScan(true);
            }
        }
    });
}

23. ThreadManager#runThread()

Project: Android-ZBLibrary
File: ThreadManager.java
/**????
	 * @param name
	 * @param runnable
	 * @return
	 */
public Handler runThread(String name, Runnable runnable) {
    if (StringUtil.isNotEmpty(name, true) == false || runnable == null) {
        Log.e(TAG, "runThread  StringUtil.isNotEmpty(name, true) == false || runnable == null >> return");
        return null;
    }
    name = StringUtil.getTrimedString(name);
    Log.d(TAG, "\n runThread  name = " + name);
    Handler handler = getHandler(name);
    if (handler != null) {
        Log.w(TAG, "handler != null >>  destroyThread(name);");
        destroyThread(name);
    }
    HandlerThread thread = new HandlerThread(name);
    //????HandlerThread????
    thread.start();
    //??HandlerThread?looper????Handler
    handler = new Handler(thread.getLooper());
    //???post?Handler?
    handler.post(runnable);
    threadMap.put(name, new ThreadBean(name, thread, runnable, handler));
    Log.d(TAG, "runThread  added name = " + name + "; threadMap.size() = " + threadMap.size() + "\n");
    return handler;
}

24. ThreadManager#runThread()

Project: Android-ZBLibrary
File: ThreadManager.java
/**????
	 * @param name
	 * @param runnable
	 * @return
	 */
public Handler runThread(String name, Runnable runnable) {
    if (StringUtil.isNotEmpty(name, true) == false || runnable == null) {
        Log.e(TAG, "runThread  StringUtil.isNotEmpty(name, true) == false || runnable == null >> return");
        return null;
    }
    name = StringUtil.getTrimedString(name);
    Log.d(TAG, "\n runThread  name = " + name);
    Handler handler = getHandler(name);
    if (handler != null) {
        Log.w(TAG, "handler != null >>  destroyThread(name);");
        destroyThread(name);
    }
    HandlerThread thread = new HandlerThread(name);
    //????HandlerThread????
    thread.start();
    //??HandlerThread?looper????Handler
    handler = new Handler(thread.getLooper());
    //???post?Handler?
    handler.post(runnable);
    threadMap.put(name, new ThreadBean(name, thread, runnable, handler));
    Log.d(TAG, "runThread  added name = " + name + "; threadMap.size() = " + threadMap.size() + "\n");
    return handler;
}

25. WifiManager#init()

Project: android-proxy
File: WifiManager.java
private void init() {
    mWifiServiceMessenger = getWifiServiceMessenger();
    if (mWifiServiceMessenger == null) {
        mAsyncChannel = null;
        return;
    }
    HandlerThread t = new HandlerThread("WifiManager");
    t.start();
    mHandler = new ServiceHandler(t.getLooper());
    mAsyncChannel.connect(mContext, mHandler, mWifiServiceMessenger);
    try {
        mConnected.await();
    } catch (InterruptedException e) {
        Log.e(TAG, "interrupted wait at init");
    }
}

26. ServiceStartArguments#onCreate()

Project: android-maven-plugin
File: ServiceStartArguments.java
@Override
public void onCreate() {
    mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    Toast.makeText(this, R.string.service_created, Toast.LENGTH_SHORT).show();
    // This is who should be launched if the user selects our persistent
    // notification.
    mInvokeIntent = new Intent(this, Controller.class);
    // Start up the thread running the service.  Note that we create a
    // separate thread because the service normally runs in the process's
    // main thread, which we don't want to block.  We also make it
    // background priority so CPU-intensive work will not disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

27. NotificationUtils#cancelWithDelay()

Project: android
File: NotificationUtils.java
public static void cancelWithDelay(final NotificationManager notificationManager, final int notificationId, long delayInMillis) {
    HandlerThread thread = new HandlerThread("NotificationDelayerThread_" + (new Random(System.currentTimeMillis())).nextInt(), Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    Handler handler = new Handler(thread.getLooper());
    handler.postDelayed(new Runnable() {

        public void run() {
            notificationManager.cancel(notificationId);
            ((HandlerThread) Thread.currentThread()).getLooper().quit();
        }
    }, delayInMillis);
}

28. FileUploader#onCreate()

Project: android
File: FileUploader.java
/**
     * Service initialization
     */
@Override
public void onCreate() {
    super.onCreate();
    Log_OC.d(TAG, "Creating service");
    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    HandlerThread thread = new HandlerThread("FileUploaderThread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper, this);
    mBinder = new FileUploaderBinder();
    mUploadsStorageManager = new UploadsStorageManager(getContentResolver());
    int failedCounter = mUploadsStorageManager.failInProgressUploads(// Add UploadResult.KILLED?
    UploadResult.SERVICE_INTERRUPTED);
    if (failedCounter > 0) {
        resurrection();
    }
    // add AccountsUpdatedListener
    AccountManager am = AccountManager.get(getApplicationContext());
    am.addOnAccountsUpdatedListener(this, null, false);
}

29. FileDownloader#onCreate()

Project: android
File: FileDownloader.java
/**
     * Service initialization
     */
@Override
public void onCreate() {
    super.onCreate();
    Log_OC.d(TAG, "Creating service");
    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    HandlerThread thread = new HandlerThread("FileDownloaderThread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper, this);
    mBinder = new FileDownloaderBinder();
    // add AccountsUpdatedListener
    AccountManager am = AccountManager.get(getApplicationContext());
    am.addOnAccountsUpdatedListener(this, null, false);
}

30. TriggerLoop#onCreate()

Project: Trigger
File: TriggerLoop.java
@Override
public void onCreate() {
    super.onCreate();
    jobSet = new ConcurrentHashMap<>();
    receivers = new ConcurrentHashMap<>();
    binder = new TriggerBinder();
    executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE, new TriggerWorkerFactory());
    mainHandler = new Handler(Looper.getMainLooper());
    alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
    shortDeadlineHandler = new Handler();
    deadlineCheck = new DeadlineCheck();
    sDeviceStatus = DeviceStatus.get(this);
    registerReceiver(deadlineCheck, new IntentFilter(DEADLINE_BROADCAST));
    PowerManager pm = (PowerManager) getSystemService(POWER_SERVICE);
    int granted = checkCallingOrSelfPermission("android.permission.WAKE_LOCK");
    if (granted == PackageManager.PERMISSION_GRANTED) {
        wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
    } else {
        wakeLock = null;
    }
    handlerThread = new HandlerThread("Trigger-HandlerThread");
    handlerThread.start();
    checker = new CheckHandler(handlerThread.getLooper());
    mayRecoverJobsFromFile();
}

31. LibrarySyncService#onCreate()

Project: Kore
File: LibrarySyncService.java
@Override
public void onCreate() {
    // Create a Handler Thread to process callback calls after the Xbmc method call
    handlerThread = new HandlerThread("LibrarySyncService", Process.THREAD_PRIORITY_BACKGROUND);
    handlerThread.start();
    // Get the HandlerThread's Looper and use it for our Handler
    callbackHandler = new Handler(handlerThread.getLooper());
    // Check which libraries to update and call the corresponding methods on Xbmc
    syncOrchestrators = new ArrayList<>();
}

32. MockLocationProvider#startMockLocationProviderThread()

Project: chromium_webview
File: MockLocationProvider.java
private void startMockLocationProviderThread() {
    assert mHandlerThread == null;
    assert mHandler == null;
    mHandlerThread = new HandlerThread("MockLocationProviderImpl");
    mHandlerThread.start();
    mHandler = new Handler(mHandlerThread.getLooper()) {

        @Override
        public void handleMessage(Message msg) {
            synchronized (mLock) {
                if (msg.what == UPDATE_LOCATION_MSG) {
                    newLocation();
                    sendEmptyMessageDelayed(UPDATE_LOCATION_MSG, 250);
                }
            }
        }
    };
}

33. GPXImporterTest#setUp()

Project: cgeo
File: GPXImporterTest.java
@Override
protected void setUp() throws Exception {
    super.setUp();
    serviceThread = new HandlerThread("[" + getClass().getSimpleName() + "Thread]");
    serviceThread.start();
    final Looper serviceLooper = serviceThread.getLooper();
    importStepHandler = new TestHandler(serviceLooper);
    progressHandler = new TestHandler(serviceLooper);
    final String globalTempDir = System.getProperty("java.io.tmpdir");
    assertThat(StringUtils.isNotBlank(globalTempDir)).overridingErrorMessage("java.io.tmpdir is not defined").isTrue();
    tempDir = new File(globalTempDir, "cgeogpxesTest");
    cgeo.geocaching.utils.FileUtils.mkdirs(tempDir);
    assertThat(tempDir).overridingErrorMessage("Could not create directory %s", tempDir.getPath()).exists();
    // workaround to get storage initialized
    DataStore.getAllHistoryCachesCount();
    listId = DataStore.createList("cgeogpxesTest");
    importCacheStaticMaps = Settings.isStoreOfflineMaps();
    TestSettings.setStoreOfflineMaps(true);
    importWpStaticMaps = Settings.isStoreOfflineWpMaps();
    TestSettings.setStoreOfflineWpMaps(true);
}

34. BasicFieldVariableViewTest#setUp()

Project: blockly-android
File: BasicFieldVariableViewTest.java
@Override
public void setUp() throws Exception {
    super.setUp();
    mThread = new HandlerThread("DraggerTest");
    mThread.start();
    mLooper = mThread.getLooper();
    mHandler = new Handler(mLooper);
    mMockContext = Mockito.mock(Context.class, AdditionalAnswers.delegatesTo(getContext()));
    Mockito.doReturn(mLooper).when(mMockContext).getMainLooper();
    mFieldVariable = new FieldVariable("field", "var2");
    mNameManager = new NameManager.VariableNameManager();
    mNameManager.addName("var1");
    mNameManager.addName(mFieldVariable.getVariable());
    mNameManager.addName("var3");
    mVariableAdapter = new VariableViewAdapter(getContext(), mNameManager, android.R.layout.simple_spinner_item);
}

35. UEntropyMic#onResume()

Project: bither-android
File: UEntropyMic.java
@Override
public void onResume() {
    if (micThread != null && micThread.isAlive()) {
        return;
    }
    micThread = new HandlerThread("UEntropyMicThread", android.os.Process.THREAD_PRIORITY_BACKGROUND);
    micThread.setUncaughtExceptionHandler(this);
    micThread.start();
    micHandler = new Handler(micThread.getLooper());
    micHandler.post(openRunnable);
}

36. UEntropyCamera#onResume()

Project: bither-android
File: UEntropyCamera.java
@Override
public void onResume() {
    if (cameraThread != null && cameraThread.isAlive()) {
        return;
    }
    cameraThread = new HandlerThread("UEntropyCameraThread", android.os.Process.THREAD_PRIORITY_BACKGROUND);
    cameraThread.setUncaughtExceptionHandler(this);
    cameraThread.start();
    cameraHandler = new Handler(cameraThread.getLooper());
    if (surfaceHolder != null) {
        cameraHandler.post(openRunnable);
    }
}

37. AudioVisualizerView#onAttachedToWindow()

Project: bither-android
File: AudioVisualizerView.java
@Override
protected void onAttachedToWindow() {
    super.onAttachedToWindow();
    if (dataThread != null && dataThread.isAlive()) {
        dataThread.quit();
    }
    dataThread = new HandlerThread("AudioVisualizeDataThread", android.os.Process.THREAD_PRIORITY_BACKGROUND);
    dataThread.start();
    dataHandler = new Handler(dataThread.getLooper());
    paint = new Paint();
    paint.setColor(LineColor);
    paint.setStrokeWidth(LineWidth);
    paint.setAntiAlias(true);
    paint.setStyle(Paint.Style.STROKE);
    paint.setStrokeJoin(Paint.Join.ROUND);
    paint.setStrokeCap(Paint.Cap.ROUND);
    subLinePaint = new Paint(paint);
    subLinePaint.setStrokeWidth(SubLineWidth);
    subLinePaint.setColor(SubLineColor);
    drawer = new PathDrawer(SubLineCount);
}

38. ScanActivity#onResume()

Project: bither-android
File: ScanActivity.java
@Override
protected void onResume() {
    super.onResume();
    cameraThread = new HandlerThread("cameraThread", Process.THREAD_PRIORITY_BACKGROUND);
    cameraThread.start();
    cameraHandler = new Handler(cameraThread.getLooper());
    final SurfaceView surfaceView = (SurfaceView) findViewById(R.id.scan_activity_preview);
    surfaceHolder = surfaceView.getHolder();
    surfaceHolder.addCallback(this);
    surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
}

39. HandlerThreadActivity#initBackThread()

Project: Android_Blog_Demos
File: HandlerThreadActivity.java
private void initBackThread() {
    mCheckMsgThread = new HandlerThread("check-message-coming");
    mCheckMsgThread.start();
    mCheckMsgHandler = new Handler(mCheckMsgThread.getLooper()) {

        @Override
        public void handleMessage(Message msg) {
            checkForUpdate();
            if (isUpdateInfo) {
                mCheckMsgHandler.sendEmptyMessageDelayed(MSG_UPDATE_INFO, 1000);
            }
        }
    };
}

40. RichTvInputService#onCreate()

Project: androidtv-sample-inputs
File: RichTvInputService.java
@Override
public void onCreate() {
    super.onCreate();
    mHandlerThread = new HandlerThread(getClass().getSimpleName());
    mHandlerThread.start();
    mDbHandler = new Handler(mHandlerThread.getLooper());
    mCaptioningManager = (CaptioningManager) getSystemService(Context.CAPTIONING_SERVICE);
    setTheme(android.R.style.Theme_Holo_Light_NoActionBar);
    mSessions = new ArrayList<>();
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(TvInputManager.ACTION_BLOCKED_RATINGS_CHANGED);
    intentFilter.addAction(TvInputManager.ACTION_PARENTAL_CONTROLS_ENABLED_CHANGED);
    registerReceiver(mParentalControlsBroadcastReceiver, intentFilter);
}

41. NumberValidator#start()

Project: androidclient
File: NumberValidator.java
public synchronized void start() {
    if (mThread != null)
        throw new IllegalArgumentException("already started");
    // internal handler
    mServiceHandler = new HandlerThread(NumberValidator.class.getSimpleName()) {

        @Override
        protected void onLooperPrepared() {
            mInternalHandler = new Handler(getLooper());
        }
    };
    mServiceHandler.start();
    // validator thread
    mThread = new Thread(this);
    mThread.start();
}

42. AndroidJsDebugger#start()

Project: android-runtime
File: AndroidJsDebugger.java
public void start() {
    debugServerThread = new DebugLocalServerSocketThread(context.getPackageName() + "-debug");
    debugServerThread.start();
    handlerThread = new HandlerThread("debugAgentBroadCastReceiverHandler");
    handlerThread.start();
    Handler handler = new Handler(handlerThread.getLooper());
    this.registerEnableDisableDebuggerReceiver(handler);
    AndroidJsDebugger.this.debugContext.enableAgent();
    boolean shouldDebugBreak = getDebugBreakFlagAndClearIt();
    if (shouldDebugBreak) {
        AndroidJsDebugger.this.debugContext.debugBreak();
    }
}

43. AndroidJsDebugger#start()

Project: android-runtime
File: AndroidJsDebugger.java
public void start() {
    debugServerThread = new DebugLocalServerSocketThread(context.getPackageName() + "-debug");
    debugServerThread.start();
    handlerThread = new HandlerThread("debugAgentBroadCastReceiverHandler");
    handlerThread.start();
    Handler handler = new Handler(handlerThread.getLooper());
    this.registerEnableDisableDebuggerReceiver(handler);
    AndroidJsDebugger.this.debugContext.enableAgent();
    boolean shouldDebugBreak = getDebugBreakFlagAndClearIt();
    if (shouldDebugBreak) {
        AndroidJsDebugger.this.debugContext.debugBreak();
    }
}

44. TypeBasedNotificationsTests#callback_with_relevant_commit_from_different_looper_realmobject_async()

Project: realm-java
File: TypeBasedNotificationsTests.java
// UC 1 Async RealmObject
@Test
@RunTestInLooperThread
public void callback_with_relevant_commit_from_different_looper_realmobject_async() {
    final CountDownLatch looperThread1Done = new CountDownLatch(1);
    final CountDownLatch looperThread2Done = new CountDownLatch(1);
    final CountDownLatch looperThread3Done = new CountDownLatch(1);
    final HandlerThread looperThread1 = new HandlerThread("looperThread1");
    final HandlerThread looperThread2 = new HandlerThread("looperThread2");
    final HandlerThread looperThread3 = new HandlerThread("looperThread3");
    looperThread1.start();
    looperThread2.start();
    looperThread3.start();
    final Handler looperHandler1 = new Handler(looperThread1.getLooper());
    final Handler looperHandler2 = new Handler(looperThread2.getLooper());
    final Handler looperHandler3 = new Handler(looperThread3.getLooper());
    final Realm realm = looperThread.realm;
    realm.addChangeListener(new RealmChangeListener<Realm>() {

        @Override
        public void onChange(Realm object) {
            globalCommitInvocations.incrementAndGet();
        }
    });
    final Dog dog = realm.where(Dog.class).findFirstAsync();
    assertTrue(dog.load());
    dog.addChangeListener(new RealmChangeListener<Dog>() {

        @Override
        public void onChange(Dog object) {
            switch(typebasedCommitInvocations.incrementAndGet()) {
                case // triggered by COMPLETED_ASYNC_REALM_OBJECT from calling dog.load()
                1:
                    assertTrue(dog.isLoaded());
                    assertFalse(dog.isValid());
                    looperHandler1.post(new Runnable() {

                        @Override
                        public void run() {
                            Realm realmLooperThread1 = Realm.getInstance(realm.getConfiguration());
                            realmLooperThread1.beginTransaction();
                            realmLooperThread1.commitTransaction();
                            realmLooperThread1.close();
                            looperThread1Done.countDown();
                        }
                    });
                    break;
                case // triggered by the irrelevant commit (not affecting Dog table) from LooperThread1
                2:
                    assertTrue(dog.isLoaded());
                    assertFalse(dog.isValid());
                    looperHandler2.post(new Runnable() {

                        @Override
                        public void run() {
                            Realm realmLooperThread2 = Realm.getInstance(realm.getConfiguration());
                            // trigger first callback invocation
                            realmLooperThread2.beginTransaction();
                            Dog dog = realmLooperThread2.createObject(Dog.class);
                            dog.setName("Akamaru");
                            realmLooperThread2.commitTransaction();
                            realmLooperThread2.close();
                            looperThread2Done.countDown();
                        }
                    });
                    break;
                case // triggered by relevant commit from LooperThread2
                3:
                    assertEquals("Akamaru", dog.getName());
                    realm.handler.post(new Runnable() {

                        @Override
                        public void run() {
                            // trigger second callback invocation
                            looperHandler3.post(new Runnable() {

                                @Override
                                public void run() {
                                    Realm realmLooperThread3 = Realm.getInstance(realm.getConfiguration());
                                    realmLooperThread3.beginTransaction();
                                    realmLooperThread3.where(Dog.class).findFirst().setAge(17);
                                    realmLooperThread3.commitTransaction();
                                    realmLooperThread3.close();
                                    looperThread3Done.countDown();
                                }
                            });
                        }
                    });
                    break;
                case 4:
                    assertEquals("Akamaru", dog.getName());
                    assertEquals(17, dog.getAge());
                    // posting as an event will give the handler a chance
                    // to deliver the notification for globalCommitInvocations
                    // otherwise, test will exit before the callback get a chance to be invoked
                    realm.handler.post(new Runnable() {

                        @Override
                        public void run() {
                            assertEquals(3, globalCommitInvocations.get());
                            assertEquals(4, typebasedCommitInvocations.get());
                            looperThread1.quit();
                            looperThread2.quit();
                            looperThread3.quit();
                            TestHelper.awaitOrFail(looperThread1Done);
                            TestHelper.awaitOrFail(looperThread2Done);
                            TestHelper.awaitOrFail(looperThread3Done);
                            looperThread.testComplete();
                        }
                    });
                    break;
            }
        }
    });
}

45. ServiceSinkhole#onCreate()

Project: NetGuard
File: ServiceSinkhole.java
@Override
public void onCreate() {
    Log.i(TAG, "Create version=" + Util.getSelfVersionName(this) + "/" + Util.getSelfVersionCode(this));
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    // Native init
    jni_init();
    boolean pcap = prefs.getBoolean("pcap", false);
    setPcap(pcap, this);
    prefs.registerOnSharedPreferenceChangeListener(this);
    Util.setTheme(this);
    super.onCreate();
    HandlerThread commandThread = new HandlerThread(getString(R.string.app_name) + " command");
    HandlerThread logThread = new HandlerThread(getString(R.string.app_name) + " log");
    HandlerThread statsThread = new HandlerThread(getString(R.string.app_name) + " stats");
    commandThread.start();
    logThread.start();
    statsThread.start();
    commandLooper = commandThread.getLooper();
    logLooper = logThread.getLooper();
    statsLooper = statsThread.getLooper();
    commandHandler = new CommandHandler(commandLooper);
    logHandler = new LogHandler(logLooper);
    statsHandler = new StatsHandler(statsLooper);
    // Listen for interactive state changes
    last_interactive = Util.isInteractive(this);
    IntentFilter ifInteractive = new IntentFilter();
    ifInteractive.addAction(Intent.ACTION_SCREEN_ON);
    ifInteractive.addAction(Intent.ACTION_SCREEN_OFF);
    ifInteractive.addAction(ACTION_SCREEN_OFF_DELAYED);
    registerReceiver(interactiveStateReceiver, ifInteractive);
    registeredInteractiveState = true;
    // Listen for power save mode
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !Util.isPlayStoreInstall(this)) {
        PowerManager pm = (PowerManager) getSystemService(POWER_SERVICE);
        powersaving = pm.isPowerSaveMode();
        IntentFilter ifPower = new IntentFilter();
        ifPower.addAction(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED);
        registerReceiver(powerSaveReceiver, ifPower);
        registeredPowerSave = true;
    }
    // Listen for user switches
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        IntentFilter ifUser = new IntentFilter();
        ifUser.addAction(Intent.ACTION_USER_BACKGROUND);
        ifUser.addAction(Intent.ACTION_USER_FOREGROUND);
        registerReceiver(userReceiver, ifUser);
        registeredUser = true;
    }
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        // Listen for idle mode state changes
        IntentFilter ifIdle = new IntentFilter();
        ifIdle.addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED);
        registerReceiver(idleStateReceiver, ifIdle);
        registeredIdleState = true;
    }
    // Listen for connectivity updates
    IntentFilter ifConnectivity = new IntentFilter();
    ifConnectivity.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    registerReceiver(connectivityChangedReceiver, ifConnectivity);
    registeredConnectivityChanged = true;
    // Listen for added applications
    IntentFilter ifPackage = new IntentFilter();
    ifPackage.addAction(Intent.ACTION_PACKAGE_ADDED);
    ifPackage.addDataScheme("package");
    registerReceiver(packageAddedReceiver, ifPackage);
    registeredPackageAdded = true;
    // Setup house holding
    Intent alarmIntent = new Intent(this, ServiceSinkhole.class);
    alarmIntent.setAction(ACTION_HOUSE_HOLDING);
    PendingIntent pi = PendingIntent.getService(this, 0, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    am.setInexactRepeating(AlarmManager.RTC, SystemClock.elapsedRealtime() + 60 * 1000, AlarmManager.INTERVAL_HALF_DAY, pi);
}

46. NotificationsTest#nonLooperThreadShouldNotifyLooperThreadAboutCommit()

Project: realm-java
File: NotificationsTest.java
@Test
public void nonLooperThreadShouldNotifyLooperThreadAboutCommit() {
    final CountDownLatch mainThreadReady = new CountDownLatch(1);
    final CountDownLatch backgroundThreadClosed = new CountDownLatch(1);
    final CountDownLatch numberOfInvocation = new CountDownLatch(1);
    Thread thread = new Thread() {

        @Override
        public void run() {
            TestHelper.awaitOrFail(mainThreadReady);
            Realm realm = Realm.getInstance(realmConfig);
            realm.beginTransaction();
            realm.createObject(AllTypes.class);
            realm.commitTransaction();
            realm.close();
            backgroundThreadClosed.countDown();
        }
    };
    thread.start();
    HandlerThread mainThread = new HandlerThread("mainThread");
    mainThread.start();
    Handler handler = new Handler(mainThread.getLooper());
    handler.post(new Runnable() {

        @Override
        public void run() {
            final Realm mainRealm = Realm.getInstance(realmConfig);
            mainRealm.addChangeListener(new RealmChangeListener<Realm>() {

                @Override
                public void onChange(Realm object) {
                    mainRealm.close();
                    numberOfInvocation.countDown();
                }
            });
            mainThreadReady.countDown();
        }
    });
    TestHelper.awaitOrFail(numberOfInvocation);
    TestHelper.awaitOrFail(backgroundThreadClosed);
    mainThread.quit();
}

47. NotificationsTest#handlerThreadShouldReceiveNotification()

Project: realm-java
File: NotificationsTest.java
@Test
public void handlerThreadShouldReceiveNotification() throws ExecutionException, InterruptedException {
    final AssertionFailedError[] assertionFailedErrors = new AssertionFailedError[1];
    final CountDownLatch backgroundThreadReady = new CountDownLatch(1);
    final CountDownLatch numberOfInvocation = new CountDownLatch(1);
    HandlerThread handlerThread = new HandlerThread("handlerThread");
    handlerThread.start();
    Handler handler = new Handler(handlerThread.getLooper());
    handler.post(new Runnable() {

        @Override
        public void run() {
            try {
                assertEquals("handlerThread", Thread.currentThread().getName());
            } catch (AssertionFailedError e) {
                assertionFailedErrors[0] = e;
            }
            final Realm backgroundRealm = Realm.getInstance(realmConfig);
            backgroundRealm.addChangeListener(new RealmChangeListener<Realm>() {

                @Override
                public void onChange(Realm object) {
                    backgroundRealm.close();
                    numberOfInvocation.countDown();
                }
            });
            backgroundThreadReady.countDown();
        }
    });
    TestHelper.awaitOrFail(backgroundThreadReady);
    // At this point the background thread started & registered the listener
    Realm realm = Realm.getInstance(realmConfig);
    realm.beginTransaction();
    realm.createObject(AllTypes.class);
    realm.commitTransaction();
    TestHelper.awaitOrFail(numberOfInvocation);
    realm.close();
    handlerThread.quit();
    if (assertionFailedErrors[0] != null) {
        throw assertionFailedErrors[0];
    }
}

48. HandlerFactory#newBackgroundLooper()

Project: androidkit
File: HandlerFactory.java
/**
	 * ??????Looper???
	 * 
	 * @param name
	 *            ?????
	 * @return ????????Looper???
	 */
public static Looper newBackgroundLooper(String name) {
    HandlerThread thread = new HandlerThread(name);
    thread.start();
    return thread.getLooper();
}

49. PlaylistActivity#onCreate()

Project: vanilla
File: PlaylistActivity.java
@Override
public void onCreate(Bundle state) {
    ThemeHelper.setTheme(this, R.style.BackActionBar);
    super.onCreate(state);
    HandlerThread thread = new HandlerThread(getClass().getName());
    thread.start();
    setContentView(R.layout.playlist_activity);
    DragSortListView view = (DragSortListView) findViewById(R.id.list);
    view.setOnItemClickListener(this);
    view.setOnCreateContextMenuListener(this);
    view.setDropListener(this);
    view.setRemoveListener(this);
    mListView = view;
    View header = LayoutInflater.from(this).inflate(R.layout.playlist_buttons, null);
    mEditButton = (Button) header.findViewById(R.id.edit);
    mEditButton.setOnClickListener(this);
    mDeleteButton = (Button) header.findViewById(R.id.delete);
    mDeleteButton.setOnClickListener(this);
    view.addHeaderView(header, null, false);
    mLooper = thread.getLooper();
    mAdapter = new PlaylistAdapter(this, mLooper);
    view.setAdapter(mAdapter);
    onNewIntent(getIntent());
}

50. PlaybackService#onCreate()

Project: vanilla
File: PlaybackService.java
@Override
public void onCreate() {
    HandlerThread thread = new HandlerThread("PlaybackService", Process.THREAD_PRIORITY_DEFAULT);
    thread.start();
    mTimeline = new SongTimeline(this);
    mTimeline.setCallback(this);
    int state = loadState();
    mPlayCounts = new PlayCountsHelper(this);
    mMediaPlayer = getNewMediaPlayer();
    mPreparedMediaPlayer = getNewMediaPlayer();
    // We only have a single audio session
    mPreparedMediaPlayer.setAudioSessionId(mMediaPlayer.getAudioSessionId());
    mBastpUtil = new BastpUtil();
    mReadahead = new ReadaheadThread();
    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    mAudioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
    SharedPreferences settings = getSettings(this);
    settings.registerOnSharedPreferenceChangeListener(this);
    mNotificationMode = Integer.parseInt(settings.getString(PrefKeys.NOTIFICATION_MODE, PrefDefaults.NOTIFICATION_MODE));
    mNotificationNag = settings.getBoolean(PrefKeys.NOTIFICATION_NAG, PrefDefaults.NOTIFICATION_NAG);
    mScrobble = settings.getBoolean(PrefKeys.SCROBBLE, PrefDefaults.SCROBBLE);
    mIdleTimeout = settings.getBoolean(PrefKeys.USE_IDLE_TIMEOUT, PrefDefaults.USE_IDLE_TIMEOUT) ? settings.getInt(PrefKeys.IDLE_TIMEOUT, PrefDefaults.IDLE_TIMEOUT) : 0;
    CoverCache.mCoverLoadMode = settings.getBoolean(PrefKeys.COVERLOADER_ANDROID, PrefDefaults.COVERLOADER_ANDROID) ? CoverCache.mCoverLoadMode | CoverCache.COVER_MODE_ANDROID : CoverCache.mCoverLoadMode & ~(CoverCache.COVER_MODE_ANDROID);
    CoverCache.mCoverLoadMode = settings.getBoolean(PrefKeys.COVERLOADER_VANILLA, PrefDefaults.COVERLOADER_VANILLA) ? CoverCache.mCoverLoadMode | CoverCache.COVER_MODE_VANILLA : CoverCache.mCoverLoadMode & ~(CoverCache.COVER_MODE_VANILLA);
    CoverCache.mCoverLoadMode = settings.getBoolean(PrefKeys.COVERLOADER_SHADOW, PrefDefaults.COVERLOADER_SHADOW) ? CoverCache.mCoverLoadMode | CoverCache.COVER_MODE_SHADOW : CoverCache.mCoverLoadMode & ~(CoverCache.COVER_MODE_SHADOW);
    mHeadsetOnly = settings.getBoolean(PrefKeys.HEADSET_ONLY, PrefDefaults.HEADSET_ONLY);
    mStockBroadcast = settings.getBoolean(PrefKeys.STOCK_BROADCAST, PrefDefaults.STOCK_BROADCAST);
    mNotificationAction = createNotificationAction(settings);
    mHeadsetPause = getSettings(this).getBoolean(PrefKeys.HEADSET_PAUSE, PrefDefaults.HEADSET_PAUSE);
    mShakeAction = settings.getBoolean(PrefKeys.ENABLE_SHAKE, PrefDefaults.ENABLE_SHAKE) ? Action.getAction(settings, PrefKeys.SHAKE_ACTION, PrefDefaults.SHAKE_ACTION) : Action.Nothing;
    mShakeThreshold = settings.getInt(PrefKeys.SHAKE_THRESHOLD, PrefDefaults.SHAKE_THRESHOLD) / 10.0f;
    mReplayGainTrackEnabled = settings.getBoolean(PrefKeys.ENABLE_TRACK_REPLAYGAIN, PrefDefaults.ENABLE_TRACK_REPLAYGAIN);
    mReplayGainAlbumEnabled = settings.getBoolean(PrefKeys.ENABLE_ALBUM_REPLAYGAIN, PrefDefaults.ENABLE_ALBUM_REPLAYGAIN);
    mReplayGainBump = settings.getInt(PrefKeys.REPLAYGAIN_BUMP, PrefDefaults.REPLAYGAIN_BUMP);
    mReplayGainUntaggedDeBump = settings.getInt(PrefKeys.REPLAYGAIN_UNTAGGED_DEBUMP, PrefDefaults.REPLAYGAIN_UNTAGGED_DEBUMP);
    mVolumeDuringDucking = settings.getInt(PrefKeys.VOLUME_DURING_DUCKING, PrefDefaults.VOLUME_DURING_DUCKING);
    mIgnoreAudioFocusLoss = settings.getBoolean(PrefKeys.IGNORE_AUDIOFOCUS_LOSS, PrefDefaults.IGNORE_AUDIOFOCUS_LOSS);
    refreshDuckingValues();
    mReadaheadEnabled = settings.getBoolean(PrefKeys.ENABLE_READAHEAD, PrefDefaults.ENABLE_READAHEAD);
    mAutoPlPlaycounts = settings.getInt(PrefKeys.AUTOPLAYLIST_PLAYCOUNTS, PrefDefaults.AUTOPLAYLIST_PLAYCOUNTS);
    PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
    mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "VanillaMusicLock");
    mReceiver = new Receiver();
    IntentFilter filter = new IntentFilter();
    filter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
    filter.addAction(Intent.ACTION_SCREEN_ON);
    registerReceiver(mReceiver, filter);
    getContentResolver().registerContentObserver(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, true, mObserver);
    mRemoteControlClient = new RemoteControl().getClient(this);
    mRemoteControlClient.initializeRemote();
    mLooper = thread.getLooper();
    mHandler = new Handler(mLooper, this);
    initWidgets();
    updateState(state);
    setCurrentSong(0);
    sInstance = this;
    synchronized (sWait) {
        sWait.notifyAll();
    }
    mAccelFiltered = 0.0f;
    mAccelLast = SensorManager.GRAVITY_EARTH;
    setupSensor();
}

51. MirrorLinkMediaBrowserService#onCreate()

Project: vanilla
File: MirrorLinkMediaBrowserService.java
@Override
public void onCreate() {
    Log.d("VanillaMusic", "MediaBrowserService#onCreate");
    super.onCreate();
    HandlerThread thread = new HandlerThread("MediaBrowserService", Process.THREAD_PRIORITY_DEFAULT);
    thread.start();
    // Prep the Media Adapters (caches the top categories)
    mArtistAdapter = new MediaAdapter(this, MediaUtils.TYPE_ARTIST, null, null);
    mAlbumAdapter = new MediaAdapter(this, MediaUtils.TYPE_ALBUM, null, null);
    mSongAdapter = new MediaAdapter(this, MediaUtils.TYPE_SONG, null, null);
    mPlaylistAdapter = new MediaAdapter(this, MediaUtils.TYPE_PLAYLIST, null, null);
    mGenreAdapter = new MediaAdapter(this, MediaUtils.TYPE_GENRE, null, null);
    mMediaAdapters[MediaUtils.TYPE_ARTIST] = mArtistAdapter;
    mMediaAdapters[MediaUtils.TYPE_ALBUM] = mAlbumAdapter;
    mMediaAdapters[MediaUtils.TYPE_SONG] = mSongAdapter;
    mMediaAdapters[MediaUtils.TYPE_PLAYLIST] = mPlaylistAdapter;
    mMediaAdapters[MediaUtils.TYPE_GENRE] = mGenreAdapter;
    // Fill and cache the top queries
    mMediaRoot.add(new MediaBrowser.MediaItem(new MediaDescription.Builder().setMediaId(Integer.toString(MediaUtils.TYPE_ARTIST)).setTitle(getString(R.string.artists)).setIconUri(Uri.parse("android.resource://" + "ch.blinkenlights.android.vanilla/drawable/ic_menu_music_library")).setSubtitle(getString(R.string.artists)).build(), MediaBrowser.MediaItem.FLAG_BROWSABLE));
    mMediaRoot.add(new MediaBrowser.MediaItem(new MediaDescription.Builder().setMediaId(Integer.toString(MediaUtils.TYPE_ALBUM)).setTitle(getString(R.string.albums)).setIconUri(Uri.parse("android.resource://" + "ch.blinkenlights.android.vanilla/drawable/ic_menu_music_library")).setSubtitle(getString(R.string.albums)).build(), MediaBrowser.MediaItem.FLAG_BROWSABLE));
    mMediaRoot.add(new MediaBrowser.MediaItem(new MediaDescription.Builder().setMediaId(Integer.toString(MediaUtils.TYPE_SONG)).setTitle(getString(R.string.songs)).setIconUri(Uri.parse("android.resource://" + "ch.blinkenlights.android.vanilla/drawable/ic_menu_music_library")).setSubtitle(getString(R.string.songs)).build(), MediaBrowser.MediaItem.FLAG_BROWSABLE));
    mMediaRoot.add(new MediaBrowser.MediaItem(new MediaDescription.Builder().setMediaId(Integer.toString(MediaUtils.TYPE_GENRE)).setTitle(getString(R.string.genres)).setIconUri(Uri.parse("android.resource://" + "ch.blinkenlights.android.vanilla/drawable/ic_menu_music_library")).setSubtitle(getString(R.string.genres)).build(), MediaBrowser.MediaItem.FLAG_BROWSABLE));
    mMediaRoot.add(new MediaBrowser.MediaItem(new MediaDescription.Builder().setMediaId(Integer.toString(MediaUtils.TYPE_PLAYLIST)).setTitle(getString(R.string.playlists)).setIconUri(Uri.parse("android.resource://" + "ch.blinkenlights.android.vanilla/drawable/ic_menu_music_library")).setSubtitle(getString(R.string.playlists)).build(), MediaBrowser.MediaItem.FLAG_BROWSABLE));
    // Start a new MediaSession
    mSession = new MediaSession(this, "VanillaMediaBrowserService");
    setSessionToken(mSession.getSessionToken());
    mSession.setCallback(new MediaSessionCallback());
    mSession.setFlags(MediaSession.FLAG_HANDLES_MEDIA_BUTTONS | MediaSession.FLAG_HANDLES_TRANSPORT_CONTROLS);
    mSessionExtras = new Bundle();
    mSession.setExtras(mSessionExtras);
    // Register with the PlaybackService
    PlaybackService.addTimelineCallback(this);
    // Make sure the PlaybackService is running
    if (!PlaybackService.hasInstance()) {
        Thread t = new Thread(new Runnable() {

            @Override
            public void run() {
                PlaybackService.get(MirrorLinkMediaBrowserService.this);
            }
        });
        t.start();
    }
    mLooper = thread.getLooper();
    mHandler = new Handler(mLooper, this);
    updatePlaybackState(null);
}

52. FileCreateThread#run()

Project: SimplifyReader
File: FileCreateThread.java
@Override
public void run() {
    for (DownloadInfo info : download_temp_infos) {
        if (download.existsDownloadInfo(info.videoid)) {
            if (download.isDownloadFinished(// ?????
            info.videoid)) {
                PlayerUtil.showTips(R.string.download_exist_finished);
            } else {
                PlayerUtil.showTips(R.string.download_exist_not_finished);
            }
            continue;
        }
        long time = System.currentTimeMillis();
        info.createTime = time;
        info.taskId = // ?????ID
        String.valueOf(time).substring(// ?????ID
        5);
        if (init(info)) {
            Logger.d("DownloadFlow", "init() success");
            download.addDownloadingInfo(info);
            switch(info.format) {
                case DownloadInfo.FORMAT_HD2:
                    break;
                case DownloadInfo.FORMAT_MP4:
                    break;
                default:
                    break;
            }
            successCount++;
            YoukuPlayerApplication.context.sendBroadcast(new Intent(IDownload.ACTION_CREATE_DOWNLOAD_ONE_READY));
        } else {
            Logger.d("DownloadFlow", "init() fail");
            failCount++;
            YoukuPlayerApplication.context.sendBroadcast(new Intent(IDownload.ACTION_CREATE_DOWNLOAD_ONE_FAILED));
            if (// ???????????
            info.getExceptionId() == DownloadInfo.EXCEPTION_NO_SPACE) {
                failCount = download_temp_infos.size() - successCount;
                ArrayList<SDCardInfo> card = SDCardManager.getExternalStorageDirectory();
                if (card != null && card.size() > 1) {
                    hasMaryPaths = true;
                    HandlerThread ht = new HandlerThread("handler_thread1");
                    ht.start();
                    new Handler(ht.getLooper()) {

                        public void handleMessage(Message msg) {
                            /*								YoukuPlayerApplication.context
										.startActivity(new Intent(
												YoukuPlayerApplication.context,
												EmptyActivity.class)
												.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));*/
                            Toast.makeText(YoukuPlayerApplication.context, "??????", Toast.LENGTH_SHORT).show();
                        }

                        ;
                    }.sendEmptyMessageDelayed(0, 500L);
                }
                break;
            }
            continue;
        }
    }
    for (DownloadInfo info : download_temp_infos) {
        tempCreateData.remove(info.videoid);
    }
    showTips();
    over();
    HandlerThread ht = new HandlerThread("handler_thread2");
    ht.start();
    new Handler(ht.getLooper()) {

        public void handleMessage(Message msg) {
            Logger.d("DownloadFlow", "FileCreateThread: create task to download");
            download.startNewTask();
        }

        ;
    }.sendEmptyMessageDelayed(0, 1000L);
    super.run();
}

53. ContentProviderStore#createHandler()

Project: reark
File: ContentProviderStore.java
@NonNull
protected static Handler createHandler(String name) {
    HandlerThread handlerThread = new HandlerThread(name);
    handlerThread.start();
    return new Handler(handlerThread.getLooper());
}

54. RealmTests#closeRealmInChangeListener()

Project: realm-java
File: RealmTests.java
// Test if close can be called from Realm change listener when there is no other listeners
@Test
public void closeRealmInChangeListener() {
    realm.close();
    final CountDownLatch signalTestFinished = new CountDownLatch(1);
    HandlerThread handlerThread = new HandlerThread("background");
    handlerThread.start();
    final Handler handler = new Handler(handlerThread.getLooper());
    handler.post(new Runnable() {

        @Override
        public void run() {
            final Realm realm = Realm.getInstance(realmConfig);
            final RealmChangeListener<Realm> listener = new RealmChangeListener<Realm>() {

                @Override
                public void onChange(Realm object) {
                    if (realm.where(AllTypes.class).count() == 1) {
                        realm.removeChangeListener(this);
                        realm.close();
                        signalTestFinished.countDown();
                    }
                }
            };
            realm.addChangeListener(listener);
            realm.executeTransactionAsync(new Realm.Transaction() {

                @Override
                public void execute(Realm realm) {
                    realm.createObject(AllTypes.class);
                }
            });
        }
    });
    TestHelper.awaitOrFail(signalTestFinished);
}

55. PassphraseCacheService#getCachedPassphrase()

Project: open-keychain
File: PassphraseCacheService.java
/**
     * Gets a cached passphrase from memory by sending an intent to the service. This method is
     * designed to wait until the service returns the passphrase.
     *
     * @return passphrase or null (if no passphrase is cached for this keyId)
     */
public static Passphrase getCachedPassphrase(Context context, long masterKeyId, long subKeyId) throws KeyNotFoundException {
    Log.d(Constants.TAG, "PassphraseCacheService.getCachedPassphrase() for masterKeyId " + masterKeyId + ", subKeyId " + subKeyId);
    Intent intent = new Intent(context, PassphraseCacheService.class);
    intent.setAction(ACTION_PASSPHRASE_CACHE_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getPassphraseThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_KEY_ID, masterKeyId);
    intent.putExtra(EXTRA_SUBKEY_ID, subKeyId);
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_PASSPHRASE_CACHE_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_PASSPHRASE);
        case MSG_PASSPHRASE_CACHE_GET_KEY_NOT_FOUND:
            throw new KeyNotFoundException();
        default:
            Log.e(Constants.TAG, "timeout case!");
            throw new KeyNotFoundException("should not happen!");
    }
}

56. CryptoInputParcelCacheService#getCryptoInputParcel()

Project: open-keychain
File: CryptoInputParcelCacheService.java
private static CryptoInputParcel getCryptoInputParcel(Context context, UUID uuid) throws InputParcelNotFound {
    Intent intent = new Intent(context, CryptoInputParcelCacheService.class);
    intent.setAction(ACTION_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getParcelableThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_UUID1, uuid.getMostSignificantBits());
    intent.putExtra(EXTRA_UUID2, uuid.getLeastSignificantBits());
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_CRYPTO_INPUT_PARCEL);
        case MSG_GET_NOT_FOUND:
            throw new InputParcelNotFound();
        default:
            Log.e(Constants.TAG, "timeout!");
            throw new InputParcelNotFound("should not happen!");
    }
}

57. DownloadManagerService#onCreate()

Project: NewPipe
File: DownloadManagerService.java
@Override
public void onCreate() {
    super.onCreate();
    if (DEBUG) {
        Log.d(TAG, "onCreate");
    }
    mBinder = new DMBinder();
    if (mManager == null) {
        String path = NewPipeSettings.getVideoDownloadPath(this);
        mManager = new DownloadManagerImpl(this, path);
        if (DEBUG) {
            Log.d(TAG, "mManager == null");
            Log.d(TAG, "Download directory: " + path);
        }
    }
    Intent i = new Intent();
    i.setAction(Intent.ACTION_MAIN);
    i.setClass(this, MainActivity.class);
    Drawable icon = this.getResources().getDrawable(R.mipmap.ic_launcher);
    Builder builder = new Builder(this).setContentIntent(PendingIntent.getActivity(this, 0, i, 0)).setSmallIcon(android.R.drawable.stat_sys_download).setLargeIcon(((BitmapDrawable) icon).getBitmap()).setContentTitle(getString(R.string.msg_running)).setContentText(getString(R.string.msg_running_detail));
    PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class).setAction(MainActivity.INTENT_LIST), PendingIntent.FLAG_UPDATE_CURRENT);
    builder.setContentIntent(pendingIntent);
    mNotification = builder.build();
    HandlerThread thread = new HandlerThread("ServiceMessenger");
    thread.start();
    mHandler = new Handler(thread.getLooper()) {

        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 0) {
                int runningCount = 0;
                for (int i = 0; i < mManager.getCount(); i++) {
                    if (mManager.getMission(i).running) {
                        runningCount++;
                    }
                }
                updateState(runningCount);
            }
        }
    };
}

58. PaletteLoader#setupHandlers()

Project: narrate-android
File: PaletteLoader.java
private static void setupHandlers(Context context) {
    HandlerThread handlerThread = new HandlerThread("palette-loader-background");
    handlerThread.start();
    backgroundHandler = new Handler(handlerThread.getLooper(), sCallback);
    uiHandler = new Handler(context.getMainLooper(), sCallback);
}

59. PhotosGridFragment#onCreate()

Project: narrate-android
File: PhotosGridFragment.java
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setMenuItems(R.menu.entries_grid);
    HandlerThread handlerThread = new HandlerThread("EntriesGrid.background");
    handlerThread.start();
    mBackgroundHandler = new Handler(handlerThread.getLooper(), this);
}

60. PersistentIntentService#onCreate()

Project: MozStumbler
File: PersistentIntentService.java
@Override
public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

61. BlurActivity#onCreate()

Project: LiveBlurListView
File: BlurActivity.java
@Override
public void onCreate(Bundle savedInstanceState) {
    canSetTranslucentFlag();
    mActionBar = getActionBar();
    mActionBar.hide();
    //mActionBar.setDisplayShowCustomEnabled(true);
    //mActionBar.setBackgroundDrawable(null);
    //TextView v = new TextView(this);
    //v.setText("hello world");
    //v.setTextSize(25);
    //LayoutParams l = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    //mActionBar.setCustomView(v, l);
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_blur);
    sCollator = Collator.getInstance();
    mUIHandler = new Handler(this.getMainLooper());
    mList = (LiveBlurListView) findViewById(R.id.list);
    mApplications = new ArrayList<AppInfo>();
    mApplicationsAdapter = new ApplicationsAdapter(this, mApplications);
    mList.setAdapter(mApplicationsAdapter);
    mList.setOnItemClickListener(this);
    mApplicationsLoader = new ApplicationsLoader(this);
    HandlerThread mthread = new HandlerThread("launcher");
    mthread.start();
    mHandler = new Handler(mthread.getLooper());
    mHandler.postDelayed(mApplicationsLoader, 500);
}

62. GroundyService#onCreate()

Project: groundy
File: GroundyService.java
@Override
public void onCreate() {
    super.onCreate();
    updateModeFromMetadata();
    HandlerThread thread = new HandlerThread("SyncGroundyService");
    thread.start();
    mGroundyLooper = thread.getLooper();
    mGroundyHandler = new GroundyHandler(mGroundyLooper);
}

63. JobServiceTest#testOnStartCommand_handlesStartJob_validRequest()

Project: firebase-jobdispatcher-android
File: JobServiceTest.java
@Test
public void testOnStartCommand_handlesStartJob_validRequest() throws InterruptedException {
    JobService service = spy(new ExampleJobService());
    HandlerThread ht = new HandlerThread("handler");
    ht.start();
    Handler h = new Handler(ht.getLooper());
    Intent executeJobIntent = new Intent(JobService.ACTION_EXECUTE);
    Job jobSpec = TestUtil.getBuilderWithNoopValidator().setTag("tag").setService(ExampleJobService.class).setRetryStrategy(RetryStrategy.DEFAULT_EXPONENTIAL).setTrigger(Trigger.NOW).setLifetime(Lifetime.FOREVER).build();
    countDownLatch = new CountDownLatch(1);
    ((JobService.LocalBinder) service.onBind(executeJobIntent)).getService().start(jobSpec, h.obtainMessage(ExternalReceiver.JOB_FINISHED, jobSpec));
    assertTrue("Expected job to run to completion", countDownLatch.await(5, TimeUnit.SECONDS));
}

64. MPDAsyncWorker#startThread()

Project: dmix
File: MPDAsyncWorker.java
/**
     * Initiates the worker thread {@code Handler} in an off UI thread {@code Looper}.
     *
     * @return A {@code Handler} for this object.
     */
final Handler startThread() {
    final HandlerThread handlerThread = new HandlerThread("MPDAsyncWorker");
    handlerThread.start();
    mWorkerHandler = new Handler(handlerThread.getLooper(), this);
    return mWorkerHandler;
}

65. SensorTest#testBatchAndFlushWithHandler()

Project: CtsVerifier
File: SensorTest.java
/**
     * Verifies that sensor events arrive in the given message queue (Handler).
     */
@TimeoutReq(minutes = 10)
public void testBatchAndFlushWithHandler() throws Exception {
    Sensor sensor = null;
    for (Sensor s : mSensorList) {
        if (s.getReportingMode() == Sensor.REPORTING_MODE_CONTINUOUS) {
            sensor = s;
            break;
        }
    }
    if (sensor == null) {
        throw new SensorTestStateNotSupportedException("There are no Continuous sensors in the device.");
    }
    TestSensorEnvironment environment = new TestSensorEnvironment(getContext(), sensor, SensorManager.SENSOR_DELAY_FASTEST, (int) TimeUnit.SECONDS.toMicros(5));
    TestSensorManager sensorManager = new TestSensorManager(environment);
    HandlerThread handlerThread = new HandlerThread("sensorThread");
    handlerThread.start();
    Handler handler = new Handler(handlerThread.getLooper());
    TestSensorEventListener listener = new TestSensorEventListener(environment, handler);
    CountDownLatch eventLatch = sensorManager.registerListener(listener, 1);
    listener.waitForEvents(eventLatch, 1);
    CountDownLatch flushLatch = sensorManager.requestFlush();
    listener.waitForFlushComplete(flushLatch);
    listener.assertEventsReceivedInHandler();
}

66. PassphraseCacheService#getCachedPassphrase()

Project: apg
File: PassphraseCacheService.java
/**
     * Gets a cached passphrase from memory by sending an intent to the service. This method is
     * designed to wait until the service returns the passphrase.
     *
     * @return passphrase or null (if no passphrase is cached for this keyId)
     */
public static Passphrase getCachedPassphrase(Context context, long masterKeyId, long subKeyId) throws KeyNotFoundException {
    Log.d(Constants.TAG, "PassphraseCacheService.getCachedPassphrase() for masterKeyId " + masterKeyId + ", subKeyId " + subKeyId);
    Intent intent = new Intent(context, PassphraseCacheService.class);
    intent.setAction(ACTION_PASSPHRASE_CACHE_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getPassphraseThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_KEY_ID, masterKeyId);
    intent.putExtra(EXTRA_SUBKEY_ID, subKeyId);
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_PASSPHRASE_CACHE_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_PASSPHRASE);
        case MSG_PASSPHRASE_CACHE_GET_KEY_NOT_FOUND:
            throw new KeyNotFoundException();
        default:
            Log.e(Constants.TAG, "timeout case!");
            throw new KeyNotFoundException("should not happen!");
    }
}

67. CryptoInputParcelCacheService#getCryptoInputParcel()

Project: apg
File: CryptoInputParcelCacheService.java
private static CryptoInputParcel getCryptoInputParcel(Context context, UUID uuid) throws InputParcelNotFound {
    Intent intent = new Intent(context, CryptoInputParcelCacheService.class);
    intent.setAction(ACTION_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getParcelableThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_UUID1, uuid.getMostSignificantBits());
    intent.putExtra(EXTRA_UUID2, uuid.getLeastSignificantBits());
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_CRYPTO_INPUT_PARCEL);
        case MSG_GET_NOT_FOUND:
            throw new InputParcelNotFound();
        default:
            Log.e(Constants.TAG, "timeout!");
            throw new InputParcelNotFound("should not happen!");
    }
}

68. MessageCenterService#createIdleHandler()

Project: androidclient
File: MessageCenterService.java
private void createIdleHandler() {
    HandlerThread thread = new HandlerThread("IdleThread", Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    int refCount = Kontalk.get(this).getReferenceCounter();
    mIdleHandler = new IdleConnectionHandler(this, refCount, thread.getLooper());
}

69. MqttService#onCreate()

Project: android-mqtt
File: MqttService.java
/**
     * Initalizes the DeviceId and most instance variables
     * Including the Connection Handler, Datastore, Alarm Manager
     * and ConnectivityManager.
     */
@Override
public void onCreate() {
    super.onCreate();
    mDeviceId = String.format(DEVICE_ID_FORMAT, Secure.getString(getContentResolver(), Secure.ANDROID_ID));
    HandlerThread thread = new HandlerThread(MQTT_THREAD_NAME);
    thread.start();
    mConnHandler = new Handler(thread.getLooper());
    try {
        mDataStore = new MqttDefaultFilePersistence(getCacheDir().getAbsolutePath());
    } catch (MqttPersistenceException e) {
        e.printStackTrace();
        mDataStore = null;
        mMemStore = new MemoryPersistence();
    }
    mOpts = new MqttConnectOptions();
    mOpts.setCleanSession(MQTT_CLEAN_SESSION);
    // Do not set keep alive interval on mOpts we keep track of it with alarm's
    mAlarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
    mConnectivityManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
}

70. DecoderThread#start()

Project: zxing-android-embedded
File: DecoderThread.java
/**
     * Start decoding.
     *
     * This must be called from the UI thread.
     */
public void start() {
    Util.validateMainThread();
    thread = new HandlerThread(TAG);
    thread.start();
    handler = new Handler(thread.getLooper(), callback);
    running = true;
    requestNextPreview();
}

71. ChatWindow#onCreate()

Project: yaxim
File: ChatWindow.java
@Override
public void onCreate(Bundle savedInstanceState) {
    setTheme(YaximApplication.getConfig(this).getTheme());
    super.onCreate(savedInstanceState);
    mChatFontSize = Integer.valueOf(YaximApplication.getConfig(this).chatFontSize);
    requestWindowFeature(Window.FEATURE_ACTION_BAR);
    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED);
    setContentView(R.layout.mainchat);
    getContentResolver().registerContentObserver(RosterProvider.CONTENT_URI, true, mContactObserver);
    actionBar = getSupportActionBar();
    actionBar.setHomeButtonEnabled(true);
    actionBar.setDisplayHomeAsUpEnabled(true);
    setContactFromUri();
    // Setup the actual chat view
    mListView = (ListView) findViewById(android.R.id.list);
    mChatAdapter = new ChatWindowAdapter(null, PROJECTION_FROM, PROJECTION_TO, mWithJabberID, mUserScreenName);
    mListView.setAdapter(mChatAdapter);
    Log.d(TAG, "registrs for contextmenu...");
    registerForContextMenu(mListView);
    registerXMPPService();
    setSendButton();
    setUserInput();
    String titleUserid;
    if (mUserScreenName != null) {
        titleUserid = mUserScreenName;
    } else {
        titleUserid = mWithJabberID;
    }
    setCustomTitle(titleUserid);
    // Setup the loader
    getSupportLoaderManager().initLoader(CHAT_MSG_LOADER, null, this);
    // Loading progress
    mLoadingProgress = (ProgressBar) findViewById(R.id.loading_progress);
    mLoadingProgress.setVisibility(View.VISIBLE);
    mMarkThread = new HandlerThread("MarkAsReadThread: " + mWithJabberID);
    mMarkThread.start();
    mMarkHandler = new Handler(mMarkThread.getLooper());
}

72. ScreencastDispatcher#startScreencast()

Project: weex
File: ScreencastDispatcher.java
public void startScreencast(JsonRpcPeer peer, Page.StartScreencastRequest request) {
    LogUtil.d("Starting screencast");
    mRequest = request;
    mHandlerThread = new HandlerThread("Screencast Thread");
    mHandlerThread.start();
    mPeer = peer;
    mIsRunning = true;
    mStream = new ByteArrayOutputStream();
    mBackgroundHandler = new Handler(mHandlerThread.getLooper());
    mMainHandler.postDelayed(mBitmapFetchRunnable, FRAME_DELAY);
}

73. DelayedEventsTest#setUp()

Project: tinybus
File: DelayedEventsTest.java
@Override
protected void setUp() throws Exception {
    super.setUp();
    bus = null;
    mainThread = new HandlerThread("tinybus-test-mainthread");
    mainThread.start();
    handler = new Handler(mainThread.getLooper());
}

74. ScreencastDispatcher#startScreencast()

Project: stetho
File: ScreencastDispatcher.java
public void startScreencast(JsonRpcPeer peer, Page.StartScreencastRequest request) {
    LogUtil.d("Starting screencast");
    mRequest = request;
    mHandlerThread = new HandlerThread("Screencast Thread");
    mHandlerThread.start();
    mPeer = peer;
    mIsRunning = true;
    mStream = new ByteArrayOutputStream();
    mBackgroundHandler = new Handler(mHandlerThread.getLooper());
    mMainHandler.postDelayed(mBitmapFetchRunnable, FRAME_DELAY);
}

75. Camera2Renderer#startBackgroundThread()

Project: opencv-android-sample-master
File: Camera2Renderer.java
private void startBackgroundThread() {
    Log.i(LOGTAG, "startBackgroundThread");
    stopBackgroundThread();
    mBackgroundThread = new HandlerThread("CameraBackground");
    mBackgroundThread.start();
    mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}

76. MusicService#onCreate()

Project: Muzesto
File: MusicService.java
@Override
public void onCreate() {
    if (D)
        Log.d(TAG, "Creating service");
    super.onCreate();
    mNotificationManager = NotificationManagerCompat.from(this);
    // gets a pointer to the playback state store
    mPlaybackStateStore = MusicPlaybackState.getInstance(this);
    mSongPlayCount = SongPlayCount.getInstance(this);
    mRecentStore = RecentStore.getInstance(this);
    mHandlerThread = new HandlerThread("MusicPlayerHandler", android.os.Process.THREAD_PRIORITY_BACKGROUND);
    mHandlerThread.start();
    mPlayerHandler = new MusicPlayerHandler(this, mHandlerThread.getLooper());
    mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
    mMediaButtonReceiverComponent = new ComponentName(getPackageName(), MediaButtonIntentReceiver.class.getName());
    mAudioManager.registerMediaButtonEventReceiver(mMediaButtonReceiverComponent);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
        setUpMediaSession();
    mPreferences = getSharedPreferences("Service", 0);
    mCardId = getCardId();
    registerExternalStorageListener();
    mPlayer = new MultiPlayer(this);
    mPlayer.setHandler(mPlayerHandler);
    // Initialize the intent filter and each action
    final IntentFilter filter = new IntentFilter();
    filter.addAction(SERVICECMD);
    filter.addAction(TOGGLEPAUSE_ACTION);
    filter.addAction(PAUSE_ACTION);
    filter.addAction(STOP_ACTION);
    filter.addAction(NEXT_ACTION);
    filter.addAction(PREVIOUS_ACTION);
    filter.addAction(PREVIOUS_FORCE_ACTION);
    filter.addAction(REPEAT_ACTION);
    filter.addAction(SHUFFLE_ACTION);
    // Attach the broadcast listener
    registerReceiver(mIntentReceiver, filter);
    mMediaStoreObserver = new MediaStoreObserver(mPlayerHandler);
    getContentResolver().registerContentObserver(MediaStore.Audio.Media.INTERNAL_CONTENT_URI, true, mMediaStoreObserver);
    getContentResolver().registerContentObserver(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, true, mMediaStoreObserver);
    // Initialize the wake lock
    final PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
    mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, getClass().getName());
    mWakeLock.setReferenceCounted(false);
    final Intent shutdownIntent = new Intent(this, MusicService.class);
    shutdownIntent.setAction(SHUTDOWN);
    mAlarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    mShutdownIntent = PendingIntent.getService(this, 0, shutdownIntent, 0);
    scheduleDelayedShutdown();
    reloadQueueAfterPermissionCheck();
    notifyChange(QUEUE_CHANGED);
    notifyChange(META_CHANGED);
}

77. Camera2Fragment#startBackgroundThread()

Project: material-camera
File: Camera2Fragment.java
/**
     * Starts a background thread and its {@link Handler}.
     */
private void startBackgroundThread() {
    mBackgroundThread = new HandlerThread("CameraBackground");
    mBackgroundThread.start();
    mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}

78. CameraFragment#startBackgroundThread()

Project: io2015-codelabs
File: CameraFragment.java
/**
     * Starts a background thread and its {@link Handler}.
     */
private void startBackgroundThread() {
    Log.d(TAG, "startBackgroundThread: ");
    mBackgroundThread = new HandlerThread("CameraBackground");
    mBackgroundThread.start();
    mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}

79. CameraFragment#startBackgroundThread()

Project: io2015-codelabs
File: CameraFragment.java
/**
     * Starts a background thread and its {@link Handler}.
     */
private void startBackgroundThread() {
    Log.d(TAG, "startBackgroundThread: ");
    mBackgroundThread = new HandlerThread("CameraBackground");
    mBackgroundThread.start();
    mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}

80. GVRContext#setUseTheFrameworkThread()

Project: GearVRf
File: GVRContext.java
void setUseTheFrameworkThread(boolean useTheFrameworkThread) {
    if (null != mHandlerThread) {
        throw new IllegalStateException();
    }
    mUseTheFrameworkThread = useTheFrameworkThread;
    mHandlerThread = new HandlerThread("gvrf-main");
    mHandlerThread.start();
    mHandler = new Handler(mHandlerThread.getLooper());
}

81. TextTrackRenderer#onEnabled()

Project: ExoPlayer
File: TextTrackRenderer.java
@Override
protected void onEnabled(int track, long positionUs, boolean joining) throws ExoPlaybackException {
    super.onEnabled(track, positionUs, joining);
    parserIndex = getParserIndex(getFormat(track));
    parserThread = new HandlerThread("textParser");
    parserThread.start();
    parserHelper = new SubtitleParserHelper(parserThread.getLooper(), subtitleParsers[parserIndex]);
}

82. SOSOLocationActivity#onCreate()

Project: demo-app-android-v2
File: SOSOLocationActivity.java
@Override
protected /**
     *????????????????MapController?????????Zoom??
     */
void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.de_ac_soso_map);
    mHandlerThread = new HandlerThread("LocationThread");
    mHandlerThread.start();
    mWorkHandler = new Handler(mHandlerThread.getLooper());
    mHandler = new Handler(this);
    mMapView = (MapView) findViewById(android.R.id.widget_frame);
    mTitle = (TextView) findViewById(android.R.id.title);
    mButton = (Button) this.findViewById(android.R.id.button1);
    if (getIntent().hasExtra("location")) {
        mMsg = getIntent().getParcelableExtra("location");
    }
    if (mMsg != null)
        mButton.setVisibility(View.GONE);
    mButton.setOnClickListener(this);
    // ???????????
    mMapView.getUiSettings().setAnimationEnabled(true);
    if (mMsg == null) {
        // ???????????GeoPoint??????
        GeoPoint point = new GeoPoint((int) (39.90923 * 1E6), (int) (116.397428 * 1E6));
        mMapView.getController().setCenter(point);
        mMapView.getMap().setZoom(16);
        mMapView.setOnTouchListener(this);
        TencentLocationRequest request = TencentLocationRequest.create();
        TencentLocationManager.getInstance(this).requestLocationUpdates(request, this);
    } else {
        LatLng latLng = new LatLng((mMsg.getLat()), (mMsg.getLng()));
        mMapView.getMap().setZoom(16);
        SOSOPoiItem sosoPoiItem = new SOSOPoiItem();
        sosoPoiItem.setName(mMsg.getPoi());
        sosoPoiItem.setLat((mMsg.getLat() * 1E6));
        sosoPoiItem.setLng((mMsg.getLng() * 1E6));
        mHandler.obtainMessage(RENDER_POI, sosoPoiItem).sendToTarget();
        findViewById(android.R.id.icon).setVisibility(View.GONE);
        mMapView.getMap().animateTo(latLng);
    }
}

83. DanmakuView#getLooper()

Project: DanmakuFlameMaster
File: DanmakuView.java
protected Looper getLooper(int type) {
    if (mHandlerThread != null) {
        mHandlerThread.quit();
        mHandlerThread = null;
    }
    int priority;
    switch(type) {
        case THREAD_TYPE_MAIN_THREAD:
            return Looper.getMainLooper();
        case THREAD_TYPE_HIGH_PRIORITY:
            priority = android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY;
            break;
        case THREAD_TYPE_LOW_PRIORITY:
            priority = android.os.Process.THREAD_PRIORITY_LOWEST;
            break;
        case THREAD_TYPE_NORMAL_PRIORITY:
        default:
            priority = android.os.Process.THREAD_PRIORITY_DEFAULT;
            break;
    }
    String threadName = "DFM Handler Thread #" + priority;
    mHandlerThread = new HandlerThread(threadName, priority);
    mHandlerThread.start();
    return mHandlerThread.getLooper();
}

84. DanmakuTextureView#getLooper()

Project: DanmakuFlameMaster
File: DanmakuTextureView.java
protected Looper getLooper(int type) {
    if (mHandlerThread != null) {
        mHandlerThread.quit();
        mHandlerThread = null;
    }
    int priority;
    switch(type) {
        case THREAD_TYPE_MAIN_THREAD:
            return Looper.getMainLooper();
        case THREAD_TYPE_HIGH_PRIORITY:
            priority = android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY;
            break;
        case THREAD_TYPE_LOW_PRIORITY:
            priority = android.os.Process.THREAD_PRIORITY_LOWEST;
            break;
        case THREAD_TYPE_NORMAL_PRIORITY:
        default:
            priority = android.os.Process.THREAD_PRIORITY_DEFAULT;
            break;
    }
    String threadName = "DFM Handler Thread #" + priority;
    mHandlerThread = new HandlerThread(threadName, priority);
    mHandlerThread.start();
    return mHandlerThread.getLooper();
}

85. DanmakuSurfaceView#getLooper()

Project: DanmakuFlameMaster
File: DanmakuSurfaceView.java
protected Looper getLooper(int type) {
    if (mHandlerThread != null) {
        mHandlerThread.quit();
        mHandlerThread = null;
    }
    int priority;
    switch(type) {
        case THREAD_TYPE_MAIN_THREAD:
            return Looper.getMainLooper();
        case THREAD_TYPE_HIGH_PRIORITY:
            priority = android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY;
            break;
        case THREAD_TYPE_LOW_PRIORITY:
            priority = android.os.Process.THREAD_PRIORITY_LOWEST;
            break;
        case THREAD_TYPE_NORMAL_PRIORITY:
        default:
            priority = android.os.Process.THREAD_PRIORITY_DEFAULT;
            break;
    }
    String threadName = "DFM Handler Thread #" + priority;
    mHandlerThread = new HandlerThread(threadName, priority);
    mHandlerThread.start();
    return mHandlerThread.getLooper();
}

86. DraggerTest#setUp()

Project: blockly-android
File: DraggerTest.java
@Override
public void setUp() throws Exception {
    super.setUp();
    mThread = new HandlerThread("DraggerTest");
    mThread.start();
    mHandler = new Handler(mThread.getLooper());
    mMockContext = Mockito.mock(Context.class, AdditionalAnswers.delegatesTo(getContext()));
    Mockito.doReturn(mThread.getLooper()).when(mMockContext).getMainLooper();
    runAndSync(new Runnable() {

        @Override
        public void run() {
            mBlockFactory = new BlockFactory(mMockContext, new int[] { R.raw.test_blocks });
            mWorkspaceView = new WorkspaceView(mMockContext);
            mWorkspaceHelper = new WorkspaceHelper(mMockContext);
            mWorkspaceHelper.setWorkspaceView(mWorkspaceView);
            mViewFactory = new VerticalBlockViewFactory(mMockContext, mWorkspaceHelper);
            // The following are queried by the Dragger.
            Mockito.stub(mMockWorkspace.getConnectionManager()).toReturn(mMockConnectionManager);
            Mockito.stub(mMockController.getBlockFactory()).toReturn(mBlockFactory);
            Mockito.stub(mMockController.getWorkspace()).toReturn(mMockWorkspace);
            Mockito.stub(mMockController.getWorkspaceHelper()).toReturn(mWorkspaceHelper);
            mDragger = new Dragger(mMockController);
            mDragger.setWorkspaceView(mWorkspaceView);
            mTouchHandler = mDragger.buildSloppyBlockTouchHandler(mDragHandler);
            // Since we can't create DragEvents...
            when(mDragStartedEvent.getAction()).thenReturn(DragEvent.ACTION_DRAG_STARTED);
            when(mDragLocationEvent.getAction()).thenReturn(DragEvent.ACTION_DRAG_LOCATION);
        }
    }, TIMEOUT);
}

87. WebSocketConnection#createWriter()

Project: autobahn-android
File: WebSocketConnection.java
/**
    * Create WebSockets background writer.
    */
protected void createWriter() {
    mWriterThread = new HandlerThread("WebSocketWriter");
    mWriterThread.start();
    mWriter = new WebSocketWriter(mWriterThread.getLooper(), mMasterHandler, mTransportChannel, mOptions);
    if (DEBUG)
        Log.d(TAG, "WS writer created and started");
}

88. WampConnection#createWriter()

Project: autobahn-android
File: WampConnection.java
/**
    * Create the connection transmitting leg writer.
    */
protected void createWriter() {
    mWriterThread = new HandlerThread("AutobahnWriter");
    mWriterThread.start();
    mWriter = new WampWriter(mWriterThread.getLooper(), mMasterHandler, mTransportChannel, mOptions);
    if (DEBUG)
        Log.d(TAG, "writer created and started");
}

89. WeakHandlerTest#setup()

Project: android-weak-handler
File: WeakHandlerTest.java
@Before
public void setup() {
    mThread = new HandlerThread("test");
    mThread.start();
    mHandler = new WeakHandler(mThread.getLooper());
}