FileDocCategorySizeDatePackage
HeadsetObserver.javaAPI DocAndroid 1.5 API4919Wed May 06 22:42:00 BST 2009com.android.server

HeadsetObserver

public class HeadsetObserver extends android.os.UEventObserver

HeadsetObserver monitors for a wired headset.

Fields Summary
private static final String
TAG
private static final String
HEADSET_UEVENT_MATCH
private static final String
HEADSET_STATE_PATH
private static final String
HEADSET_NAME_PATH
private android.content.Context
mContext
private int
mHeadsetState
private String
mHeadsetName
private boolean
mAudioRouteNeedsUpdate
private android.media.AudioManager
mAudioManager
private final android.os.Handler
mHandler
Constructors Summary
public HeadsetObserver(android.content.Context context)


       
        mContext = context;

        startObserving(HEADSET_UEVENT_MATCH);

        init();  // set initial status
    
Methods Summary
private final synchronized voidinit()

        char[] buffer = new char[1024];

        String newName = mHeadsetName;
        int newState = mHeadsetState;
        try {
            FileReader file = new FileReader(HEADSET_STATE_PATH);
            int len = file.read(buffer, 0, 1024);
            newState = Integer.valueOf((new String(buffer, 0, len)).trim());

            file = new FileReader(HEADSET_NAME_PATH);
            len = file.read(buffer, 0, 1024);
            newName = new String(buffer, 0, len).trim();

        } catch (FileNotFoundException e) {
            Log.w(TAG, "This kernel does not have wired headset support");
        } catch (Exception e) {
            Log.e(TAG, "" , e);
        }

        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
        update(newName, newState);
    
public voidonUEvent(UEventObserver.UEvent event)

        Log.v(TAG, "Headset UEVENT: " + event.toString());

        try {
            update(event.get("SWITCH_NAME"), Integer.parseInt(event.get("SWITCH_STATE")));
        } catch (NumberFormatException e) {
            Log.e(TAG, "Could not parse switch state from event " + event);
        }
    
private final synchronized voidsendIntent(boolean isUnplug)

        //  Pack up the values and broadcast them to everyone
        Intent intent = new Intent(Intent.ACTION_HEADSET_PLUG);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);

        intent.putExtra("state", mHeadsetState);
        intent.putExtra("name", mHeadsetName);

        // TODO: Should we require a permission?
        ActivityManagerNative.broadcastStickyIntent(intent, null);

        if (isUnplug) {
            intent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
            mContext.sendBroadcast(intent);
        }
    
private final synchronized voidupdate(java.lang.String newName, int newState)

        if (newName != mHeadsetName || newState != mHeadsetState) {
            boolean isUnplug = (newState == 0 && mHeadsetState == 1);
            mHeadsetName = newName;
            mHeadsetState = newState;
            mAudioRouteNeedsUpdate = true;

            sendIntent(isUnplug);

            if (isUnplug) {
                // It can take hundreds of ms flush the audio pipeline after
                // apps pause audio playback, but audio route changes are
                // immediate, so delay the route change by 1000ms.
                // This could be improved once the audio sub-system provides an
                // interface to clear the audio pipeline.
                mHandler.sendEmptyMessageDelayed(0, 1000);
            } else {
                updateAudioRoute();
            }
        }
    
private final synchronized voidupdateAudioRoute()

        if (mAudioRouteNeedsUpdate) {
            mAudioManager.setWiredHeadsetOn(mHeadsetState == 1);
            mAudioRouteNeedsUpdate = false;
        }