1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* Application.java
* Copyright (C) 2003 Chris Burdess <dog@gnu.org>
*
* This file is part of GNU JavaMail, a library.
*
* GNU JavaMail is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* GNU JavaMail is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* As a special exception, if you link this library with other files to
* produce an executable, this library does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* This exception does not however invalidate any other reasons why the
* executable file might be covered by the GNU General Public License.
*/
package gnu.mail.handler;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.*;
import javax.activation.*;
import javax.mail.internet.ContentType;
import javax.mail.internet.MimeUtility;
import javax.mail.internet.ParseException;
/**
* A JAF data content handler for the application/* family of MIME content
* types.
* This provides the basic behaviour for any number of byte-array-handling
* subtypes which simply need to override their default constructor to provide
* the correct MIME content-type and description.
*/
public abstract class Application
implements DataContentHandler
{
/**
* Our favorite data flavor.
*/
protected DataFlavor flavor;
/**
* Constructor specifying the data flavor.
* @param mimeType the MIME content type
* @param description the description of the content type
*/
protected Application(String mimeType, String description)
{
flavor = new ActivationDataFlavor(byte[].class, mimeType,
description);
}
/**
* Returns an array of DataFlavor objects indicating the flavors the data
* can be provided in.
* @return the DataFlavors
*/
public DataFlavor[] getTransferDataFlavors()
{
DataFlavor[] flavors = new DataFlavor[1];
flavors[0] = flavor;
return flavors;
}
/**
* Returns an object which represents the data to be transferred.
* The class of the object returned is defined by the representation class
* of the flavor.
* @param flavor the data flavor representing the requested type
* @param source the data source representing the data to be converted
* @return the constructed object
*/
public Object getTransferData(DataFlavor flavor, DataSource source)
throws UnsupportedFlavorException, IOException
{
if (this.flavor.equals(flavor))
return getContent(source);
return null;
}
/**
* Return an object representing the data in its most preferred form.
* Generally this will be the form described by the first data flavor
* returned by the <code>getTransferDataFlavors</code> method.
* @param source the data source representing the data to be converted
* @return a byte array
*/
public Object getContent(DataSource source)
throws IOException
{
InputStream in = source.getInputStream();
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buf = new byte[4096]; // TODO make configurable
while (true)
{
int len = in.read(buf);
if (len > -1)
out.write(buf, 0, len);
else
break;
}
return out.toByteArray();
}
/**
* Convert the object to a byte stream of the specified MIME type and
* write it to the output stream.
* @param object the object to be converted
* @param mimeType the requested MIME content type to write as
* @param out the output stream into which to write the converted object
*/
public void writeTo(Object object, String mimeType, OutputStream out)
throws IOException
{
// We only handle arrays of byte
byte[] bytes = null;
if (object instanceof byte[])
bytes = (byte[])object;
out.write(bytes);
out.flush();
}
}
|
