Java Code Examples for android.os.HandlerThread#getLooper()

public InternalHandler(
    HandlerThread thread,
    WritableDownloadIndex downloadIndex,
    DownloaderFactory downloaderFactory,
    Handler mainHandler,
    int maxParallelDownloads,
    int minRetryCount,
    boolean downloadsPaused) {
  super(thread.getLooper());
  this.thread = thread;
  this.downloadIndex = downloadIndex;
  this.downloaderFactory = downloaderFactory;
  this.mainHandler = mainHandler;
  this.maxParallelDownloads = maxParallelDownloads;
  this.minRetryCount = minRetryCount;
  this.downloadsPaused = downloadsPaused;
  downloads = new ArrayList<>();
  activeTasks = new HashMap<>();
}
 

private Handler createHandler() {
    final HandlerThread handlerThread = new HandlerThread("ThreadPool#WorkerThread-" + hashCode()) {
        @Override
        protected void onLooperPrepared() {
            Log.i(TAG, "createHandler(id : %d), onLooperPrepared", getThreadId());
        }
    };
    handlerThread.start();
    Handler handler = new Handler(handlerThread.getLooper());
    handler.post(new Runnable() {
        @Override
        public void run() {
            Log.i(TAG, "createHandler(id : %d)", handlerThread.getThreadId());
        }
    });
    return handler;
}
 

public CTABTestController(Context context, CleverTapInstanceConfig config, String guid, CTABTestListener listener) {
    this.varCache = new CTVarCache();
    this.enableEditor = config.isUIEditorEnabled();
    this.config = config;
    this.guid = guid;
    this.setListener(listener);
    this.uiEditor = new UIEditor(context, config);

    final HandlerThread thread = new HandlerThread(CTABTestController.class.getCanonicalName());
    thread.setPriority(Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    executionThreadHandler = new ExecutionThreadHandler(context, config, thread.getLooper());
    executionThreadHandler.start();

    if (enableEditor) {
        final Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    } else {
        config.getLogger().debug(config.getAccountId(), "UIEditor connection is disabled");
    }
    applyStoredExperiments();
}
 

CameraImplV2(Activity context, TextureView prevView, boolean cameraFallback) throws CameraException {
    super(context, prevView);

    mCamManager = (CameraManager) mActivity.getSystemService(Context.CAMERA_SERVICE);
    if (mCamManager == null) {
        throw new CameraException(mActivity.getString(R.string.couldNotObtainCameraService));
    }

    try {
        findCameraFacing(CameraCharacteristics.LENS_FACING_FRONT);

        if (mCameraId == null && cameraFallback) {
            findCameraFacing(CameraCharacteristics.LENS_FACING_BACK);
        }
    } catch (CameraAccessException e) {
        throw new CameraException(e);
    }

    if (mCameraId == null) {
        if (cameraFallback) {
            throw new CameraException(mActivity.getString(R.string.cameraMissing));
        } else {
            throw new CameraException(mActivity.getString(R.string.frontCameraMissing));
        }
    }

    mPreviewThread = new HandlerThread("previewThread");
    mPreviewThread.start();
    mPreviewHandler = new Handler(mPreviewThread.getLooper());
}
 

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    prefManager = new VideoPrefs(getContext());
    permissionListener = this;

    final HandlerThread handlerThread = new HandlerThread("BulkDownloadBgThread");
    handlerThread.start();
    bgThreadHandler = new Handler(handlerThread.getLooper());

    ViewCompat.setImportantForAccessibility(binding.getRoot(), ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO);
    ViewCompat.setImportantForAccessibility(binding.ivIcon, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO);
    ViewCompat.setImportantForAccessibility(binding.tvTitle, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO);
    ViewCompat.setImportantForAccessibility(binding.tvSubtitle, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO);
    ViewCompat.setImportantForAccessibility(binding.pbDownload, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO);
    ViewCompat.setImportantForAccessibility(binding.swDownload, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
    initDownloadSwitch();
    if (totalDownloadableVideos != null && videosStatus.courseComponentId != null) {
        populateViewHolder(downloadListener, videosStatus.courseComponentId, totalDownloadableVideos);
    }
    if (bulkDownloadWasCancelled) {
        onEvent(new BulkVideosDownloadCancelledEvent());
        bulkDownloadWasCancelled = false;
    }
    if (bulkDownloadWasStarted) {
        onEvent(new BulkVideosDownloadStartedEvent());
        bulkDownloadWasStarted = false;
    }
}
 

@Override
public synchronized void onResume() {
    Log.d(TAG, "onResume " + this);
    super.onResume();

    handlerThread = new HandlerThread("inference");
    handlerThread.start();
    handler = new Handler(handlerThread.getLooper());
}
 

@Override
public void onCreate()
{
	HandlerThread thread = new HandlerThread("ServiceStartArguments", android.os.Process.THREAD_PRIORITY_BACKGROUND);
	thread.start();

	mServiceLooper = thread.getLooper();
	mServiceHandler = new ServiceHandler(mServiceLooper, new WeakReference<Service>(this));
}
 

@Override
public void onCreate() {
    HandlerThread thread = new HandlerThread(
            "ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

    serviceLooper = thread.getLooper();
    serviceHandler = createServiceHandler(serviceLooper, this);
}
 

@Override
public void onCreate() {
  super.onCreate();
  HandlerThread backgroundThread = new HandlerThread("SpeakEasyService");
  backgroundThread.start();
  backgroundLooper = backgroundThread.getLooper();
  backgroundHandler =
      new Handler(backgroundLooper) {
        @Override
        public void handleMessage(Message m) {
          serveIntent((Intent) m.obj, m.arg1);
        }
      };
}
 

/**
 * Starts a background thread and its {@link Handler}.
 */
private void startBackgroundThread() {
  backgroundThread = new HandlerThread("ImageListener");
  backgroundThread.start();
  backgroundHandler = new Handler(backgroundThread.getLooper());
  
  inferenceThread = new HandlerThread("InferenceThread");
  inferenceThread.start();
  inferenceHandler = new Handler(inferenceThread.getLooper());
}
 

public Ringer(Context aContext) {
    context = aContext;
    vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
    ringerThread = new HandlerThread("RingerThread");
    ringerThread.start();
    ringerWorker = new RingWorkerHandler(ringerThread.getLooper());
}
 

public void onCreate() {
    super.onCreate();
    DebugLog.log(TAG, "=======================================Servcie onCreate!");
    HandlerThread thread = new HandlerThread("IntentService[" + this.mName + "]");
    thread.start();
    this.mServiceLooper = thread.getLooper();
    this.mServiceHandler = new ServiceHandler(this.mServiceLooper);
}
 

@Override
public synchronized void onResume() {
  LOGGER.d("onResume " + this);
  super.onResume();

  handlerThread = new HandlerThread("inference");
  handlerThread.start();
  handler = new Handler(handlerThread.getLooper());
}
 

public DiscoveryManager(@NonNull Gson gson,
                        @NonNull ILogger logger,
                        @NonNull IPreferenceManager preferenceManager) {
    mGson = gson;
    mLogger = logger;
    mPreferenceManager = preferenceManager;

    HandlerThread mPacketHandlerThread = new HandlerThread(LOG_TAG);
    mPacketHandlerThread.start();
    mPacketHandler = new Handler(mPacketHandlerThread.getLooper());
    mDiscoveryRunnable = getDiscoveryRunnable();

    mDiscoveredServers = new ArrayMap<>();
    mDiscoveredServersLiveData = new MutableLiveData<>();
}
 

public VideoMediaPlayer() {

        mMediaPlayer = new MediaPlayer();
        mMediaHandlerThread = new HandlerThread(TAG);
        mMediaHandlerThread.start();
        mMediaHandler = new MediaHandler(mMediaHandlerThread.getLooper());
    }
 

/**
 * Starts a background thread and its {@link Handler}.
 */
private void startBackgroundThread() {
  backgroundThread = new HandlerThread("ImageListener");
  backgroundThread.start();
  backgroundHandler = new Handler(backgroundThread.getLooper());
}
 

private BackgroundTaskManager() {
	HandlerThread handlerThread = new HandlerThread("BackgroundTaskManager");
	handlerThread.start();
	backgroundHandler = new BackgroundHandler(handlerThread.getLooper());
}
 

/**
 * Starts a background thread and its {@link Handler}.
 */
private void startBackgroundThread() {
    backgroundThread = new HandlerThread("ImageListener");
    backgroundThread.start();
    backgroundHandler = new Handler(backgroundThread.getLooper());
}
 

/**
 * Starts a background thread and its {@link Handler}.
 */
private void startBackgroundThread() {
    mBackgroundThread = new HandlerThread("CameraBackground");
    mBackgroundThread.start();
    mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}
 

public HandlerThreadWrapper(String threadName) {
    HandlerThread handlerThread = new HandlerThread("BlockCanary-" + threadName);
    handlerThread.start();
    handler = new Handler(handlerThread.getLooper());
}