FileDocCategorySizeDatePackage
ClipDescription.javaAPI DocAndroid 5.1 API7645Thu Mar 12 22:22:10 GMT 2015android.content

ClipDescription

public class ClipDescription extends Object implements android.os.Parcelable
Meta-data describing the contents of a {@link ClipData}. Provides enough information to know if you can handle the ClipData, but not the data itself.

Developer Guides

For more information about using the clipboard framework, read the Copy and Paste developer guide.

Fields Summary
public static final String
MIMETYPE_TEXT_PLAIN
The MIME type for a clip holding plain text.
public static final String
MIMETYPE_TEXT_HTML
The MIME type for a clip holding HTML text.
public static final String
MIMETYPE_TEXT_URILIST
The MIME type for a clip holding one or more URIs. This should be used for URIs that are meaningful to a user (such as an http: URI). It should not be used for a content: URI that references some other piece of data; in that case the MIME type should be the type of the referenced data.
public static final String
MIMETYPE_TEXT_INTENT
The MIME type for a clip holding an Intent.
final CharSequence
mLabel
final String[]
mMimeTypes
public static final Parcelable.Creator
CREATOR
Constructors Summary
public ClipDescription(CharSequence label, String[] mimeTypes)
Create a new clip.

param
label Label to show to the user describing this clip.
param
mimeTypes An array of MIME types this data is available as.


                                    
         
        if (mimeTypes == null) {
            throw new NullPointerException("mimeTypes is null");
        }
        mLabel = label;
        mMimeTypes = mimeTypes;
ClipDescription(android.os.Parcel in)

        mLabel = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
        mMimeTypes = in.createStringArray();
public ClipDescription(ClipDescription o)
Create a copy of a ClipDescription.

        mLabel = o.mLabel;
        mMimeTypes = o.mMimeTypes;
Methods Summary
public static booleancompareMimeTypes(java.lang.String concreteType, java.lang.String desiredType)
Helper to compare two MIME types, where one may be a pattern.

param
concreteType A fully-specified MIME type.
param
desiredType A desired MIME type that may be a pattern such as */*.
return
Returns true if the two MIME types match.

        final int typeLength = desiredType.length();
        if (typeLength == 3 && desiredType.equals("*/*")) {
            return true;
        }

        final int slashpos = desiredType.indexOf('/");
        if (slashpos > 0) {
            if (typeLength == slashpos+2 && desiredType.charAt(slashpos+1) == '*") {
                if (desiredType.regionMatches(0, concreteType, 0, slashpos+1)) {
                    return true;
                }
            } else if (desiredType.equals(concreteType)) {
                return true;
            }
        }

        return false;
public intdescribeContents()

        return 0;
public java.lang.String[]filterMimeTypes(java.lang.String mimeType)
Filter the clip description MIME types by the given MIME type. Returns all MIME types in the clip that match the given MIME type.

param
mimeType The desired MIME type. May be a pattern.
return
Returns an array of all matching MIME types. If there are no matching MIME types, null is returned.

        ArrayList<String> array = null;
        for (int i=0; i<mMimeTypes.length; i++) {
            if (compareMimeTypes(mMimeTypes[i], mimeType)) {
                if (array == null) {
                    array = new ArrayList<String>();
                }
                array.add(mMimeTypes[i]);
            }
        }
        if (array == null) {
            return null;
        }
        String[] rawArray = new String[array.size()];
        array.toArray(rawArray);
        return rawArray;
public java.lang.CharSequencegetLabel()
Return the label for this clip.

        return mLabel;
public java.lang.StringgetMimeType(int index)
Return one of the possible clip MIME types.

        return mMimeTypes[index];
public intgetMimeTypeCount()
Return the number of MIME types the clip is available in.

        return mMimeTypes.length;
public booleanhasMimeType(java.lang.String mimeType)
Check whether the clip description contains the given MIME type.

param
mimeType The desired MIME type. May be a pattern.
return
Returns true if one of the MIME types in the clip description matches the desired MIME type, else false.

        for (int i=0; i<mMimeTypes.length; i++) {
            if (compareMimeTypes(mMimeTypes[i], mimeType)) {
                return true;
            }
        }
        return false;
public booleantoShortString(java.lang.StringBuilder b)

hide

        boolean first = true;
        for (int i=0; i<mMimeTypes.length; i++) {
            if (!first) {
                b.append(' ");
            }
            first = false;
            b.append(mMimeTypes[i]);
        }
        if (mLabel != null) {
            if (!first) {
                b.append(' ");
            }
            first = false;
            b.append('"");
            b.append(mLabel);
            b.append('"");
        }
        return !first;
public java.lang.StringtoString()

        StringBuilder b = new StringBuilder(128);

        b.append("ClipDescription { ");
        toShortString(b);
        b.append(" }");

        return b.toString();
public voidvalidate()

hide

        if (mMimeTypes == null) {
            throw new NullPointerException("null mime types");
        }
        if (mMimeTypes.length <= 0) {
            throw new IllegalArgumentException("must have at least 1 mime type");
        }
        for (int i=0; i<mMimeTypes.length; i++) {
            if (mMimeTypes[i] == null) {
                throw new NullPointerException("mime type at " + i + " is null");
            }
        }
public voidwriteToParcel(android.os.Parcel dest, int flags)

        TextUtils.writeToParcel(mLabel, dest, flags);
        dest.writeStringArray(mMimeTypes);