media/java/android/media/AudioDeviceAttributes.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2019 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 android.media;

 import android.annotation.IntDef;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.SystemApi;
 import android.os.Parcel;
 import android.os.Parcelable;

 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;

 /**
  * @hide
  * Class to represent the attributes of an audio device: its type (speaker, headset...), address
  * (if known) and role (input, output).
  * <p>Unlike {@link AudioDeviceInfo}, the device
  * doesn't need to be connected to be uniquely identified, it can
  * for instance represent a specific A2DP headset even after a
  * disconnection, whereas the corresponding <code>AudioDeviceInfo</code>
  * would then be invalid.
  * <p>While creating / obtaining an instance is not protected by a
  * permission, APIs using one rely on MODIFY_AUDIO_ROUTING.
  */
 @SystemApi
 public final class AudioDeviceAttributes implements Parcelable {

     /**
      * A role identifying input devices, such as microphones.
      */
     public static final int ROLE_INPUT = AudioPort.ROLE_SOURCE;
     /**
      * A role identifying output devices, such as speakers or headphones.
      */
     public static final int ROLE_OUTPUT = AudioPort.ROLE_SINK;

     /** @hide */
     @IntDef(flag = false, prefix = "ROLE_", value = {
             ROLE_INPUT, ROLE_OUTPUT }
     )
     @Retention(RetentionPolicy.SOURCE)
     public @interface Role {}

     /**
      * The audio device type, as defined in {@link AudioDeviceInfo}
      */
     private final @AudioDeviceInfo.AudioDeviceType int mType;
     /**
      * The unique address of the device. Some devices don't have addresses, only an empty string.
      */
     private @NonNull String mAddress;
     /**
      * The non-unique name of the device. Some devices don't have names, only an empty string.
      * Should not be used as a unique identifier for a device.
      */
     private final @NonNull String mName;
     /**
      * Is input or output device
      */
     private final @Role int mRole;
     /**
      * The internal audio device type
      */
     private final int mNativeType;
     /**
      * List of AudioProfiles supported by the device
      */
     private final @NonNull List<AudioProfile> mAudioProfiles;
     /**
      * List of AudioDescriptors supported by the device
      */
     private final @NonNull List<AudioDescriptor> mAudioDescriptors;

     /**
      * @hide
      * Constructor from a valid {@link AudioDeviceInfo}
      * @param deviceInfo the connected audio device from which to obtain the device-identifying
      *                   type and address.
      */
     @SystemApi
     public AudioDeviceAttributes(@NonNull AudioDeviceInfo deviceInfo) {
         Objects.requireNonNull(deviceInfo);
         mRole = deviceInfo.isSink() ? ROLE_OUTPUT : ROLE_INPUT;
         mType = deviceInfo.getType();
         mAddress = deviceInfo.getAddress();
         mName = String.valueOf(deviceInfo.getProductName());
         mNativeType = deviceInfo.getInternalType();
         mAudioProfiles = deviceInfo.getAudioProfiles();
         mAudioDescriptors = deviceInfo.getAudioDescriptors();
     }

     /**
      * @hide
      * Constructor from role, device type and address
      * @param role indicates input or output role
      * @param type the device type, as defined in {@link AudioDeviceInfo}
      * @param address the address of the device, or an empty string for devices without one
      */
     @SystemApi
     public AudioDeviceAttributes(@Role int role, @AudioDeviceInfo.AudioDeviceType int type,
             @NonNull String address) {
         this(role, type, address, "", new ArrayList<>(), new ArrayList<>());
     }

     /**
      * @hide
      * Constructor with specification of all attributes
      * @param role indicates input or output role
      * @param type the device type, as defined in {@link AudioDeviceInfo}
      * @param address the address of the device, or an empty string for devices without one
      * @param name the name of the device, or an empty string for devices without one
      * @param profiles the list of AudioProfiles supported by the device
      * @param descriptors the list of AudioDescriptors supported by the device
      */
     @SystemApi
     public AudioDeviceAttributes(@Role int role, @AudioDeviceInfo.AudioDeviceType int type,
             @NonNull String address, @NonNull String name, @NonNull List<AudioProfile> profiles,
             @NonNull List<AudioDescriptor> descriptors) {
         Objects.requireNonNull(address);
         if (role != ROLE_OUTPUT && role != ROLE_INPUT) {
             throw new IllegalArgumentException("Invalid role " + role);
         }
         if (role == ROLE_OUTPUT) {
             AudioDeviceInfo.enforceValidAudioDeviceTypeOut(type);
             mNativeType = AudioDeviceInfo.convertDeviceTypeToInternalDevice(type);
         } else if (role == ROLE_INPUT) {
             AudioDeviceInfo.enforceValidAudioDeviceTypeIn(type);
             mNativeType = AudioDeviceInfo.convertDeviceTypeToInternalInputDevice(type, address);
         } else {
             mNativeType = AudioSystem.DEVICE_NONE;
         }

         mRole = role;
         mType = type;
         mAddress = address;
         mName = name;
         mAudioProfiles = profiles;
         mAudioDescriptors = descriptors;
     }

     /**
      * @hide
      * Constructor called from AudioSystem JNI when creating an AudioDeviceAttributes from a native
      * AudioDeviceTypeAddr instance.
      * @param nativeType the internal device type, as defined in {@link AudioSystem}
      * @param address the address of the device, or an empty string for devices without one
      */
     public AudioDeviceAttributes(int nativeType, @NonNull String address) {
         this(nativeType, address, "");
     }

     /**
      * @hide
      * Constructor called from BtHelper to connect or disconnect a Bluetooth device.
      * @param nativeType the internal device type, as defined in {@link AudioSystem}
      * @param address the address of the device, or an empty string for devices without one
      * @param name the name of the device, or an empty string for devices without one
      */
     public AudioDeviceAttributes(int nativeType, @NonNull String address, @NonNull String name) {
         mRole = AudioSystem.isInputDevice(nativeType) ? ROLE_INPUT : ROLE_OUTPUT;
         mType = AudioDeviceInfo.convertInternalDeviceToDeviceType(nativeType);
         mAddress = address;
         mName = name;
         mNativeType = nativeType;
         mAudioProfiles = new ArrayList<>();
         mAudioDescriptors = new ArrayList<>();
     }

     /**
      * @hide
      * Copy Constructor.
      * @param ada the copied AudioDeviceAttributes
      */
     public AudioDeviceAttributes(AudioDeviceAttributes ada) {
         mRole = ada.getRole();
         mType = ada.getType();
         mAddress = ada.getAddress();
         mName = ada.getName();
         mNativeType = ada.getInternalType();
         mAudioProfiles = ada.getAudioProfiles();
         mAudioDescriptors = ada.getAudioDescriptors();
     }

     /**
      * @hide
      * Returns the role of a device
      * @return the role
      */
     @SystemApi
     public @Role int getRole() {
         return mRole;
     }

     /**
      * @hide
      * Returns the audio device type of a device
      * @return the type, as defined in {@link AudioDeviceInfo}
      */
     @SystemApi
     public @AudioDeviceInfo.AudioDeviceType int getType() {
         return mType;
     }

     /**
      * @hide
      * Returns the address of the audio device, or an empty string for devices without one
      * @return the device address
      */
     @SystemApi
     public @NonNull String getAddress() {
         return mAddress;
     }

     /**
      * @hide
      * Sets the device address. Only used by audio service.
      */
     public void setAddress(@NonNull String address) {
         Objects.requireNonNull(address);
         mAddress = address;
     }

     /**
      * @hide
      * Returns the name of the audio device, or an empty string for devices without one
      * @return the device name
      */
     @SystemApi
     public @NonNull String getName() {
         return mName;
     }

     /**
      * @hide
      * Returns the internal device type of a device
      * @return the internal device type
      */
     public int getInternalType() {
         return mNativeType;
     }

     /**
      * @hide
      * Returns the list of AudioProfiles supported by the device
      * @return the list of AudioProfiles
      */
     @SystemApi
     public @NonNull List<AudioProfile> getAudioProfiles() {
         return mAudioProfiles;
     }

     /**
      * @hide
      * Returns the list of AudioDescriptors supported by the device
      * @return the list of AudioDescriptors
      */
     @SystemApi
     public @NonNull List<AudioDescriptor> getAudioDescriptors() {
         return mAudioDescriptors;
     }

     @Override
     public int hashCode() {
         return Objects.hash(mRole, mType, mAddress, mName, mAudioProfiles, mAudioDescriptors);
     }

     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;

         AudioDeviceAttributes that = (AudioDeviceAttributes) o;
         return ((mRole == that.mRole)
                 && (mType == that.mType)
                 && mAddress.equals(that.mAddress)
                 && mName.equals(that.mName)
                 && mAudioProfiles.equals(that.mAudioProfiles)
                 && mAudioDescriptors.equals(that.mAudioDescriptors));
     }

     /**
      * Returns true if the role, type and address are equal. Called to compare with an
      * AudioDeviceAttributes that was created from a native AudioDeviceTypeAddr instance.
      * @param o object to compare with
      * @return whether role, type and address are equal
      */
     public boolean equalTypeAddress(@Nullable Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;

         AudioDeviceAttributes that = (AudioDeviceAttributes) o;
         return ((mRole == that.mRole)
                 && (mType == that.mType)
                 && mAddress.equals(that.mAddress));
     }

     /** @hide */
     public static String roleToString(@Role int role) {
         return (role == ROLE_OUTPUT ? "output" : "input");
     }

     @Override
     public String toString() {
         return new String("AudioDeviceAttributes:"
                 + " role:" + roleToString(mRole)
                 + " type:" + (mRole == ROLE_OUTPUT ? AudioSystem.getOutputDeviceName(mNativeType)
                         : AudioSystem.getInputDeviceName(mNativeType))
                 + " addr:" + Utils.anonymizeBluetoothAddress(mNativeType, mAddress)
                 + " name:" + mName
                 + " profiles:" + mAudioProfiles.toString()
                 + " descriptors:" + mAudioDescriptors.toString());
     }

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(@NonNull Parcel dest, int flags) {
         dest.writeInt(mRole);
         dest.writeInt(mType);
         dest.writeString(mAddress);
         dest.writeString(mName);
         dest.writeInt(mNativeType);
         dest.writeParcelableArray(
                 mAudioProfiles.toArray(new AudioProfile[mAudioProfiles.size()]), flags);
         dest.writeParcelableArray(
                 mAudioDescriptors.toArray(new AudioDescriptor[mAudioDescriptors.size()]), flags);
     }

     private AudioDeviceAttributes(@NonNull Parcel in) {
         mRole = in.readInt();
         mType = in.readInt();
         mAddress = in.readString();
         mName = in.readString();
         mNativeType = in.readInt();
         AudioProfile[] audioProfilesArray =
                 in.readParcelableArray(AudioProfile.class.getClassLoader(), AudioProfile.class);
         mAudioProfiles = new ArrayList<AudioProfile>(Arrays.asList(audioProfilesArray));
         AudioDescriptor[] audioDescriptorsArray = in.readParcelableArray(
                 AudioDescriptor.class.getClassLoader(), AudioDescriptor.class);
         mAudioDescriptors = new ArrayList<AudioDescriptor>(Arrays.asList(audioDescriptorsArray));
     }

     public static final @NonNull Parcelable.Creator<AudioDeviceAttributes> CREATOR =
             new Parcelable.Creator<AudioDeviceAttributes>() {
         /**
          * Rebuilds an AudioDeviceAttributes previously stored with writeToParcel().
          * @param p Parcel object to read the AudioDeviceAttributes from
          * @return a new AudioDeviceAttributes created from the data in the parcel
          */
         public AudioDeviceAttributes createFromParcel(Parcel p) {
             return new AudioDeviceAttributes(p);
         }

         public AudioDeviceAttributes[] newArray(int size) {
             return new AudioDeviceAttributes[size];
         }
     };
 }
	/*
	* Copyright (C) 2019 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 android.media;

	import android.annotation.IntDef;
	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.annotation.SystemApi;
	import android.os.Parcel;
	import android.os.Parcelable;

	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	import java.util.Objects;

	/**
	* @hide
	* Class to represent the attributes of an audio device: its type (speaker, headset...), address
	* (if known) and role (input, output).
	* <p>Unlike {@link AudioDeviceInfo}, the device
	* doesn't need to be connected to be uniquely identified, it can
	* for instance represent a specific A2DP headset even after a
	* disconnection, whereas the corresponding <code>AudioDeviceInfo</code>
	* would then be invalid.
	* <p>While creating / obtaining an instance is not protected by a
	* permission, APIs using one rely on MODIFY_AUDIO_ROUTING.
	*/
	@SystemApi
	public final class AudioDeviceAttributes implements Parcelable {

	/**
	* A role identifying input devices, such as microphones.
	*/
	public static final int ROLE_INPUT = AudioPort.ROLE_SOURCE;
	/**
	* A role identifying output devices, such as speakers or headphones.
	*/
	public static final int ROLE_OUTPUT = AudioPort.ROLE_SINK;

	/** @hide */
	@IntDef(flag = false, prefix = "ROLE_", value = {
	ROLE_INPUT, ROLE_OUTPUT }
	)
	@Retention(RetentionPolicy.SOURCE)
	public @interface Role {}

	/**
	* The audio device type, as defined in {@link AudioDeviceInfo}
	*/
	private final @AudioDeviceInfo.AudioDeviceType int mType;
	/**
	* The unique address of the device. Some devices don't have addresses, only an empty string.
	*/
	private @NonNull String mAddress;
	/**
	* The non-unique name of the device. Some devices don't have names, only an empty string.
	* Should not be used as a unique identifier for a device.
	*/
	private final @NonNull String mName;
	/**
	* Is input or output device
	*/
	private final @Role int mRole;
	/**
	* The internal audio device type
	*/
	private final int mNativeType;
	/**
	* List of AudioProfiles supported by the device
	*/
	private final @NonNull List<AudioProfile> mAudioProfiles;
	/**
	* List of AudioDescriptors supported by the device
	*/
	private final @NonNull List<AudioDescriptor> mAudioDescriptors;

	/**
	* @hide
	* Constructor from a valid {@link AudioDeviceInfo}
	* @param deviceInfo the connected audio device from which to obtain the device-identifying
	* type and address.
	*/
	@SystemApi
	public AudioDeviceAttributes(@NonNull AudioDeviceInfo deviceInfo) {
	Objects.requireNonNull(deviceInfo);
	mRole = deviceInfo.isSink() ? ROLE_OUTPUT : ROLE_INPUT;
	mType = deviceInfo.getType();
	mAddress = deviceInfo.getAddress();
	mName = String.valueOf(deviceInfo.getProductName());
	mNativeType = deviceInfo.getInternalType();
	mAudioProfiles = deviceInfo.getAudioProfiles();
	mAudioDescriptors = deviceInfo.getAudioDescriptors();
	}

	/**
	* @hide
	* Constructor from role, device type and address
	* @param role indicates input or output role
	* @param type the device type, as defined in {@link AudioDeviceInfo}
	* @param address the address of the device, or an empty string for devices without one
	*/
	@SystemApi
	public AudioDeviceAttributes(@Role int role, @AudioDeviceInfo.AudioDeviceType int type,
	@NonNull String address) {
	this(role, type, address, "", new ArrayList<>(), new ArrayList<>());
	}

	/**
	* @hide
	* Constructor with specification of all attributes
	* @param role indicates input or output role
	* @param type the device type, as defined in {@link AudioDeviceInfo}
	* @param address the address of the device, or an empty string for devices without one
	* @param name the name of the device, or an empty string for devices without one
	* @param profiles the list of AudioProfiles supported by the device
	* @param descriptors the list of AudioDescriptors supported by the device
	*/
	@SystemApi
	public AudioDeviceAttributes(@Role int role, @AudioDeviceInfo.AudioDeviceType int type,
	@NonNull String address, @NonNull String name, @NonNull List<AudioProfile> profiles,
	@NonNull List<AudioDescriptor> descriptors) {
	Objects.requireNonNull(address);
	if (role != ROLE_OUTPUT && role != ROLE_INPUT) {
	throw new IllegalArgumentException("Invalid role " + role);
	}
	if (role == ROLE_OUTPUT) {
	AudioDeviceInfo.enforceValidAudioDeviceTypeOut(type);
	mNativeType = AudioDeviceInfo.convertDeviceTypeToInternalDevice(type);
	} else if (role == ROLE_INPUT) {
	AudioDeviceInfo.enforceValidAudioDeviceTypeIn(type);
	mNativeType = AudioDeviceInfo.convertDeviceTypeToInternalInputDevice(type, address);
	} else {
	mNativeType = AudioSystem.DEVICE_NONE;
	}

	mRole = role;
	mType = type;
	mAddress = address;
	mName = name;
	mAudioProfiles = profiles;
	mAudioDescriptors = descriptors;
	}

	/**
	* @hide
	* Constructor called from AudioSystem JNI when creating an AudioDeviceAttributes from a native
	* AudioDeviceTypeAddr instance.
	* @param nativeType the internal device type, as defined in {@link AudioSystem}
	* @param address the address of the device, or an empty string for devices without one
	*/
	public AudioDeviceAttributes(int nativeType, @NonNull String address) {
	this(nativeType, address, "");
	}

	/**
	* @hide
	* Constructor called from BtHelper to connect or disconnect a Bluetooth device.
	* @param nativeType the internal device type, as defined in {@link AudioSystem}
	* @param address the address of the device, or an empty string for devices without one
	* @param name the name of the device, or an empty string for devices without one
	*/
	public AudioDeviceAttributes(int nativeType, @NonNull String address, @NonNull String name) {
	mRole = AudioSystem.isInputDevice(nativeType) ? ROLE_INPUT : ROLE_OUTPUT;
	mType = AudioDeviceInfo.convertInternalDeviceToDeviceType(nativeType);
	mAddress = address;
	mName = name;
	mNativeType = nativeType;
	mAudioProfiles = new ArrayList<>();
	mAudioDescriptors = new ArrayList<>();
	}

	/**
	* @hide
	* Copy Constructor.
	* @param ada the copied AudioDeviceAttributes
	*/
	public AudioDeviceAttributes(AudioDeviceAttributes ada) {
	mRole = ada.getRole();
	mType = ada.getType();
	mAddress = ada.getAddress();
	mName = ada.getName();
	mNativeType = ada.getInternalType();
	mAudioProfiles = ada.getAudioProfiles();
	mAudioDescriptors = ada.getAudioDescriptors();
	}

	/**
	* @hide
	* Returns the role of a device
	* @return the role
	*/
	@SystemApi
	public @Role int getRole() {
	return mRole;
	}

	/**
	* @hide
	* Returns the audio device type of a device
	* @return the type, as defined in {@link AudioDeviceInfo}
	*/
	@SystemApi
	public @AudioDeviceInfo.AudioDeviceType int getType() {
	return mType;
	}

	/**
	* @hide
	* Returns the address of the audio device, or an empty string for devices without one
	* @return the device address
	*/
	@SystemApi
	public @NonNull String getAddress() {
	return mAddress;
	}

	/**
	* @hide
	* Sets the device address. Only used by audio service.
	*/
	public void setAddress(@NonNull String address) {
	Objects.requireNonNull(address);
	mAddress = address;
	}

	/**
	* @hide
	* Returns the name of the audio device, or an empty string for devices without one
	* @return the device name
	*/
	@SystemApi
	public @NonNull String getName() {
	return mName;
	}

	/**
	* @hide
	* Returns the internal device type of a device
	* @return the internal device type
	*/
	public int getInternalType() {
	return mNativeType;
	}

	/**
	* @hide
	* Returns the list of AudioProfiles supported by the device
	* @return the list of AudioProfiles
	*/
	@SystemApi
	public @NonNull List<AudioProfile> getAudioProfiles() {
	return mAudioProfiles;
	}

	/**
	* @hide
	* Returns the list of AudioDescriptors supported by the device
	* @return the list of AudioDescriptors
	*/
	@SystemApi
	public @NonNull List<AudioDescriptor> getAudioDescriptors() {
	return mAudioDescriptors;
	}

	@Override
	public int hashCode() {
	return Objects.hash(mRole, mType, mAddress, mName, mAudioProfiles, mAudioDescriptors);
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) return true;
	if (o == null \|\| getClass() != o.getClass()) return false;

	AudioDeviceAttributes that = (AudioDeviceAttributes) o;
	return ((mRole == that.mRole)
	&& (mType == that.mType)
	&& mAddress.equals(that.mAddress)
	&& mName.equals(that.mName)
	&& mAudioProfiles.equals(that.mAudioProfiles)
	&& mAudioDescriptors.equals(that.mAudioDescriptors));
	}

	/**
	* Returns true if the role, type and address are equal. Called to compare with an
	* AudioDeviceAttributes that was created from a native AudioDeviceTypeAddr instance.
	* @param o object to compare with
	* @return whether role, type and address are equal
	*/
	public boolean equalTypeAddress(@Nullable Object o) {
	if (this == o) return true;
	if (o == null \|\| getClass() != o.getClass()) return false;

	AudioDeviceAttributes that = (AudioDeviceAttributes) o;
	return ((mRole == that.mRole)
	&& (mType == that.mType)
	&& mAddress.equals(that.mAddress));
	}

	/** @hide */
	public static String roleToString(@Role int role) {
	return (role == ROLE_OUTPUT ? "output" : "input");
	}

	@Override
	public String toString() {
	return new String("AudioDeviceAttributes:"
	+ " role:" + roleToString(mRole)
	+ " type:" + (mRole == ROLE_OUTPUT ? AudioSystem.getOutputDeviceName(mNativeType)
	: AudioSystem.getInputDeviceName(mNativeType))
	+ " addr:" + Utils.anonymizeBluetoothAddress(mNativeType, mAddress)
	+ " name:" + mName
	+ " profiles:" + mAudioProfiles.toString()
	+ " descriptors:" + mAudioDescriptors.toString());
	}

	@Override
	public int describeContents() {
	return 0;
	}

	@Override
	public void writeToParcel(@NonNull Parcel dest, int flags) {
	dest.writeInt(mRole);
	dest.writeInt(mType);
	dest.writeString(mAddress);
	dest.writeString(mName);
	dest.writeInt(mNativeType);
	dest.writeParcelableArray(
	mAudioProfiles.toArray(new AudioProfile[mAudioProfiles.size()]), flags);
	dest.writeParcelableArray(
	mAudioDescriptors.toArray(new AudioDescriptor[mAudioDescriptors.size()]), flags);
	}

	private AudioDeviceAttributes(@NonNull Parcel in) {
	mRole = in.readInt();
	mType = in.readInt();
	mAddress = in.readString();
	mName = in.readString();
	mNativeType = in.readInt();
	AudioProfile[] audioProfilesArray =
	in.readParcelableArray(AudioProfile.class.getClassLoader(), AudioProfile.class);
	mAudioProfiles = new ArrayList<AudioProfile>(Arrays.asList(audioProfilesArray));
	AudioDescriptor[] audioDescriptorsArray = in.readParcelableArray(
	AudioDescriptor.class.getClassLoader(), AudioDescriptor.class);
	mAudioDescriptors = new ArrayList<AudioDescriptor>(Arrays.asList(audioDescriptorsArray));
	}

	public static final @NonNull Parcelable.Creator<AudioDeviceAttributes> CREATOR =
	new Parcelable.Creator<AudioDeviceAttributes>() {
	/**
	* Rebuilds an AudioDeviceAttributes previously stored with writeToParcel().
	* @param p Parcel object to read the AudioDeviceAttributes from
	* @return a new AudioDeviceAttributes created from the data in the parcel
	*/
	public AudioDeviceAttributes createFromParcel(Parcel p) {
	return new AudioDeviceAttributes(p);
	}

	public AudioDeviceAttributes[] newArray(int size) {
	return new AudioDeviceAttributes[size];
	}
	};
	}