src/com/android/bluetooth/avrcp/AvrcpHelperClasses.java - platform/packages/apps/Bluetooth - Git at Google

 /*
  * Copyright (C) 2016 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 android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.media.session.MediaSession;

 import com.android.bluetooth.Utils;

 import java.util.List;
 import java.util.Arrays;
 import java.util.ArrayDeque;
 import java.util.Collection;

 /*************************************************************************************************
  * Helper classes used for callback/response of browsing commands:-
  *     1) To bundle parameters for  native callbacks/response.
  *     2) Stores information of Addressed and Browsed Media Players.
  ************************************************************************************************/

 class AvrcpCmd {

     public AvrcpCmd() {}

     /* Helper classes to pass parameters from callbacks to Avrcp handler */
     class FolderItemsCmd {
         byte mScope;
         long mStartItem;
         long mEndItem;
         byte mNumAttr;
         int[] mAttrIDs;
         public byte[] mAddress;

         public FolderItemsCmd(byte[] address, byte scope, long startItem, long endItem,
                 byte numAttr, int[] attrIds) {
             mAddress = address;
             this.mScope = scope;
             this.mStartItem = startItem;
             this.mEndItem = endItem;
             this.mNumAttr = numAttr;
             this.mAttrIDs = attrIds;
         }

         public String toString() {
             StringBuilder sb = new StringBuilder();
             sb.append("[FolderItemCmd: scope " + mScope);
             sb.append(" start " + mStartItem);
             sb.append(" end " + mEndItem);
             sb.append(" numAttr " + mNumAttr);
             sb.append(" attrs: ");
             for (int i = 0; i < mNumAttr; i++) {
                 sb.append(mAttrIDs[i] + " ");
             }
             return sb.toString();
         }
     }

     class ItemAttrCmd {
         byte mScope;
         byte[] mUid;
         int mUidCounter;
         byte mNumAttr;
         int[] mAttrIDs;
         public byte[] mAddress;

         public ItemAttrCmd(byte[] address, byte scope, byte[] uid, int uidCounter, byte numAttr,
                 int[] attrIDs) {
             mAddress = address;
             mScope = scope;
             mUid = uid;
             mUidCounter = uidCounter;
             mNumAttr = numAttr;
             mAttrIDs = attrIDs;
         }

         public String toString() {
             StringBuilder sb = new StringBuilder();
             sb.append("[ItemAttrCmd: scope " + mScope);
             sb.append(" uid " + Utils.byteArrayToString(mUid));
             sb.append(" numAttr " + mNumAttr);
             sb.append(" attrs: ");
             for (int i = 0; i < mNumAttr; i++) {
                 sb.append(mAttrIDs[i] + " ");
             }
             return sb.toString();
         }
     }

     class ElementAttrCmd {
         byte mNumAttr;
         int[] mAttrIDs;
         public byte[] mAddress;

         public ElementAttrCmd(byte[] address, byte numAttr, int[] attrIDs) {
             mAddress = address;
             mNumAttr = numAttr;
             mAttrIDs = attrIDs;
         }
     }
 }

 /* Helper classes to pass parameters to native response */
 class MediaPlayerListRsp {
     byte mStatus;
     short mUIDCounter;
     byte itemType;
     int[] mPlayerIds;
     byte[] mPlayerTypes;
     int[] mPlayerSubTypes;
     byte[] mPlayStatusValues;
     short[] mFeatureBitMaskValues;
     String[] mPlayerNameList;
     int mNumItems;

     public MediaPlayerListRsp(byte status, short UIDCounter, int numItems, byte itemType,
             int[] playerIds, byte[] playerTypes, int[] playerSubTypes, byte[] playStatusValues,
             short[] featureBitMaskValues, String[] playerNameList) {
         this.mStatus = status;
         this.mUIDCounter = UIDCounter;
         this.mNumItems = numItems;
         this.itemType = itemType;
         this.mPlayerIds = playerIds;
         this.mPlayerTypes = playerTypes;
         this.mPlayerSubTypes = new int[numItems];
         this.mPlayerSubTypes = playerSubTypes;
         this.mPlayStatusValues = new byte[numItems];
         this.mPlayStatusValues = playStatusValues;
         int bitMaskSize = AvrcpConstants.AVRC_FEATURE_MASK_SIZE;
         this.mFeatureBitMaskValues = new short[numItems * bitMaskSize];
         for (int bitMaskIndex = 0; bitMaskIndex < (numItems * bitMaskSize); bitMaskIndex++) {
             this.mFeatureBitMaskValues[bitMaskIndex] = featureBitMaskValues[bitMaskIndex];
         }
         this.mPlayerNameList = playerNameList;
     }
 }

 class FolderItemsRsp {
     byte mStatus;
     short mUIDCounter;
     byte mScope;
     int mNumItems;
     byte[] mFolderTypes;
     byte[] mPlayable;
     byte[] mItemTypes;
     byte[] mItemUid;
     String[] mDisplayNames; /* display name of the item. Eg: Folder name or song name */
     int[] mAttributesNum;
     int[] mAttrIds;
     String[] mAttrValues;

     public FolderItemsRsp(byte Status, short UIDCounter, byte scope, int numItems,
             byte[] folderTypes, byte[] playable, byte[] ItemTypes, byte[] ItemsUid,
             String[] displayNameArray, int[] AttributesNum, int[] AttrIds, String[] attrValues) {
         this.mStatus = Status;
         this.mUIDCounter = UIDCounter;
         this.mScope = scope;
         this.mNumItems = numItems;
         this.mFolderTypes = folderTypes;
         this.mPlayable = playable;
         this.mItemTypes = ItemTypes;
         this.mItemUid = ItemsUid;
         this.mDisplayNames = displayNameArray;
         this.mAttributesNum = AttributesNum;
         this.mAttrIds = AttrIds;
         this.mAttrValues = attrValues;
     }
 }

 class ItemAttrRsp {
     byte mStatus;
     byte mNumAttr;
     int[] mAttributesIds;
     String[] mAttributesArray;

     public ItemAttrRsp(byte status, int[] attributesIds, String[] attributesArray) {
         mStatus = status;
         mNumAttr = (byte) attributesIds.length;
         mAttributesIds = attributesIds;
         mAttributesArray = attributesArray;
     }
 }

 /* stores information of Media Players in the system */
 class MediaPlayerInfo {

     private byte majorType;
     private int subType;
     private byte playStatus;
     private short[] featureBitMask;
     private @NonNull String packageName;
     private @NonNull String displayableName;
     private @Nullable MediaController mediaController;

     MediaPlayerInfo(@Nullable MediaController controller, byte majorType, int subType,
             byte playStatus, short[] featureBitMask, @NonNull String packageName,
             @Nullable String displayableName) {
         this.setMajorType(majorType);
         this.setSubType(subType);
         this.playStatus = playStatus;
         // store a copy the FeatureBitMask array
         this.featureBitMask = Arrays.copyOf(featureBitMask, featureBitMask.length);
         Arrays.sort(this.featureBitMask);
         this.setPackageName(packageName);
         this.setDisplayableName(displayableName);
         this.setMediaController(controller);
     }

     /* getters and setters */
     byte getPlayStatus() {
         return playStatus;
     }

     void setPlayStatus(byte playStatus) {
         this.playStatus = playStatus;
     }

     MediaController getMediaController() {
         return mediaController;
     }

     void setMediaController(MediaController mediaController) {
         if (mediaController != null) {
             this.packageName = mediaController.getPackageName();
         }
         this.mediaController = mediaController;
     }

     void setPackageName(@NonNull String name) {
         // Controller determines package name when it is set.
         if (mediaController != null) return;
         this.packageName = name;
     }

     String getPackageName() {
         if (mediaController != null) {
             return mediaController.getPackageName();
         } else if (packageName != null) {
             return packageName;
         }
         return null;
     }

     byte getMajorType() {
         return majorType;
     }

     void setMajorType(byte majorType) {
         this.majorType = majorType;
     }

     int getSubType() {
         return subType;
     }

     void setSubType(int subType) {
         this.subType = subType;
     }

     String getDisplayableName() {
         return displayableName;
     }

     void setDisplayableName(@Nullable String displayableName) {
         if (displayableName == null) displayableName = "";
         this.displayableName = displayableName;
     }

     short[] getFeatureBitMask() {
         return featureBitMask;
     }

     void setFeatureBitMask(short[] featureBitMask) {
         synchronized (this) {
             this.featureBitMask = Arrays.copyOf(featureBitMask, featureBitMask.length);
             Arrays.sort(this.featureBitMask);
         }
     }

     boolean isBrowseSupported() {
         synchronized (this) {
             if (this.featureBitMask == null) return false;
             for (short bit : this.featureBitMask) {
                 if (bit == AvrcpConstants.AVRC_PF_BROWSE_BIT_NO) return true;
             }
         }
         return false;
     }

     /** Tests if the view of this player presented to the controller is different enough to
      *  justify sending an Available Players Changed update */
     public boolean equalView(MediaPlayerInfo other) {
         return (this.majorType == other.getMajorType()) && (this.subType == other.getSubType())
                 && Arrays.equals(this.featureBitMask, other.getFeatureBitMask())
                 && this.displayableName.equals(other.getDisplayableName());
     }

     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append("MediaPlayerInfo ");
         sb.append(getPackageName());
         sb.append(" (as '" + getDisplayableName() + "')");
         sb.append(" Type = " + getMajorType());
         sb.append(", SubType = " + getSubType());
         sb.append(", Status = " + playStatus);
         sb.append(" Feature Bits [");
         short[] bits = getFeatureBitMask();
         for (int i = 0; i < bits.length; i++) {
             if (i != 0) sb.append(" ");
             sb.append(bits[i]);
         }
         sb.append("] Controller: ");
         sb.append(getMediaController());
         return sb.toString();
     }
 }

 /* stores information for browsable Media Players available in the system */
 class BrowsePlayerInfo {
     String packageName;
     String displayableName;
     String serviceClass;

     public BrowsePlayerInfo(String packageName, String displayableName, String serviceClass) {
         this.packageName = packageName;
         this.displayableName = displayableName;
         this.serviceClass = serviceClass;
     }

     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append("BrowsePlayerInfo ");
         sb.append(packageName);
         sb.append(" ( as '" + displayableName + "')");
         sb.append(" service " + serviceClass);
         return sb.toString();
     }
 }

 class FolderItemsData {
     /* initialize sizes for rsp parameters */
     int mNumItems;
     int[] mAttributesNum;
     byte[] mFolderTypes;
     byte[] mItemTypes;
     byte[] mPlayable;
     byte[] mItemUid;
     String[] mDisplayNames;
     int[] mAttrIds;
     String[] mAttrValues;
     int attrCounter;

     public FolderItemsData(int size) {
         mNumItems = size;
         mAttributesNum = new int[size];

         mFolderTypes = new byte[size]; /* folderTypes */
         mItemTypes = new byte[size]; /* folder or media item */
         mPlayable = new byte[size];
         Arrays.fill(mFolderTypes, AvrcpConstants.FOLDER_TYPE_MIXED);
         Arrays.fill(mItemTypes, AvrcpConstants.BTRC_ITEM_MEDIA);
         Arrays.fill(mPlayable, AvrcpConstants.ITEM_PLAYABLE);

         mItemUid = new byte[size * AvrcpConstants.UID_SIZE];
         mDisplayNames = new String[size];

         mAttrIds = null; /* array of attr ids */
         mAttrValues = null; /* array of attr values */
     }
 }

 /** A queue that evicts the first element when you add an element to the end when it reaches a
  * maximum size.
  * This is useful for keeping a FIFO queue of items where the items drop off the front, i.e. a log
  * with a maximum size.
  */
 class EvictingQueue<E> extends ArrayDeque<E> {
     private int mMaxSize;

     public EvictingQueue(int maxSize) {
         super();
         mMaxSize = maxSize;
     }

     public EvictingQueue(int maxSize, int initialElements) {
         super(initialElements);
         mMaxSize = maxSize;
     }

     public EvictingQueue(int maxSize, Collection<? extends E> c) {
         super(c);
         mMaxSize = maxSize;
     }

     @Override
     public void addFirst(E e) {
         if (super.size() == mMaxSize) return;
         super.addFirst(e);
     }

     @Override
     public void addLast(E e) {
         if (super.size() == mMaxSize) {
             super.remove();
         }
         super.addLast(e);
     }

     @Override
     public boolean offerFirst(E e) {
         if (super.size() == mMaxSize) return false;
         return super.offerFirst(e);
     }

     @Override
     public boolean offerLast(E e) {
         if (super.size() == mMaxSize) {
             super.remove();
         }
         return super.offerLast(e);
     }
 }
	/*
	* Copyright (C) 2016 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 android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.media.session.MediaSession;

	import com.android.bluetooth.Utils;

	import java.util.List;
	import java.util.Arrays;
	import java.util.ArrayDeque;
	import java.util.Collection;

	/*************************************************************************************************
	* Helper classes used for callback/response of browsing commands:-
	* 1) To bundle parameters for native callbacks/response.
	* 2) Stores information of Addressed and Browsed Media Players.
	************************************************************************************************/

	class AvrcpCmd {

	public AvrcpCmd() {}

	/* Helper classes to pass parameters from callbacks to Avrcp handler */
	class FolderItemsCmd {
	byte mScope;
	long mStartItem;
	long mEndItem;
	byte mNumAttr;
	int[] mAttrIDs;
	public byte[] mAddress;

	public FolderItemsCmd(byte[] address, byte scope, long startItem, long endItem,
	byte numAttr, int[] attrIds) {
	mAddress = address;
	this.mScope = scope;
	this.mStartItem = startItem;
	this.mEndItem = endItem;
	this.mNumAttr = numAttr;
	this.mAttrIDs = attrIds;
	}

	public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("[FolderItemCmd: scope " + mScope);
	sb.append(" start " + mStartItem);
	sb.append(" end " + mEndItem);
	sb.append(" numAttr " + mNumAttr);
	sb.append(" attrs: ");
	for (int i = 0; i < mNumAttr; i++) {
	sb.append(mAttrIDs[i] + " ");
	}
	return sb.toString();
	}
	}

	class ItemAttrCmd {
	byte mScope;
	byte[] mUid;
	int mUidCounter;
	byte mNumAttr;
	int[] mAttrIDs;
	public byte[] mAddress;

	public ItemAttrCmd(byte[] address, byte scope, byte[] uid, int uidCounter, byte numAttr,
	int[] attrIDs) {
	mAddress = address;
	mScope = scope;
	mUid = uid;
	mUidCounter = uidCounter;
	mNumAttr = numAttr;
	mAttrIDs = attrIDs;
	}

	public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("[ItemAttrCmd: scope " + mScope);
	sb.append(" uid " + Utils.byteArrayToString(mUid));
	sb.append(" numAttr " + mNumAttr);
	sb.append(" attrs: ");
	for (int i = 0; i < mNumAttr; i++) {
	sb.append(mAttrIDs[i] + " ");
	}
	return sb.toString();
	}
	}

	class ElementAttrCmd {
	byte mNumAttr;
	int[] mAttrIDs;
	public byte[] mAddress;

	public ElementAttrCmd(byte[] address, byte numAttr, int[] attrIDs) {
	mAddress = address;
	mNumAttr = numAttr;
	mAttrIDs = attrIDs;
	}
	}
	}

	/* Helper classes to pass parameters to native response */
	class MediaPlayerListRsp {
	byte mStatus;
	short mUIDCounter;
	byte itemType;
	int[] mPlayerIds;
	byte[] mPlayerTypes;
	int[] mPlayerSubTypes;
	byte[] mPlayStatusValues;
	short[] mFeatureBitMaskValues;
	String[] mPlayerNameList;
	int mNumItems;

	public MediaPlayerListRsp(byte status, short UIDCounter, int numItems, byte itemType,
	int[] playerIds, byte[] playerTypes, int[] playerSubTypes, byte[] playStatusValues,
	short[] featureBitMaskValues, String[] playerNameList) {
	this.mStatus = status;
	this.mUIDCounter = UIDCounter;
	this.mNumItems = numItems;
	this.itemType = itemType;
	this.mPlayerIds = playerIds;
	this.mPlayerTypes = playerTypes;
	this.mPlayerSubTypes = new int[numItems];
	this.mPlayerSubTypes = playerSubTypes;
	this.mPlayStatusValues = new byte[numItems];
	this.mPlayStatusValues = playStatusValues;
	int bitMaskSize = AvrcpConstants.AVRC_FEATURE_MASK_SIZE;
	this.mFeatureBitMaskValues = new short[numItems * bitMaskSize];
	for (int bitMaskIndex = 0; bitMaskIndex < (numItems * bitMaskSize); bitMaskIndex++) {
	this.mFeatureBitMaskValues[bitMaskIndex] = featureBitMaskValues[bitMaskIndex];
	}
	this.mPlayerNameList = playerNameList;
	}
	}

	class FolderItemsRsp {
	byte mStatus;
	short mUIDCounter;
	byte mScope;
	int mNumItems;
	byte[] mFolderTypes;
	byte[] mPlayable;
	byte[] mItemTypes;
	byte[] mItemUid;
	String[] mDisplayNames; /* display name of the item. Eg: Folder name or song name */
	int[] mAttributesNum;
	int[] mAttrIds;
	String[] mAttrValues;

	public FolderItemsRsp(byte Status, short UIDCounter, byte scope, int numItems,
	byte[] folderTypes, byte[] playable, byte[] ItemTypes, byte[] ItemsUid,
	String[] displayNameArray, int[] AttributesNum, int[] AttrIds, String[] attrValues) {
	this.mStatus = Status;
	this.mUIDCounter = UIDCounter;
	this.mScope = scope;
	this.mNumItems = numItems;
	this.mFolderTypes = folderTypes;
	this.mPlayable = playable;
	this.mItemTypes = ItemTypes;
	this.mItemUid = ItemsUid;
	this.mDisplayNames = displayNameArray;
	this.mAttributesNum = AttributesNum;
	this.mAttrIds = AttrIds;
	this.mAttrValues = attrValues;
	}
	}

	class ItemAttrRsp {
	byte mStatus;
	byte mNumAttr;
	int[] mAttributesIds;
	String[] mAttributesArray;

	public ItemAttrRsp(byte status, int[] attributesIds, String[] attributesArray) {
	mStatus = status;
	mNumAttr = (byte) attributesIds.length;
	mAttributesIds = attributesIds;
	mAttributesArray = attributesArray;
	}
	}

	/* stores information of Media Players in the system */
	class MediaPlayerInfo {

	private byte majorType;
	private int subType;
	private byte playStatus;
	private short[] featureBitMask;
	private @NonNull String packageName;
	private @NonNull String displayableName;
	private @Nullable MediaController mediaController;

	MediaPlayerInfo(@Nullable MediaController controller, byte majorType, int subType,
	byte playStatus, short[] featureBitMask, @NonNull String packageName,
	@Nullable String displayableName) {
	this.setMajorType(majorType);
	this.setSubType(subType);
	this.playStatus = playStatus;
	// store a copy the FeatureBitMask array
	this.featureBitMask = Arrays.copyOf(featureBitMask, featureBitMask.length);
	Arrays.sort(this.featureBitMask);
	this.setPackageName(packageName);
	this.setDisplayableName(displayableName);
	this.setMediaController(controller);
	}

	/* getters and setters */
	byte getPlayStatus() {
	return playStatus;
	}

	void setPlayStatus(byte playStatus) {
	this.playStatus = playStatus;
	}

	MediaController getMediaController() {
	return mediaController;
	}

	void setMediaController(MediaController mediaController) {
	if (mediaController != null) {
	this.packageName = mediaController.getPackageName();
	}
	this.mediaController = mediaController;
	}

	void setPackageName(@NonNull String name) {
	// Controller determines package name when it is set.
	if (mediaController != null) return;
	this.packageName = name;
	}

	String getPackageName() {
	if (mediaController != null) {
	return mediaController.getPackageName();
	} else if (packageName != null) {
	return packageName;
	}
	return null;
	}

	byte getMajorType() {
	return majorType;
	}

	void setMajorType(byte majorType) {
	this.majorType = majorType;
	}

	int getSubType() {
	return subType;
	}

	void setSubType(int subType) {
	this.subType = subType;
	}

	String getDisplayableName() {
	return displayableName;
	}

	void setDisplayableName(@Nullable String displayableName) {
	if (displayableName == null) displayableName = "";
	this.displayableName = displayableName;
	}

	short[] getFeatureBitMask() {
	return featureBitMask;
	}

	void setFeatureBitMask(short[] featureBitMask) {
	synchronized (this) {
	this.featureBitMask = Arrays.copyOf(featureBitMask, featureBitMask.length);
	Arrays.sort(this.featureBitMask);
	}
	}

	boolean isBrowseSupported() {
	synchronized (this) {
	if (this.featureBitMask == null) return false;
	for (short bit : this.featureBitMask) {
	if (bit == AvrcpConstants.AVRC_PF_BROWSE_BIT_NO) return true;
	}
	}
	return false;
	}

	/** Tests if the view of this player presented to the controller is different enough to
	* justify sending an Available Players Changed update */
	public boolean equalView(MediaPlayerInfo other) {
	return (this.majorType == other.getMajorType()) && (this.subType == other.getSubType())
	&& Arrays.equals(this.featureBitMask, other.getFeatureBitMask())
	&& this.displayableName.equals(other.getDisplayableName());
	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("MediaPlayerInfo ");
	sb.append(getPackageName());
	sb.append(" (as '" + getDisplayableName() + "')");
	sb.append(" Type = " + getMajorType());
	sb.append(", SubType = " + getSubType());
	sb.append(", Status = " + playStatus);
	sb.append(" Feature Bits [");
	short[] bits = getFeatureBitMask();
	for (int i = 0; i < bits.length; i++) {
	if (i != 0) sb.append(" ");
	sb.append(bits[i]);
	}
	sb.append("] Controller: ");
	sb.append(getMediaController());
	return sb.toString();
	}
	}

	/* stores information for browsable Media Players available in the system */
	class BrowsePlayerInfo {
	String packageName;
	String displayableName;
	String serviceClass;

	public BrowsePlayerInfo(String packageName, String displayableName, String serviceClass) {
	this.packageName = packageName;
	this.displayableName = displayableName;
	this.serviceClass = serviceClass;
	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("BrowsePlayerInfo ");
	sb.append(packageName);
	sb.append(" ( as '" + displayableName + "')");
	sb.append(" service " + serviceClass);
	return sb.toString();
	}
	}

	class FolderItemsData {
	/* initialize sizes for rsp parameters */
	int mNumItems;
	int[] mAttributesNum;
	byte[] mFolderTypes;
	byte[] mItemTypes;
	byte[] mPlayable;
	byte[] mItemUid;
	String[] mDisplayNames;
	int[] mAttrIds;
	String[] mAttrValues;
	int attrCounter;

	public FolderItemsData(int size) {
	mNumItems = size;
	mAttributesNum = new int[size];

	mFolderTypes = new byte[size]; /* folderTypes */
	mItemTypes = new byte[size]; /* folder or media item */
	mPlayable = new byte[size];
	Arrays.fill(mFolderTypes, AvrcpConstants.FOLDER_TYPE_MIXED);
	Arrays.fill(mItemTypes, AvrcpConstants.BTRC_ITEM_MEDIA);
	Arrays.fill(mPlayable, AvrcpConstants.ITEM_PLAYABLE);

	mItemUid = new byte[size * AvrcpConstants.UID_SIZE];
	mDisplayNames = new String[size];

	mAttrIds = null; /* array of attr ids */
	mAttrValues = null; /* array of attr values */
	}
	}

	/** A queue that evicts the first element when you add an element to the end when it reaches a
	* maximum size.
	* This is useful for keeping a FIFO queue of items where the items drop off the front, i.e. a log
	* with a maximum size.
	*/
	class EvictingQueue<E> extends ArrayDeque<E> {
	private int mMaxSize;

	public EvictingQueue(int maxSize) {
	super();
	mMaxSize = maxSize;
	}

	public EvictingQueue(int maxSize, int initialElements) {
	super(initialElements);
	mMaxSize = maxSize;
	}

	public EvictingQueue(int maxSize, Collection<? extends E> c) {
	super(c);
	mMaxSize = maxSize;
	}

	@Override
	public void addFirst(E e) {
	if (super.size() == mMaxSize) return;
	super.addFirst(e);
	}

	@Override
	public void addLast(E e) {
	if (super.size() == mMaxSize) {
	super.remove();
	}
	super.addLast(e);
	}

	@Override
	public boolean offerFirst(E e) {
	if (super.size() == mMaxSize) return false;
	return super.offerFirst(e);
	}

	@Override
	public boolean offerLast(E e) {
	if (super.size() == mMaxSize) {
	super.remove();
	}
	return super.offerLast(e);
	}
	}