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.annotation.NonNull;
20 import android.annotation.Nullable;
21 import android.os.Parcel;
22 import android.os.Parcelable;
23 
24 import com.android.internal.util.Preconditions;
25 
26 /**
27  * A class representing a configuration on a {@link UsbDevice}.
28  * A USB configuration can have one or more interfaces, each one providing a different
29  * piece of functionality, separate from the other interfaces.
30  * An interface will have one or more {@link UsbEndpoint}s, which are the
31  * channels by which the host transfers data with the device.
32  *
33  * <div class="special reference">
34  * <h3>Developer Guides</h3>
35  * <p>For more information about communicating with USB hardware, read the
36  * <a href="{@docRoot}guide/topics/usb/index.html">USB</a> developer guide.</p>
37  * </div>
38  */
39 public class UsbConfiguration implements Parcelable {
40 
41     private final int mId;
42     private final @Nullable String mName;
43     private final int mAttributes;
44     private final int mMaxPower;
45 
46     /** All interfaces for this config, only null during creation */
47     private @Nullable Parcelable[] mInterfaces;
48 
49     /**
50      * Mask for "self-powered" bit in the configuration's attributes.
51      */
52     private static final int ATTR_SELF_POWERED = 1 << 6;
53 
54     /**
55      * Mask for "remote wakeup" bit in the configuration's attributes.
56      */
57     private static final int ATTR_REMOTE_WAKEUP = 1 << 5;
58 
59     /**
60      * UsbConfiguration should only be instantiated by UsbService implementation
61      * @hide
62      */
UsbConfiguration(int id, @Nullable String name, int attributes, int maxPower)63     public UsbConfiguration(int id, @Nullable String name, int attributes, int maxPower) {
64         mId = id;
65         mName = name;
66         mAttributes = attributes;
67         mMaxPower = maxPower;
68     }
69 
70     /**
71      * Returns the configuration's ID field.
72      * This is an integer that uniquely identifies the configuration on the device.
73      *
74      * @return the configuration's ID
75      */
getId()76     public int getId() {
77         return mId;
78     }
79 
80     /**
81      * Returns the configuration's name.
82      *
83      * @return the configuration's name, or {@code null} if the property could not be read
84      */
getName()85     public @Nullable String getName() {
86         return mName;
87     }
88 
89     /**
90      * Returns the self-powered attribute value configuration's attributes field.
91      * This attribute indicates that the device has a power source other than the USB connection.
92      *
93      * @return the configuration's self-powered attribute
94      */
isSelfPowered()95     public boolean isSelfPowered() {
96         return (mAttributes & ATTR_SELF_POWERED) != 0;
97     }
98 
99     /**
100      * Returns the remote-wakeup attribute value configuration's attributes field.
101      * This attributes that the device may signal the host to wake from suspend.
102      *
103      * @return the configuration's remote-wakeup attribute
104      */
isRemoteWakeup()105     public boolean isRemoteWakeup() {
106         return (mAttributes & ATTR_REMOTE_WAKEUP) != 0;
107     }
108 
109     /**
110      * Returns the attributes of this configuration
111      *
112      * @return the configuration's attributes
113      *
114      * @hide
115      */
getAttributes()116     public int getAttributes() {
117         return mAttributes;
118     }
119 
120     /**
121      * Returns the configuration's max power consumption, in milliamps.
122      *
123      * @return the configuration's max power
124      */
getMaxPower()125     public int getMaxPower() {
126         return mMaxPower * 2;
127     }
128 
129     /**
130      * Returns the number of {@link UsbInterface}s this configuration contains.
131      *
132      * @return the number of endpoints
133      */
getInterfaceCount()134     public int getInterfaceCount() {
135         return mInterfaces.length;
136     }
137 
138     /**
139      * Returns the {@link UsbInterface} at the given index.
140      *
141      * @return the interface
142      */
getInterface(int index)143     public @NonNull UsbInterface getInterface(int index) {
144         return (UsbInterface)mInterfaces[index];
145     }
146 
147     /**
148      * Only used by UsbService implementation
149      * @hide
150      */
setInterfaces(@onNull Parcelable[] interfaces)151     public void setInterfaces(@NonNull Parcelable[] interfaces) {
152         mInterfaces = Preconditions.checkArrayElementsNotNull(interfaces, "interfaces");
153     }
154 
155     @Override
toString()156     public String toString() {
157         StringBuilder builder = new StringBuilder("UsbConfiguration[mId=" + mId +
158                 ",mName=" + mName + ",mAttributes=" + mAttributes +
159                 ",mMaxPower=" + mMaxPower + ",mInterfaces=[");
160         for (int i = 0; i < mInterfaces.length; i++) {
161             builder.append("\n");
162             builder.append(mInterfaces[i].toString());
163         }
164         builder.append("]");
165         return builder.toString();
166     }
167 
168     public static final @android.annotation.NonNull Parcelable.Creator<UsbConfiguration> CREATOR =
169         new Parcelable.Creator<UsbConfiguration>() {
170         public UsbConfiguration createFromParcel(Parcel in) {
171             int id = in.readInt();
172             String name = in.readString();
173             int attributes = in.readInt();
174             int maxPower = in.readInt();
175             Parcelable[] interfaces = in.readParcelableArray(
176                     UsbInterface.class.getClassLoader(), UsbInterface.class);
177             UsbConfiguration configuration = new UsbConfiguration(id, name, attributes, maxPower);
178             configuration.setInterfaces(interfaces);
179             return configuration;
180         }
181 
182         public UsbConfiguration[] newArray(int size) {
183             return new UsbConfiguration[size];
184         }
185     };
186 
describeContents()187     public int describeContents() {
188         return 0;
189     }
190 
writeToParcel(Parcel parcel, int flags)191     public void writeToParcel(Parcel parcel, int flags) {
192         parcel.writeInt(mId);
193         parcel.writeString(mName);
194         parcel.writeInt(mAttributes);
195         parcel.writeInt(mMaxPower);
196         parcel.writeParcelableArray(mInterfaces, 0);
197    }
198 }
199