1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.hardware.usb;
18 
19 import android.os.Parcel;
20 import android.os.Parcelable;
21 
22 /**
23  * A class representing a configuration on a {@link UsbDevice}.
24  * A USB configuration can have one or more interfaces, each one providing a different
25  * piece of functionality, separate from the other interfaces.
26  * An interface will have one or more {@link UsbEndpoint}s, which are the
27  * channels by which the host transfers data with the device.
28  *
29  * <div class="special reference">
30  * <h3>Developer Guides</h3>
31  * <p>For more information about communicating with USB hardware, read the
32  * <a href="{@docRoot}guide/topics/usb/index.html">USB</a> developer guide.</p>
33  * </div>
34  */
35 public class UsbConfiguration implements Parcelable {
36 
37     private final int mId;
38     private final String mName;
39     private final int mAttributes;
40     private final int mMaxPower;
41     private Parcelable[] mInterfaces;
42 
43     /**
44      * Mask for "self-powered" bit in the configuration's attributes.
45      * @see #getAttributes
46      */
47     private static final int ATTR_SELF_POWERED = 1 << 6;
48 
49     /**
50      * Mask for "remote wakeup" bit in the configuration's attributes.
51      * @see #getAttributes
52      */
53     private static final int ATTR_REMOTE_WAKEUP = 1 << 5;
54 
55     /**
56      * UsbConfiguration should only be instantiated by UsbService implementation
57      * @hide
58      */
UsbConfiguration(int id, String name, int attributes, int maxPower)59     public UsbConfiguration(int id, String name, int attributes, int maxPower) {
60         mId = id;
61         mName = name;
62         mAttributes = attributes;
63         mMaxPower = maxPower;
64     }
65 
66     /**
67      * Returns the configuration's ID field.
68      * This is an integer that uniquely identifies the configuration on the device.
69      *
70      * @return the configuration's ID
71      */
getId()72     public int getId() {
73         return mId;
74     }
75 
76     /**
77      * Returns the configuration's name.
78      *
79      * @return the configuration's name
80      */
getName()81     public String getName() {
82         return mName;
83     }
84 
85     /**
86      * Returns the self-powered attribute value configuration's attributes field.
87      * This attribute indicates that the device has a power source other than the USB connection.
88      *
89      * @return the configuration's self-powered attribute
90      */
isSelfPowered()91     public boolean isSelfPowered() {
92         return (mAttributes & ATTR_SELF_POWERED) != 0;
93     }
94 
95     /**
96      * Returns the remote-wakeup attribute value configuration's attributes field.
97      * This attributes that the device may signal the host to wake from suspend.
98      *
99      * @return the configuration's remote-wakeup attribute
100      */
isRemoteWakeup()101     public boolean isRemoteWakeup() {
102         return (mAttributes & ATTR_REMOTE_WAKEUP) != 0;
103     }
104 
105     /**
106      * Returns the configuration's max power consumption, in milliamps.
107      *
108      * @return the configuration's max power
109      */
getMaxPower()110     public int getMaxPower() {
111         return mMaxPower * 2;
112     }
113 
114     /**
115      * Returns the number of {@link UsbInterface}s this configuration contains.
116      *
117      * @return the number of endpoints
118      */
getInterfaceCount()119     public int getInterfaceCount() {
120         return mInterfaces.length;
121     }
122 
123     /**
124      * Returns the {@link UsbInterface} at the given index.
125      *
126      * @return the interface
127      */
getInterface(int index)128     public UsbInterface getInterface(int index) {
129         return (UsbInterface)mInterfaces[index];
130     }
131 
132     /**
133      * Only used by UsbService implementation
134      * @hide
135      */
setInterfaces(Parcelable[] interfaces)136     public void setInterfaces(Parcelable[] interfaces) {
137         mInterfaces = interfaces;
138     }
139 
140     @Override
toString()141     public String toString() {
142         StringBuilder builder = new StringBuilder("UsbConfiguration[mId=" + mId +
143                 ",mName=" + mName + ",mAttributes=" + mAttributes +
144                 ",mMaxPower=" + mMaxPower + ",mInterfaces=[");
145         for (int i = 0; i < mInterfaces.length; i++) {
146             builder.append("\n");
147             builder.append(mInterfaces[i].toString());
148         }
149         builder.append("]");
150         return builder.toString();
151     }
152 
153     public static final Parcelable.Creator<UsbConfiguration> CREATOR =
154         new Parcelable.Creator<UsbConfiguration>() {
155         public UsbConfiguration createFromParcel(Parcel in) {
156             int id = in.readInt();
157             String name = in.readString();
158             int attributes = in.readInt();
159             int maxPower = in.readInt();
160             Parcelable[] interfaces = in.readParcelableArray(UsbInterface.class.getClassLoader());
161             UsbConfiguration configuration = new UsbConfiguration(id, name, attributes, maxPower);
162             configuration.setInterfaces(interfaces);
163             return configuration;
164         }
165 
166         public UsbConfiguration[] newArray(int size) {
167             return new UsbConfiguration[size];
168         }
169     };
170 
describeContents()171     public int describeContents() {
172         return 0;
173     }
174 
writeToParcel(Parcel parcel, int flags)175     public void writeToParcel(Parcel parcel, int flags) {
176         parcel.writeInt(mId);
177         parcel.writeString(mName);
178         parcel.writeInt(mAttributes);
179         parcel.writeInt(mMaxPower);
180         parcel.writeParcelableArray(mInterfaces, 0);
181    }
182 }
183