Home | History | Annotate | Download | only in usb 
      1 /*
      2  * Copyright (C) 2010 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.Bundle;
     20 import android.os.Parcel;
     21 import android.os.Parcelable;
     22 
     23 /**
     24  * A class representing an endpoint on a {@link UsbInterface}.
     25  * Endpoints are the channels for sending and receiving data over USB.
     26  * Typically bulk endpoints are used for sending non-trivial amounts of data.
     27  * Interrupt endpoints are used for sending small amounts of data, typically events,
     28  * separately from the main data streams.
     29  * The endpoint zero is a special endpoint for control messages sent from the host
     30  * to device.
     31  * Isochronous endpoints are currently unsupported.
     32  */
     33 public class UsbEndpoint implements Parcelable {
     34 
     35     private final int mAddress;
     36     private final int mAttributes;
     37     private final int mMaxPacketSize;
     38     private final int mInterval;
     39 
     40     /**
     41      * UsbEndpoint should only be instantiated by UsbService implementation
     42      * @hide
     43      */
     44     public UsbEndpoint(int address, int attributes, int maxPacketSize, int interval) {
     45         mAddress = address;
     46         mAttributes = attributes;
     47         mMaxPacketSize = maxPacketSize;
     48         mInterval = interval;
     49     }
     50 
     51     /**
     52      * Returns the endpoint's address field.
     53      * The address is a bitfield containing both the endpoint number
     54      * as well as the data direction of the endpoint.
     55      * the endpoint number and direction can also be accessed via
     56      * {@link #getEndpointNumber} and {@link #getDirection}.
     57      *
     58      * @return the endpoint's address
     59      */
     60     public int getAddress() {
     61         return mAddress;
     62     }
     63 
     64     /**
     65      * Extracts the endpoint's endpoint number from its address
     66      *
     67      * @return the endpoint's endpoint number
     68      */
     69     public int getEndpointNumber() {
     70         return mAddress & UsbConstants.USB_ENDPOINT_NUMBER_MASK;
     71     }
     72 
     73     /**
     74      * Returns the endpoint's direction.
     75      * Returns {@link UsbConstants#USB_DIR_OUT}
     76      * if the direction is host to device, and
     77      * {@link UsbConstants#USB_DIR_IN} if the
     78      * direction is device to host.
     79      * @see {@link UsbConstants#USB_DIR_IN}
     80      * @see {@link UsbConstants#USB_DIR_OUT}
     81      *
     82      * @return the endpoint's direction
     83      */
     84     public int getDirection() {
     85         return mAddress & UsbConstants.USB_ENDPOINT_DIR_MASK;
     86     }
     87 
     88     /**
     89      * Returns the endpoint's attributes field.
     90      *
     91      * @return the endpoint's attributes
     92      */
     93     public int getAttributes() {
     94         return mAttributes;
     95     }
     96 
     97     /**
     98      * Returns the endpoint's type.
     99      * Possible results are:
    100      * <ul>
    101      * <li>{@link UsbConstants#USB_ENDPOINT_XFER_CONTROL} (endpoint zero)
    102      * <li>{@link UsbConstants#USB_ENDPOINT_XFER_ISOC} (isochronous endpoint)
    103      * <li>{@link UsbConstants#USB_ENDPOINT_XFER_BULK} (bulk endpoint)
    104      * <li>{@link UsbConstants#USB_ENDPOINT_XFER_INT} (interrupt endpoint)
    105      * </ul>
    106      *
    107      * @return the endpoint's type
    108      */
    109     public int getType() {
    110         return mAttributes & UsbConstants.USB_ENDPOINT_XFERTYPE_MASK;
    111     }
    112 
    113     /**
    114      * Returns the endpoint's maximum packet size.
    115      *
    116      * @return the endpoint's maximum packet size
    117      */
    118     public int getMaxPacketSize() {
    119         return mMaxPacketSize;
    120     }
    121 
    122     /**
    123      * Returns the endpoint's interval field.
    124      *
    125      * @return the endpoint's interval
    126      */
    127     public int getInterval() {
    128         return mInterval;
    129     }
    130 
    131     @Override
    132     public String toString() {
    133         return "UsbEndpoint[mAddress=" + mAddress + ",mAttributes=" + mAttributes +
    134                 ",mMaxPacketSize=" + mMaxPacketSize + ",mInterval=" + mInterval +"]";
    135     }
    136 
    137     public static final Parcelable.Creator<UsbEndpoint> CREATOR =
    138         new Parcelable.Creator<UsbEndpoint>() {
    139         public UsbEndpoint createFromParcel(Parcel in) {
    140             int address = in.readInt();
    141             int attributes = in.readInt();
    142             int maxPacketSize = in.readInt();
    143             int interval = in.readInt();
    144             return new UsbEndpoint(address, attributes, maxPacketSize, interval);
    145         }
    146 
    147         public UsbEndpoint[] newArray(int size) {
    148             return new UsbEndpoint[size];
    149         }
    150     };
    151 
    152     public int describeContents() {
    153         return 0;
    154     }
    155 
    156     public void writeToParcel(Parcel parcel, int flags) {
    157         parcel.writeInt(mAddress);
    158         parcel.writeInt(mAttributes);
    159         parcel.writeInt(mMaxPacketSize);
    160         parcel.writeInt(mInterval);
    161    }
    162 }
    163