/src/com/android/bluetooth/avrcp/Avrcp.java

Large files files are truncated, but you can click here to view the full file

/*
 * Copyright (C) 2013-2015, The Linux Foundation. All rights reserved.
 * Not a Contribution.
 *
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.bluetooth.avrcp;

import java.util.Timer;
import java.util.TimerTask;

import android.app.PendingIntent;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothA2dp;
import android.bluetooth.BluetoothAvrcp;
import android.bluetooth.BluetoothDevice;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.content.SharedPreferences;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.media.AudioManager;
import android.media.MediaDescription;
import android.media.MediaMetadata;
import android.media.session.MediaController;
import android.media.session.MediaSessionManager;
import android.media.session.PlaybackState;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.ParcelUuid;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.util.Log;
import android.view.KeyEvent;

import com.android.bluetooth.R;
import android.content.BroadcastReceiver;
import com.android.bluetooth.a2dp.A2dpService;
import com.android.bluetooth.btservice.AdapterService;
import com.android.bluetooth.btservice.ProfileService;
import com.android.bluetooth.Utils;
import com.android.internal.util.IState;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.Iterator;

import android.provider.MediaStore;
import android.content.ContentResolver;
import android.database.Cursor;
import android.database.sqlite.SQLiteException;
import android.net.Uri;

import android.app.Notification;
import android.app.NotificationManager;

import com.android.bluetooth.avrcp.AvrcpControllerService;
import android.os.SystemProperties;

/**
 * support Bluetooth AVRCP profile.
 * support metadata, play status and event notification
 */
public final class Avrcp {
    private static final boolean DEBUG = false;
    private static final String TAG = "Avrcp";
    private static final String ABSOLUTE_VOLUME_BLACKLIST = "absolute_volume_blacklist";

    private Context mContext;
    private final AudioManager mAudioManager;
    private A2dpService mA2dpService;
    private AvrcpMessageHandler mHandler;
    private MediaSessionManager mMediaSessionManager;
    private MediaSessionChangeListener mSessionChangeListener;
    private MediaController mMediaController;
    private MediaControllerListener mMediaControllerCb;
    private MediaAttributes mMediaAttributes;
    private int mTransportControlFlags;
    private PlaybackState mCurrentPlayerState;
    private long mLastStateUpdate;
    private int mPlayStatusChangedNT;
    private int mTrackChangedNT;
    private int mPlayPosChangedNT;
    private long mSongLengthMs;
    private long mPlaybackIntervalMs;
    private long mSkipStartTime;
    
    Resources mResources;

    private int mVolumeStep;
    private final int mAudioStreamMax;
    private static final String BLUETOOTH_ADMIN_PERM = android.Manifest.permission.BLUETOOTH_ADMIN;
    private static final String BLUETOOTH_PERM = android.Manifest.permission.BLUETOOTH;
    private int mSkipAmount;
    private final BluetoothAdapter mAdapter;
    private static Uri mMediaUriStatic;
    private static long currentTrackPos;
    private static boolean updatePlayTime;
    private static boolean updateValues;
    private int mAddressedPlayerId;

    /* BTRC features */
    public static final int BTRC_FEAT_METADATA = 0x01;
    public static final int BTRC_FEAT_ABSOLUTE_VOLUME = 0x02;
    public static final int BTRC_FEAT_BROWSE = 0x04;
    public static final int BTRC_FEAT_AVRC_UI_UPDATE = 0x08;

    /* AVRC response codes, from avrc_defs */
    private static final int AVRC_RSP_NOT_IMPL = 8;
    private static final int AVRC_RSP_ACCEPT = 9;
    private static final int AVRC_RSP_REJ = 10;
    private static final int AVRC_RSP_IN_TRANS = 11;
    private static final int AVRC_RSP_IMPL_STBL = 12;
    private static final int AVRC_RSP_CHANGED = 13;
    private static final int AVRC_RSP_INTERIM = 15;

    private static final int MESSAGE_GET_RC_FEATURES = 1;
    private static final int MESSAGE_GET_PLAY_STATUS = 2;
    private static final int MESSAGE_GET_ELEM_ATTRS = 3;
    private static final int MESSAGE_REGISTER_NOTIFICATION = 4;
    private static final int MESSAGE_PLAY_INTERVAL_TIMEOUT = 5;
    private static final int MESSAGE_VOLUME_CHANGED = 6;
    private static final int MESSAGE_ADJUST_VOLUME = 7;
    private static final int MESSAGE_SET_ABSOLUTE_VOLUME = 8;
    private static final int MESSAGE_ABS_VOL_TIMEOUT = 9;
    private static final int MESSAGE_FAST_FORWARD = 10;
    private static final int MESSAGE_REWIND = 11;
    private static final int MESSAGE_CHANGE_PLAY_POS = 12;
    private static final int MESSAGE_SET_A2DP_AUDIO_STATE = 13;
    private static final int MESSAGE_SET_ADDR_PLAYER_REQ_TIMEOUT = 14;

    private static final int AVRCP_BR_RSP_TIMEOUT = 2000;
    private static final int MESSAGE_SEND_PASS_THROUGH_CMD = 2001;
    private static final int MESSAGE_SET_ADDR_PLAYER = 2002;
    private static final int MESSAGE_GET_FOLDER_ITEMS = 2003;
    private static final int MESSAGE_SET_BROWSED_PLAYER = 2004;
    private static final int MESSAGE_CHANGE_PATH = 2005;
    private static final int MESSAGE_PLAY_ITEM = 2006;
    private static final int MESSAGE_GET_ITEM_ATTRS = 2007;
    private static final int MESSAGE_GET_TOTAL_NUMBER_OF_ITEMS = 2008;

    private CachedRequest mCachedRequest = null;

    private static final int MSG_UPDATE_AVAILABLE_PLAYERS = 201;
    private static final int MSG_UPDATE_ADDRESSED_PLAYER = 202;
    private static final int MSG_UPDATE_RCC_CHANGE = 203;
    private static final int MSG_UPDATE_BROWSED_PLAYER_FOLDER = 204;
    private static final int MSG_UPDATE_NOW_PLAYING_CONTENT_CHANGED = 205;
    private static final int MSG_PLAY_ITEM_RESPONSE = 206;
    private static final int MSG_NOW_PLAYING_ENTRIES_RECEIVED = 207;

    private MediaPlayerInfo mediaPlayerInfo1;
    private MediaPlayerInfo mediaPlayerInfo2;

    private static final int BUTTON_TIMEOUT_TIME = 2000;
    private static final int BASE_SKIP_AMOUNT = 2000;
    private static final int KEY_STATE_PRESS = 1;
    private static final int KEY_STATE_RELEASE = 0;
    private static final int SKIP_PERIOD = 400;
    private static final int SKIP_DOUBLE_INTERVAL = 3000;
    private static final long MAX_MULTIPLIER_VALUE = 128L;
    private static final int CMD_TIMEOUT_DELAY = 2000;
    private static final int MAX_ERROR_RETRY_TIMES = 6;
    private static final int AVRCP_MAX_VOL = 127;
    private static final int AVRCP_BASE_VOLUME_STEP = 1;
    private final static int MESSAGE_PLAYERSETTINGS_TIMEOUT = 602;

    private static final int AVRCP_CONNECTED = 1;
    public static final int KEY_STATE_PRESSED = 0;
    public static final int KEY_STATE_RELEASED = 1;
    public static final int AVRC_ID_VOL_UP = 0x41;
    public static final int AVRC_ID_VOL_DOWN = 0x42;
    private boolean pts_test = false;

    private final static int TYPE_MEDIA_PLAYER_ITEM = 0x01;
    private final static int TYPE_FOLDER_ITEM = 0x02;
    private final static int TYPE_MEDIA_ELEMENT_ITEM = 0x03;

    private final static int FOLDER_UP = 0x00;
    private final static int FOLDER_DOWN = 0x01;

    private static final String PATH_INVALID = "invalid";
    private static final String PATH_ROOT = "root";
    private static final String PATH_TITLES = "titles";
    private static final String PATH_ALBUMS = "albums";
    private static final String PATH_ARTISTS = "artists";
    private static final String PATH_PLAYLISTS = "playlists";

    private final static long UID_TITLES = 0x01;
    private final static long UID_ALBUM = 0x02;
    private final static long UID_ARTIST = 0x03;
    private final static long UID_PLAYLIST = 0x04;
    private final static int NUM_ROOT_ELEMENTS = 0x04;

    private static final int INTERNAL_ERROR = 0x03;
    private static final int OPERATION_SUCCESSFUL = 0x04;
    private static final int INVALID_DIRECTION = 0x07;
    private static final int NOT_A_DIRECTORY = 0x08;
    private static final int DOES_NOT_EXIST = 0x09;
    private static final int INVALID_SCOPE = 0x0a;
    private static final int RANGE_OUT_OF_BOUNDS = 0x0b;
    private static final int UID_A_DIRECTORY = 0x0c;
    private static final int MEDIA_IN_USE = 0x0d;
    private static final int INVALID_PLAYER_ID = 0x11;
    private static final int PLAYER_NOT_BROWSABLE = 0x12;
    private static final int PLAYER_NOT_ADDRESSED = 0x13;

    private static final int FOLDER_TYPE_MIXED = 0x00;
    private static final int FOLDER_TYPE_TITLES = 0x01;
    private static final int FOLDER_TYPE_ALBUMS = 0x02;
    private static final int FOLDER_TYPE_ARTISTS = 0x03;
    private static final int FOLDER_TYPE_GENRES = 0x04;
    private static final int FOLDER_TYPE_PLAYLISTS = 0x05;

    private static final int MEDIA_TYPE_AUDIO = 0X00;
    private static final int MEDIA_TYPE_VIDEO = 0X01;

    private static final int MAX_BROWSE_ITEM_TO_SEND = 10;
    private static final int MAX_ATTRIB_COUNT = 0x08;

    private final static int ALBUMS_ITEM_INDEX = 0;
    private final static int ARTISTS_ITEM_INDEX = 1;
    private final static int PLAYLISTS_ITEM_INDEX = 2;
    private final static int TITLES_ITEM_INDEX = 3;

    //Intents for PlayerApplication Settings
    private static final String PLAYERSETTINGS_REQUEST =
            "org.codeaurora.music.playersettingsrequest";
    private static final String PLAYERSETTINGS_RESPONSE =
           "org.codeaurora.music.playersettingsresponse";
    // Max number of Avrcp connections at any time
    private int maxAvrcpConnections = 1;
    BluetoothDevice mBrowserDevice = null;
    private static final int INVALID_DEVICE_INDEX = 0xFF;
    // codes for reset of of notifications
    private static final int PLAY_POSITION_CHANGE_NOTIFICATION = 101;
    private static final int PLAY_STATUS_CHANGE_NOTIFICATION = 102;
    private static final int TRACK_CHANGE_NOTIFICATION = 103;
    private static final int NOW_PALYING_CONTENT_CHANGED_NOTIFICATION = 104;
    private static final int PLAYER_STATUS_CHANGED_NOTIFICATION = 105;

    private static final int INVALID_ADDRESSED_PLAYER_ID = -1;
    // Device dependent registered Notification & Variables
    private class DeviceDependentFeature {
        private BluetoothDevice mCurrentDevice;
        private PlaybackState mCurrentPlayState;
        private int mPlayStatusChangedNT;
        private int mPlayerStatusChangeNT;
        private int mTrackChangedNT;
        private long mNextPosMs;
        private long mPrevPosMs;
        private long mPlaybackIntervalMs;
        private long mLastReportedPosition;
        private int mPlayPosChangedNT;
        private int mFeatures;
        private int mAbsoluteVolume;
        private int mLastSetVolume;
        private int mLastDirection;
        private boolean mVolCmdSetInProgress;
        private boolean mVolCmdAdjustInProgress;
        private int mAbsVolRetryTimes;
        private int keyPressState;
        private int mAddressedPlayerChangedNT;
        private int mAvailablePlayersChangedNT;
        private int mNowPlayingContentChangedNT;
        private String mRequestedAddressedPlayerPackageName;
        private String mCurrentPath;
        private String mCurrentPathUid;
        private Uri mMediaUri;
        private boolean isMusicAppResponsePending;
        private boolean isBrowsingSupported;
        private boolean isAbsoluteVolumeSupportingDevice;
        private boolean isActiveDevice;

        private int mRemoteVolume;
        private int mLastRemoteVolume;
        private int mInitialRemoteVolume;

        /* Local volume in audio index 0-15 */
        private int mLocalVolume;
        private int mLastLocalVolume;
        private int mAbsVolThreshold;
        private HashMap<Integer, Integer> mVolumeMapping;

        public DeviceDependentFeature() {
            mCurrentDevice = null;
            mCurrentPlayState = new PlaybackState.Builder().setState(PlaybackState.STATE_NONE, -1L, 0.0f).build();;
            mPlayStatusChangedNT = NOTIFICATION_TYPE_CHANGED;
            mPlayerStatusChangeNT = NOTIFICATION_TYPE_CHANGED;
            mTrackChangedNT = NOTIFICATION_TYPE_CHANGED;
            mNextPosMs = -1;
            mPrevPosMs = -1;
            mPlaybackIntervalMs = 0L;
            mLastReportedPosition = -1;
            mPlayPosChangedNT = NOTIFICATION_TYPE_CHANGED;
            mFeatures = 0;
            mAbsoluteVolume = -1;
            mLastSetVolume = -1;
            mLastDirection = 0;
            mVolCmdAdjustInProgress = false;
            mVolCmdSetInProgress = false;
            mAbsVolRetryTimes = 0;
            keyPressState = KEY_STATE_RELEASE; //Key release state
            mAddressedPlayerChangedNT = NOTIFICATION_TYPE_CHANGED;
            mAvailablePlayersChangedNT = NOTIFICATION_TYPE_CHANGED;
            mNowPlayingContentChangedNT = NOTIFICATION_TYPE_CHANGED;
            mRequestedAddressedPlayerPackageName = null;
            mCurrentPath = PATH_INVALID;
            mCurrentPathUid = null;
            mMediaUri = Uri.EMPTY;
            isMusicAppResponsePending = false;
            isBrowsingSupported = false;
            isAbsoluteVolumeSupportingDevice = false;
            isActiveDevice = false;
            mRemoteVolume = -1;
            mInitialRemoteVolume = -1;
            mLastRemoteVolume = -1;
            mLocalVolume = -1;
            mLastLocalVolume = -1;
            mAbsVolThreshold = 0;
            mVolumeMapping = new HashMap<Integer, Integer>();
            if (mResources != null) {
                mAbsVolThreshold = mResources.getInteger(R.integer.a2dp_absolute_volume_initial_threshold);
            }
        }
    };

    private class PlayerSettings {
        public byte attr;
        public byte [] attrIds;
        public String path;
    };

    private PlayerSettings mPlayerSettings = new PlayerSettings();
    private class localPlayerSettings {
        public byte eq_value = 0x01;
        public byte repeat_value = 0x01;
        public byte shuffle_value = 0x01;
        public byte scan_value = 0x01;
    };
    private localPlayerSettings settingValues = new localPlayerSettings();
    private static final String COMMAND = "command";
    private static final String CMDGET = "get";
    private static final String CMDSET = "set";
    private static final String EXTRA_GET_COMMAND = "commandExtra";
    private static final String EXTRA_GET_RESPONSE = "Response";

    private static final int GET_ATTRIBUTE_IDS = 0;
    private static final int GET_VALUE_IDS = 1;
    private static final int GET_ATTRIBUTE_TEXT = 2;
    private static final int GET_VALUE_TEXT     = 3;
    private static final int GET_ATTRIBUTE_VALUES = 4;
    private static final int NOTIFY_ATTRIBUTE_VALUES = 5;
    private static final int SET_ATTRIBUTE_VALUES  = 6;
    private static final int GET_INVALID = 0xff;

    private static final String EXTRA_ATTRIBUTE_ID = "Attribute";
    private static final String EXTRA_VALUE_STRING_ARRAY = "ValueStrings";
    private static final String EXTRA_ATTRIB_VALUE_PAIRS = "AttribValuePairs";
    private static final String EXTRA_ATTRIBUTE_STRING_ARRAY = "AttributeStrings";
    private static final String EXTRA_VALUE_ID_ARRAY = "Values";
    private static final String EXTRA_ATTIBUTE_ID_ARRAY = "Attributes";

    public static final int VALUE_SHUFFLEMODE_OFF = 1;
    public static final int VALUE_SHUFFLEMODE_ALL = 2;
    public static final int VALUE_REPEATMODE_OFF = 1;
    public static final int VALUE_REPEATMODE_SINGLE = 2;
    public static final int VALUE_REPEATMODE_ALL = 3;
    public static final int VALUE_INVALID = 0;
    public static final int ATTRIBUTE_NOTSUPPORTED = -1;

    public static final int ATTRIBUTE_EQUALIZER = 1;
    public static final int ATTRIBUTE_REPEATMODE = 2;
    public static final int ATTRIBUTE_SHUFFLEMODE = 3;
    public static final int ATTRIBUTE_SCANMODE = 4;
    public static final int NUMPLAYER_ATTRIBUTE = 2;

    private static AvrcpBipRsp mAvrcpBipRsp;

    private byte [] def_attrib = new byte [] {ATTRIBUTE_REPEATMODE, ATTRIBUTE_SHUFFLEMODE};
    private byte [] value_repmode = new byte [] { VALUE_REPEATMODE_OFF,
                                                  VALUE_REPEATMODE_SINGLE,
                                                  VALUE_REPEATMODE_ALL };

    private byte [] value_shufmode = new byte [] { VALUE_SHUFFLEMODE_OFF,
                                                  VALUE_SHUFFLEMODE_ALL };
    private byte [] value_default = new byte [] {0};
    private final String UPDATE_ATTRIBUTES = "UpdateSupportedAttributes";
    private final String UPDATE_VALUES = "UpdateSupportedValues";
    private final String UPDATE_ATTRIB_VALUE = "UpdateCurrentValues";
    private final String UPDATE_ATTRIB_TEXT = "UpdateAttributesText";
    private final String UPDATE_VALUE_TEXT = "UpdateValuesText";
    private ArrayList <Integer> mPendingCmds;
    private ArrayList <Integer> mPendingSetAttributes;
    DeviceDependentFeature[] deviceFeatures;

    static {
        classInitNative();
    }

    private Avrcp(Context context, A2dpService svc, int maxConnections ) {
        if (DEBUG)
            Log.v(TAG, "Avrcp");
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mMediaAttributes = new MediaAttributes(null);
        mCurrentPlayerState = new PlaybackState.Builder().setState(PlaybackState.STATE_NONE, -1L, 0.0f).build();
        mLastStateUpdate = -1L;
        mSongLengthMs = 0L;
        mA2dpService = svc;
        maxAvrcpConnections = maxConnections;
        deviceFeatures = new DeviceDependentFeature[maxAvrcpConnections];
        mAddressedPlayerId = INVALID_ADDRESSED_PLAYER_ID;
        for(int i = 0; i < maxAvrcpConnections; i++) {
            deviceFeatures[i] = new DeviceDependentFeature();
        }
        mContext = context;

        initNative(maxConnections);

        mMediaSessionManager = (MediaSessionManager) context.getSystemService(Context.MEDIA_SESSION_SERVICE);
        mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
        mResources = context.getResources();
        mAudioStreamMax = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
        mVolumeStep = Math.max(AVRCP_BASE_VOLUME_STEP, AVRCP_MAX_VOL/mAudioStreamMax);
        mAvrcpBipRsp = new AvrcpBipRsp(mContext);
        pts_test = SystemProperties.getBoolean("bt.avrcpct-passthrough.pts", false);
    }

    private void start() {
        if (DEBUG)
            Log.v(TAG, "start");
        HandlerThread thread = new HandlerThread("BluetoothAvrcpHandler");
        thread.start();
        Looper looper = thread.getLooper();
        mHandler = new AvrcpMessageHandler(looper);
        registerMediaPlayers();
        mSessionChangeListener = new MediaSessionChangeListener();
        mMediaSessionManager.addOnActiveSessionsChangedListener(mSessionChangeListener, null, mHandler);
        List<MediaController> sessions = mMediaSessionManager.getActiveSessions(null);
        mMediaControllerCb = new MediaControllerListener();
        if (sessions.size() > 0) {
            final Iterator<MediaController> mcIterator = sessions.iterator();
            while (mcIterator.hasNext()) {
                final MediaController player = mcIterator.next();
                if (mHandler != null) {
                    Log.v(TAG, "Availability change for player: " + player.getPackageName());
                    mHandler.obtainMessage(MSG_UPDATE_RCC_CHANGE, 0, 1,
                                        player.getPackageName()).sendToTarget();
                }
            }
            updateCurrentMediaController(sessions.get(0));
        }
        mPendingCmds = new ArrayList<Integer>();
        mPendingSetAttributes = new ArrayList<Integer>();
        // clear path for all devices
        for (int i = 0; i < maxAvrcpConnections; i++) {
           deviceFeatures[i].mCurrentPath = PATH_INVALID;
           deviceFeatures[i].mCurrentPathUid = null;
           deviceFeatures[i].mMediaUri = Uri.EMPTY;
        }
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(AudioManager.RCC_CHANGED_ACTION);
        intentFilter.addAction(PLAYERSETTINGS_RESPONSE);
        try {
            mContext.registerReceiver(mIntentReceiver, intentFilter);
        }catch (Exception e) {
            Log.e(TAG,"Unable to register Avrcp receiver", e);
        }
        mAvrcpBipRsp.start();
    }

    //Listen to intents from MediaPlayer and Audio Manager and update data structures
    private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d(TAG, "Enter onReceive()" +intent);
            String action = intent.getAction();
            if (action.equals(AudioManager.RCC_CHANGED_ACTION)) {
                Log.v(TAG, "received RCC_CHANGED_ACTION");
                int isRCCFocussed = 0;
                int isRCCAvailable = 0;
                String callingPackageName =
                        intent.getStringExtra(AudioManager.EXTRA_CALLING_PACKAGE_NAME);
                boolean isFocussed =
                        intent.getBooleanExtra(AudioManager.EXTRA_FOCUS_CHANGED_VALUE,
                        false);
                boolean isAvailable =
                        intent.getBooleanExtra(AudioManager.EXTRA_AVAILABLITY_CHANGED_VALUE,
                        false);
                if (isFocussed)
                    isRCCFocussed = 1;
                if (isAvailable)
                    isRCCAvailable = 1;
                Log.v(TAG, "focus: " + isFocussed + " , availability: " + isAvailable);
                if (mHandler != null) {
                    mHandler.obtainMessage(MSG_UPDATE_RCC_CHANGE, isRCCFocussed,
                            isRCCAvailable, callingPackageName).sendToTarget();
                }
            } else if (action.equals(PLAYERSETTINGS_RESPONSE)) {
                int getResponse = intent.getIntExtra(EXTRA_GET_RESPONSE,
                                                      GET_INVALID);
                byte [] data;
                String [] text;
                boolean isSetAttrValRsp = false;
                BluetoothDevice device = null;

                synchronized (mPendingCmds) {
                    Integer val = new Integer(getResponse);
                    if (mPendingCmds.contains(val)) {
                        if (getResponse == SET_ATTRIBUTE_VALUES) {
                            isSetAttrValRsp = true;
                            if (DEBUG) Log.v(TAG,"Response received for SET_ATTRIBUTE_VALUES");
                        }
                        mHandler.removeMessages(MESSAGE_PLAYERSETTINGS_TIMEOUT);
                        mPendingCmds.remove(val);
                    }
                }
                for (int i = 0; i < maxAvrcpConnections; i++) {
                    if (deviceFeatures[i].isMusicAppResponsePending ==
                            true) {
                        device = deviceFeatures[i].mCurrentDevice;
                        deviceFeatures[i].isMusicAppResponsePending = false;
                        break;
                    }
                }

                if (DEBUG)
                    Log.v(TAG,"getResponse" + getResponse);
                switch (getResponse) {
                    case GET_ATTRIBUTE_IDS:
                        if (device == null) {
                            Log.e(TAG,"ERROR!!! device is null");
                            return;
                        }
                        data = intent.getByteArrayExtra(EXTRA_ATTIBUTE_ID_ARRAY);
                        byte numAttr = (byte) data.length;
                        if (DEBUG)
                            Log.v(TAG,"GET_ATTRIBUTE_IDS");
                        getListPlayerappAttrRspNative(numAttr ,
                                data ,getByteAddress(device));

                    break;
                    case GET_VALUE_IDS:
                        if (device == null) {
                            Log.e(TAG,"ERROR!!! device is null");
                            return;
                        }
                        data = intent.getByteArrayExtra(EXTRA_VALUE_ID_ARRAY);
                        numAttr = (byte) data.length;
                        if (DEBUG)
                            Log.v(TAG,"GET_VALUE_IDS" + numAttr);
                        getPlayerAppValueRspNative(numAttr, data,
                                getByteAddress(device));
                    break;
                    case GET_ATTRIBUTE_VALUES:
                        if (device == null) {
                            Log.e(TAG,"ERROR!!! device is null");
                            return;
                        }
                        data = intent.getByteArrayExtra(EXTRA_ATTRIB_VALUE_PAIRS);
                        updateLocalPlayerSettings(data);
                        numAttr = (byte) data.length;
                        if (DEBUG)
                            Log.v(TAG,"GET_ATTRIBUTE_VALUES" + numAttr);
                        SendCurrentPlayerValueRspNative(numAttr ,
                                data, getByteAddress(device));
                    break;
                    case SET_ATTRIBUTE_VALUES:
                        data = intent.getByteArrayExtra(EXTRA_ATTRIB_VALUE_PAIRS);
                        updateLocalPlayerSettings(data);
                        if (isSetAttrValRsp) {
                            isSetAttrValRsp = false;
                            for (int i = 0; i < maxAvrcpConnections; i++) {
                                if (deviceFeatures[i].mCurrentDevice != null)  {
                                    Log.v(TAG,"Respond to SET_ATTRIBUTE_VALUES request");
                                    if (checkPlayerAttributeResponse(data)) {
                                        SendSetPlayerAppRspNative(OPERATION_SUCCESSFUL,
                                                getByteAddress(deviceFeatures[i].mCurrentDevice));
                                    } else {
                                        SendSetPlayerAppRspNative(INTERNAL_ERROR,
                                                getByteAddress(deviceFeatures[i].mCurrentDevice));
                                    }
                                }
                            }
                            mPendingSetAttributes.clear();
                        }
                        for (int i = 0; i < maxAvrcpConnections; i++) {
                            if (deviceFeatures[i].mPlayerStatusChangeNT ==
                                    NOTIFICATION_TYPE_INTERIM) {
                                Log.v(TAG,"device has registered for"+
                                    "mPlayerStatusChangeNT");
                                deviceFeatures[i].mPlayerStatusChangeNT =
                                        NOTIFICATION_TYPE_CHANGED;
                                sendPlayerAppChangedRsp(deviceFeatures[i].mPlayerStatusChangeNT,
                                        deviceFeatures[i].mCurrentDevice);
                               } else {
                                   Log.v(TAG,"Drop Set Attr Val update from media player");
                            }
                        }
                    break;
                    case GET_ATTRIBUTE_TEXT:
                        text = intent.getStringArrayExtra(EXTRA_ATTRIBUTE_STRING_ARRAY);
                        if (device == null) {
                            Log.e(TAG,"ERROR!!! device is null");
                            return;
                        }
                        sendSettingsTextRspNative(mPlayerSettings.attrIds.length ,
                                mPlayerSettings.attrIds ,text.length,
                                text, getByteAddress(device));
                        if (DEBUG)
                            Log.v(TAG,"mPlayerSettings.attrIds"
                                    + mPlayerSettings.attrIds.length);
                    break;
                    case GET_VALUE_TEXT:
                        text = intent.getStringArrayExtra(EXTRA_VALUE_STRING_ARRAY);
                        if (device == null) {
                            Log.e(TAG,"ERROR!!! device is null");
                            return;
                        }
                        sendValueTextRspNative(mPlayerSettings.attrIds.length ,
                                mPlayerSettings.attrIds,
                                text.length, text,
                                getByteAddress(device));
                    break;
                }
            }

        }
    };

    /* This method is used for create entries of existing media players on RCD start
     * Later when media players become avaialable corresponding entries
     * are marked accordingly and similarly when media players changes focus
     * the corresponding fields are modified */
    private void registerMediaPlayers () {
        if (DEBUG)
            Log.v(TAG, "registerMediaPlayers");
        int[] featureMasks = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
        int[] featureMasks2 = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
        byte[] playerName1 = {0x4d, 0x75, 0x73, 0x69, 0x63}/*Music*/;
        byte[] playerName2 = {0x4d, 0x75, 0x73, 0x69, 0x63, 0x32}/*Music2*/;

        featureMasks[FEATURE_MASK_PLAY_OFFSET] =
            featureMasks[FEATURE_MASK_PLAY_OFFSET] | FEATURE_MASK_PLAY_MASK;
        featureMasks[FEATURE_MASK_PAUSE_OFFSET] =
            featureMasks[FEATURE_MASK_PAUSE_OFFSET] | FEATURE_MASK_PAUSE_MASK;
        featureMasks[FEATURE_MASK_STOP_OFFSET] =
            featureMasks[FEATURE_MASK_STOP_OFFSET] | FEATURE_MASK_STOP_MASK;
        featureMasks[FEATURE_MASK_PAGE_UP_OFFSET] =
            featureMasks[FEATURE_MASK_PAGE_UP_OFFSET] | FEATURE_MASK_PAGE_UP_MASK;
        featureMasks[FEATURE_MASK_PAGE_DOWN_OFFSET] =
            featureMasks[FEATURE_MASK_PAGE_DOWN_OFFSET] | FEATURE_MASK_PAGE_DOWN_MASK;
        featureMasks[FEATURE_MASK_REWIND_OFFSET] =
            featureMasks[FEATURE_MASK_REWIND_OFFSET] | FEATURE_MASK_REWIND_MASK;
        featureMasks[FEATURE_MASK_FAST_FWD_OFFSET] =
            featureMasks[FEATURE_MASK_FAST_FWD_OFFSET] | FEATURE_MASK_FAST_FWD_MASK;
        featureMasks[FEATURE_MASK_VENDOR_OFFSET] =
            featureMasks[FEATURE_MASK_VENDOR_OFFSET] | FEATURE_MASK_VENDOR_MASK;
        featureMasks[FEATURE_MASK_ADV_CTRL_OFFSET] =
            featureMasks[FEATURE_MASK_ADV_CTRL_OFFSET] | FEATURE_MASK_ADV_CTRL_MASK;
        featureMasks[FEATURE_MASK_BROWSE_OFFSET] =
            featureMasks[FEATURE_MASK_BROWSE_OFFSET] | FEATURE_MASK_BROWSE_MASK;
        featureMasks[FEATURE_MASK_NOW_PLAY_OFFSET] =
            featureMasks[FEATURE_MASK_NOW_PLAY_OFFSET] | FEATURE_MASK_NOW_PLAY_MASK;
        featureMasks[FEATURE_MASK_BR_WH_ADDR_OFFSET] =
            featureMasks[FEATURE_MASK_BR_WH_ADDR_OFFSET] | FEATURE_MASK_BR_WH_ADDR_MASK;
        featureMasks[FEATURE_MASK_NUM_ITEMS_OFFSET] =
            featureMasks[FEATURE_MASK_NUM_ITEMS_OFFSET] | FEATURE_MASK_NUM_ITEMS_MASK;
        featureMasks[FEATURE_MASK_COVER_ART_OFFSET] =
            featureMasks[FEATURE_MASK_COVER_ART_OFFSET] | FEATURE_MASK_COVER_ART_MASK;

/*Player2 does not support browsing and now playing,
            hence updated the masks properly*/
        featureMasks2[FEATURE_MASK_PLAY_OFFSET] =
            featureMasks2[FEATURE_MASK_PLAY_OFFSET] | FEATURE_MASK_PLAY_MASK;
        featureMasks2[FEATURE_MASK_PAUSE_OFFSET] =
            featureMasks2[FEATURE_MASK_PAUSE_OFFSET] | FEATURE_MASK_PAUSE_MASK;
        featureMasks2[FEATURE_MASK_STOP_OFFSET] =
            featureMasks2[FEATURE_MASK_STOP_OFFSET] | FEATURE_MASK_STOP_MASK;
        featureMasks2[FEATURE_MASK_PAGE_UP_OFFSET] =
            featureMasks2[FEATURE_MASK_PAGE_UP_OFFSET] | FEATURE_MASK_PAGE_UP_MASK;
        featureMasks2[FEATURE_MASK_PAGE_DOWN_OFFSET] =
            featureMasks2[FEATURE_MASK_PAGE_DOWN_OFFSET] | FEATURE_MASK_PAGE_DOWN_MASK;
        featureMasks2[FEATURE_MASK_REWIND_OFFSET] =
            featureMasks2[FEATURE_MASK_REWIND_OFFSET] | FEATURE_MASK_REWIND_MASK;
        featureMasks2[FEATURE_MASK_FAST_FWD_OFFSET] =
            featureMasks2[FEATURE_MASK_FAST_FWD_OFFSET] | FEATURE_MASK_FAST_FWD_MASK;
        mediaPlayerInfo1 = new MediaPlayerInfo ((short)0x0001,
                    MAJOR_TYPE_AUDIO,
                    SUB_TYPE_NONE,
                    (byte)PlaybackState.STATE_PAUSED,
                    CHAR_SET_UTF8,
                    (short)0x05,
                    playerName1,
                    "com.android.music",
                    true,
                    featureMasks);
        mediaPlayerInfo2 = new MediaPlayerInfo ((short)0x0000,
                    MAJOR_TYPE_AUDIO,
                    SUB_TYPE_NONE,
                    (byte)PlaybackState.STATE_PAUSED,
                    CHAR_SET_UTF8,
                    (short)0x06,
                    playerName2,
                    "com.google.android.music",
                    true,
                    featureMasks2);
        mMediaPlayers.add(mediaPlayerInfo1);
        mMediaPlayers.add(mediaPlayerInfo2);
        Log.d(TAG, "Exit registerMediaPlayers()");
    }

    public static Avrcp make(Context context, A2dpService svc,
            int maxConnections) {
        if (DEBUG)
            Log.v(TAG, "make");
        Avrcp ar = new Avrcp(context, svc, maxConnections);
        ar.start();
        return ar;
    }

    public void doQuit() {
        if (DEBUG)
            Log.v(TAG, "doQuit");
        mHandler.removeCallbacksAndMessages(null);
        Looper looper = mHandler.getLooper();
        if (looper != null) {
            looper.quit();
        }
        mMediaSessionManager.removeOnActiveSessionsChangedListener(mSessionChangeListener);
        clearDeviceDependentFeature();
        for (int i = 0; i < maxAvrcpConnections; i++) {
            cleanupDeviceFeaturesIndex(i);
        }
        mAvrcpBipRsp.stop();
        try {
            mContext.unregisterReceiver(mIntentReceiver);
        } catch (Exception e) {
            Log.e(TAG,"Unable to unregister Avrcp receiver", e);
        }
        mMediaPlayers.clear();
        if (mHandler.hasMessages(MESSAGE_SET_ADDR_PLAYER_REQ_TIMEOUT)) {
            mHandler.removeMessages(MESSAGE_SET_ADDR_PLAYER_REQ_TIMEOUT);
            if (DEBUG)
                Log.v(TAG, "Addressed player message cleanup as part of doQuit");
        }
    }

    public void clearDeviceDependentFeature() {
        Log.d(TAG, "Enter clearDeviceDependentFeature()");
        for (int i = 0; i < maxAvrcpConnections; i++) {
            deviceFeatures[i].keyPressState = KEY_STATE_RELEASE; //Key release state
            deviceFeatures[i].mCurrentPath = PATH_INVALID;
            deviceFeatures[i].mMediaUri = Uri.EMPTY;
            deviceFeatures[i].mCurrentPathUid = null;
            deviceFeatures[i].mRequestedAddressedPlayerPackageName = null;
            if (deviceFeatures[i].mVolumeMapping != null)
                deviceFeatures[i].mVolumeMapping.clear();
        }
        Log.d(TAG, "Exit clearDeviceDependentFeature()");
    }

    public void cleanup() {
        if (DEBUG)
            Log.v(TAG, "cleanup");
        cleanupNative();
        Log.d(TAG, "Exit cleanup()");
    }

    private class MediaControllerListener extends MediaController.Callback {
        @Override
        public void onMetadataChanged(MediaMetadata metadata) {
            Log.v(TAG, "MediaController metadata changed");
            updateMetadata(metadata);
            Log.d(TAG, "Exit onMetadataChanged()");
        }

        @Override
        public void onPlaybackStateChanged(PlaybackState state) {
            Log.v(TAG, "MediaController playback changed: " + state.toString());
            updatePlaybackState(state, null);
            Log.d(TAG, "Exit onPlaybackStateChanged()");
        }

        @Override
        public void onSessionDestroyed() {
            Log.v(TAG, "MediaController session destroyed");
        }

        @Override
        public void onUpdateFolderInfoBrowsedPlayer(String stringUri) {
            Log.v(TAG, "onClientFolderInfoBrowsedPlayer: stringUri: " + stringUri);
            if (stringUri != null) {
                String[] ExternalPath = stringUri.split("/");
                if (ExternalPath.length < 4) {
                    Log.d(TAG, "Wrong entries.");
                    mHandler.obtainMessage(MSG_UPDATE_BROWSED_PLAYER_FOLDER, 0, INTERNAL_ERROR,
                                                                  null).sendToTarget();
                    return;
                }
                Uri uri = Uri.parse(stringUri);
                Log.v(TAG, "URI received: " + uri);
                String[] SplitPath = new String[ExternalPath.length - 3];
                for (int count = 2; count < (ExternalPath.length - 1); count++) {
                    SplitPath[count - 2] = ExternalPath[count];
                    Log.d(TAG, "SplitPath[" + (count - 2) + "] = " + SplitPath[count - 2]);
                }
                Log.v(TAG, "folderDepth: " + SplitPath.length);
                for (int count = 0; count < SplitPath.length; count++) {
                    Log.v(TAG, "folderName: " + SplitPath[count]);
                }
                mMediaUriStatic = uri;
                if (mHandler != null) {
                    // Don't send the complete path to CK as few gets confused by that
                    // Send only the name of the root folder
                    mHandler.obtainMessage(MSG_UPDATE_BROWSED_PLAYER_FOLDER, NUM_ROOT_ELEMENTS,
                                                OPERATION_SUCCESSFUL, SplitPath).sendToTarget();
                }
            } else {
                mHandler.obtainMessage(MSG_UPDATE_BROWSED_PLAYER_FOLDER, 0, INTERNAL_ERROR,
                                                                  null).sendToTarget();
            }
            Log.d(TAG, "Exit onUpdateFolderInfoBrowsedPlayer()");
        }

        @Override
        public void onUpdateNowPlayingEntries(long[] playList) {
            Log.v(TAG, "onClientUpdateNowPlayingEntries");
            if (mHandler != null) {
                mHandler.obtainMessage(MSG_NOW_PLAYING_ENTRIES_RECEIVED, 0, 0,
                                                            playList).sendToTarget();
            }
            Log.d(TAG, "Exit onUpdateNowPlayingEntries()");
        }

        @Override
        public void onUpdateNowPlayingContentChange() {
            Log.v(TAG, "onClientNowPlayingContentChange");
            if (mHandler != null) {
                mHandler.obtainMessage(MSG_UPDATE_NOW_PLAYING_CONTENT_CHANGED).sendToTarget();
            }
            Log.d(TAG, "Exit onUpdateNowPlayingContentChange()");
        }

        @Override
        public void onPlayItemResponse(boolean success) {
            Log.v(TAG, "onClientPlayItemResponse");
            if (mHandler != null) {
                mHandler.obtainMessage(MSG_PLAY_ITEM_RESPONSE, 0, 0, new Boolean(success))
                                                                            .sendToTarget();
            }
            Log.d(TAG, "Exit onPlayItemResponse()");
        }
    }

    private class MediaSessionChangeListener implements MediaSessionManager.OnActiveSessionsChangedListener {
        public MediaSessionChangeListener() {
        }

        @Override
        public void onActiveSessionsChanged(List<MediaController> controllers) {
            Log.v(TAG, "Active sessions changed, " + controllers.size() + " sessions");
            if (controllers.size() > 0) {
                updateCurrentMediaController(controllers.get(0));
            }
            Log.d(TAG, "Exit onActiveSessionsChanged()");
        }
    }

    private void updateCurrentMediaController(MediaController controller) {
        Log.v(TAG, "Updating media controller to " + controller);
        if (mMediaController != null) {
            mMediaController.unregisterCallback(mMediaControllerCb);
        }
        mMediaController = controller;
        if (mMediaController == null) {
            updateMetadata(null);
            return;
        }
        mMediaController.registerCallback(mMediaControllerCb, mHandler);
        updateMetadata(mMediaController.getMetadata());
        if (mHandler != null) {
            Log.v(TAG, "Focus gained for player: " + mMediaController.getPackageName());
            mHandler.obtainMessage(MSG_UPDATE_RCC_CHANGE, 1, 1,
                                mMediaController.getPackageName()).sendToTarget();
        }
        Log.d(TAG, "Exit updateCurrentMediaController()");
    }


    /** Handles Avrcp messages. */
    private final class AvrcpMessageHandler extends Handler {
        private AvrcpMessageHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            int deviceIndex  = INVALID_DEVICE_INDEX;
            switch (msg.what) {
                case MESSAGE_PLAYERSETTINGS_TIMEOUT:
                    Log.e(TAG, "**MESSAGE_PLAYSTATUS_TIMEOUT: Addr: " +
                                (String)msg.obj + " Msg: " + msg.arg1);
                    synchronized (mPendingCmds) {
                        Integer val = new Integer(msg.arg1);
                        if (!mPendingCmds.contains(val)) {
                            break;
                        }
                        mPendingCmds.remove(val);
                    }
                    switch (msg.arg1) {
                    case GET_ATTRIBUTE_IDS:
                        getListPlayerappAttrRspNative((byte)def_attrib.length ,
                                def_attrib, getByteAddress(
                                mAdapter.getRemoteDevice((String) msg.obj)));
                    break;
                    case GET_VALUE_IDS:
                        switch (mPlayerSettings.attr) {
                            case ATTRIBUTE_REPEATMODE:
                                getPlayerAppValueRspNative((byte)value_repmode.length,
                                        value_repmode,
                                        getByteAddress(mAdapter.getRemoteDevice(
                                        (String) msg.obj)));
                            break;
                            case ATTRIBUTE_SHUFFLEMODE:
                                getPlayerAppValueRspNative((byte)value_shufmode.length,
                                        value_shufmode,
                                        getByteAddress(mAdapter.getRemoteDevice(
                                        (String) msg.obj)));
                            break;
                            default:
                                getPlayerAppValueRspNative((byte)value_default.length,
                                        value_default,
                                        getByteAddress(mAdapter.getRemoteDevice(
                                        (String) msg.obj)));
                            break;
                        }
                    break;
                    case GET_ATTRIBUTE_VALUES:
                        int j = 0;
                        byte [] retVal = new byte [mPlayerSettings.attrIds.length*2];
                        for (int i = 0; i < mPlayerSettings.attrIds.length; i++) {
                            retVal[j++] = mPlayerSettings.attrIds[i];
                            if (mPlayerSettings.attrIds[i] == ATTRIBUTE_REPEATMODE) {
                                retVal[j++] = settingValues.repeat_value;
                            } else if (mPlayerSettings.attrIds[i] == ATTRIBUTE_SHUFFLEMODE) {
                                retVal[j++] = settingValues.shuffle_value;
                             } else {
                                retVal[j++] = 0x0;
                             }
                        }
                        SendCurrentPlayerValueRspNative((byte)retVal.length ,
                                retVal, getByteAddress(mAdapter.getRemoteDevice(
                                (String) msg.obj)));
                    break;
                    case SET_ATTRIBUTE_VALUES :
                        SendSetPlayerAppRspNative(INTERNAL_ERROR, getByteAddress(
                                mAdapter.getRemoteDevice((String) msg.obj)));
                    break;
                    case GET_ATTRIBUTE_TEXT:
                        String [] attribText = new String [mPlayerSettings.attrIds.length];
                        for (int i = 0; i < mPlayerSettings.attrIds.length; i++) {
                            attribText[i] = "";
                        }
                        sendSettingsTextRspNative(mPlayerSettings.attrIds.length ,
                                mPlayerSettings.attrIds, attribText.length,
                                attribText, getByteAddress(mAdapter.getRemoteDevice(
                                (String) msg.obj)));
                    break;
                    case GET_VALUE_TEXT:
                        String [] valueText = new String [mPlayerSettings.attrIds.length];
                        for (int i = 0; i < mPlayerSettings.attrIds.length; i++) {
                            valueText[i] = "";
                        }
                        sendValueTextRspNative(mPlayerSettings.attrIds.length ,
                                mPlayerSettings.attrIds, valueText.length,
                                valueText,getByteAddress(mAdapter.getRemoteDevice(
                                (String) msg.obj)));
                    break;
                    default :
                        Log.e(TAG,"in default case");
                    break;
                }
                break;

            case MSG_UPDATE_AVAILABLE_PLAYERS:
                updateAvailableMediaPlayers();
                break;

            case MSG_UPDATE_ADDRESSED_PLAYER:
                updateAddressedMediaPlayer(msg.arg1);
                break;

            case MSG_UPDATE_BROWSED_PLAYER_FOLDER:
                Log.v(TAG, "MSG_UPDATE_BROWSED_PLAYER_FOLDER");
                updateBrowsedPlayerFolder(msg.arg1, msg.arg2, (String [])msg.obj);
                break;

            case MSG_UPDATE_NOW_PLAYING_CONTENT_CHANGED:
                Log.v(TAG, "MSG_UPDATE_NOW_PLAYING_CONTENT_CHANGED");
                updateNowPlayingContentChanged();
                break;

            case MSG_PLAY_ITEM_RESPONSE:
                Log.v(TAG, "MSG_PLAY_ITEM_RESPONSE");
                boolean success = ((Boolean)msg.obj).booleanValue();
                Log.v(TAG, "success: " + success);
                updatePlayItemResponse(success);
                break;

            case MSG_NOW_PLAYING_ENTRIES_RECEIVED:
                Log.v(TAG, "MSG_NOW_PLAYING_ENTRIES_RECEIVED");
                updateNowPlayingEntriesReceived((long [])msg.obj);
                break;

            case MESSAGE_GET_RC_FEATURES:
            {
                String address = (String) msg.obj;
                if (DEBUG)
                    Log.v(TAG, "MESSAGE_GET_RC_FEATURES: address="+address+
                            ", features="+msg.arg1);
                BluetoothDevice device = mAdapter.getRemoteDevice(address);
                deviceIndex = getIndexForDevice(device);
                if (deviceIndex == INVALID_DEVICE_INDEX) {
                    Log.v(TAG,"device entry not present, bailing out");
                    return;
                }
                deviceFeatures[deviceIndex].mFeatures = msg.arg1;
                deviceFeatures[deviceIndex].mFeatures = 
                    modifyRcFeatureFromBlacklist(deviceFeatures[deviceIndex].mFeatures,
                    address);
                Log.d(TAG, "avrcpct-passthrough pts_test = " + pts_test);
                if (pts_test) {
                    Log.v(TAG,"fake BTRC_FEAT_ABSOLUTE_VOLUME remote feat support for pts test");
                    deviceFeatures[deviceIndex].mFeatures =
                                 deviceFeatures[deviceIndex].mFeatures | BTRC_FEAT_ABSOLUTE_VOLUME;
                }
                deviceFeatures[deviceIndex].isAbsoluteVolumeSupportingDevice =
                        ((deviceFeatures[deviceIndex].mFeatures &
                        BTRC_FEAT_ABSOLUTE_VOLUME) != 0);
                mAudioManager.avrcpSupportsAbsoluteVolume(device.getAddress(),
                        isAbsoluteVolumeSupported());
                Log.v(TAG," update audio manager for abs vol state = "
                        + isAbsoluteVolumeSupported());
                deviceFeatures[deviceIndex].mLastLocalVolume = -1;
                deviceFeatures[deviceIndex].mRemoteVolume = -1;
                deviceFeatures[deviceIndex].mLocalVolume = -1;
                devic…

Large files files are truncated, but you can click here to view the full file