API Overview API Index Package Overview Direct link to this page
JDK 1.6
  javax.sound.sampled. LineEvent View Javadoc
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

/*
 * @(#)LineEvent.java	1.27 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package javax.sound.sampled;	

/**
 * The <code>LineEvent</code> class encapsulates information that a line
 * sends its listeners whenever the line opens, closes, starts, or stops.
 * Each of these four state changes is represented by a corresponding
 * type of event.  A listener receives the event as a parameter to its
 * {@link LineListener#update update} method.  By querying the event,
 * the listener can learn the type of event, the line responsible for
 * the event, and how much data the line had processed when the event occurred.
 *
 * <p>Although this class implements Serializable, attempts to
 * serialize a <code>LineEvent</code> object will fail.
 *
 * @author Kara Kytle
 * @version 1.27, 05/11/17
 *
 * @see Line
 * @see LineListener#update
 * @since 1.3
 *
 * @serial exclude
 */
public class LineEvent extends java.util.EventObject {
		
    // INSTANCE VARIABLES
	
    /**
     * The kind of line event (<code>OPEN</code>, <code>CLOSE</code>, 
     * <code>START</code>, or <code>STOP</code>).
     * @see #getType
     * @serial
     */
    private final Type type;

    /**
     * The media position when the event occurred, expressed in sample frames.
     * Note that this field is only relevant to certain events generated by
     * data lines, such as <code>START</code> and <code>STOP</code>.  For 
     * events generated by lines that do not count sample frames, and for any 
     * other events for which this value is not known, the position value 
     * should be {@link AudioSystem#NOT_SPECIFIED}.
     * @serial
     * @see #getFramePosition
     */
    private final long position;

	
    /**
     * Constructs a new event of the specified type, originating from the specified line.
     * @param line the source of this event
     * @param type the event type (<code>OPEN</code>, <code>CLOSE</code>, <code>START</code>, or <code>STOP</code>)
     * @param position the number of sample frames that the line had already processed when the event occurred,
     * or {@link AudioSystem#NOT_SPECIFIED}
     *
     * @throws IllegalArgumentException if <code>line</code> is
     * <code>null</code>.
     */
    public LineEvent(Line line, Type type, long position) {

	super(line);
	this.type = type; 
	this.position = position;
    }

    /**
     * Obtains the audio line that is the source of this event.
     * @return the line responsible for this event
     */
    public final Line getLine() {

	return (Line)getSource();
    }


    /**
     * Obtains the event's type.  
     * @return this event's type ({@link Type#OPEN}, {@link Type#CLOSE}, 
     * {@link Type#START}, or {@link Type#STOP})
     */
    public final Type getType() {

	return type;
    }

    /**
     * Obtains the position in the line's audio data when the event occurred, expressed in sample frames.  
     * For example, if a source line had already played back 14 sample frames at the time it was 
     * paused, the pause event would report the line's position as 14.  The next frame to be processed
     * would be frame number 14 using zero-based numbering, or 15 using one-based numbering.
     * <p>
     * Note that this field is relevant only to certain events generated by
     * data lines, such as <code>START</code> and <code>STOP</code>.  For 
     * events generated by lines that do not count sample frames, and for any 
     * other events for which this value is not known, the position value 
     * should be {@link AudioSystem#NOT_SPECIFIED}.
     * 
     * @return the line's position as a sample frame number
     */
    /*
     * $$kk: 04.20.99: note to myself: should make sure our implementation is consistent with this.
     * which is a reasonable definition....
     */	
    public final long getFramePosition() {

	return position;
    }

    /**
     * Obtains a string representation of the event.  The contents of the string may vary
     * between implementations of Java Sound.
     * @return a string describing the event.
     */	
    public String toString() {
	String sType = "";
	if (type != null) sType = type.toString()+" ";
	String sLine;
	if (getLine() == null) {
	    sLine = "null";
	} else {
	    sLine = getLine().toString();
	}
	return new String(sType + "event from line " + sLine);
    }	


    /**
     * The LineEvent.Type inner class identifies what kind of event occurred on a line.
     * Static instances are provided for the common types (OPEN, CLOSE, START, and STOP).
     * 
     * @see LineEvent#getType()
     */
    public static class Type {

	
	/**
	 * Type name.
	 */
	// $$kk: 03.25.99: why can't this be final??
	private /*final*/ String name;

	/**
	 * Constructs a new event type.
	 * @param name name of the type
	 */
	protected Type(String name) {
	    this.name = name;
	}


	//$$fb 2002-11-26: fix for 4695001: SPEC: description of equals() method contains typo
	/**
	 * Indicates whether the specified object is equal to this event type,
	 * returning <code>true</code> if the objects are identical.
	 * @param obj the reference object with which to compare
	 * @return <code>true</code> if this event type is the same as 
	 * <code>obj</code>; <code>false</code> otherwise
	 */
	public final boolean equals(Object obj) {
	    return super.equals(obj);
	}


	/**
	 * Finalizes the hashcode method.
	 */
	public final int hashCode() {
	    return super.hashCode();
	}


	/**
	 * Returns the type name as the string representation.
	 */
	public String toString() {
	    return name;				
	}


	// LINE EVENT TYPE DEFINES

	/**
	 * A type of event that is sent when a line opens, reserving system
	 * resources for itself.
	 * @see #CLOSE
	 * @see Line#open
	 */
	public static final Type OPEN	= new Type("Open");


	/**
	 * A type of event that is sent when a line closes, freeing the system
	 * resources it had obtained when it was opened.
	 * @see #OPEN
	 * @see Line#close
	 */
	public static final Type CLOSE	= new Type("Close");


	/**
	 * A type of event that is sent when a line begins to engage in active 
	 * input or output of audio data in response to a 
	 * {@link DataLine#start start} request.
	 * @see #STOP
	 * @see DataLine#start
	 */
	public static final Type START	= new Type("Start");


	/**
	 * A type of event that is sent when a line ceases active input or output 
	 * of audio data in response to a {@link DataLine#stop stop} request,
	 * or because the end of media has been reached.
	 * @see #START
	 * @see DataLine#stop
	 */
	public static final Type STOP	= new Type("Stop");


	/**
	 * A type of event that is sent when a line ceases to engage in active 
	 * input or output of audio data because the end of media has been reached.
	 */
	/*
	 * ISSUE: we may want to get rid of this.  Is JavaSound
	 * responsible for reporting this??
	 *
	 * [If it's decided to keep this API, the docs will need to be updated to include mention
	 * of EOM events elsewhere.]
	 */
	//public static final Type EOM	= new Type("EOM");


	/**
	 * A type of event that is sent when a line begins to engage in active 
	 * input or output of audio data.  Examples of when this happens are 
	 * when a source line begins or resumes writing data to its mixer, and 
	 * when a target line begins or resumes reading data from its mixer.
	 * @see #STOP
	 * @see SourceDataLine#write
	 * @see TargetDataLine#read
	 * @see DataLine#start
	 */
	//public static final Type ACTIVE	= new Type("ACTIVE");
	

	/**
	 * A type of event that is sent when a line ceases active input or output 
	 * of audio data.  
	 * @see #START
	 * @see DataLine#stop
	 */
	//public static final Type INACTIVE	= new Type("INACTIVE");

    } // class Type

} // class LineEvent

Generated By: JavaOnTracks Doclet 0.1.4     ©Thibaut Colar