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
17package android.hardware.usb;
18
19import android.os.Parcel;
20import 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 */
35public 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     */
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     */
72    public int getId() {
73        return mId;
74    }
75
76    /**
77     * Returns the configuration's name.
78     *
79     * @return the configuration's name
80     */
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     */
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     */
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     */
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     */
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     */
128    public UsbInterface getInterface(int index) {
129        return (UsbInterface)mInterfaces[index];
130    }
131
132    /**
133     * Only used by UsbService implementation
134     * @hide
135     */
136    public void setInterfaces(Parcelable[] interfaces) {
137        mInterfaces = interfaces;
138    }
139
140    @Override
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
171    public int describeContents() {
172        return 0;
173    }
174
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