Bonjour,

Je voudrais afficher ma webcam sur l'application mais j'ai un retour d'erreur renvoyé via firefox que je n'arrive pas à résoudre à savoir :
VerifyError: Error #1014: La classe spark.components::Group est introuvable.

Je comprends le message mais je ne comprend pas trop comment fonctionnent les dépendances. J'ai vu les préférences de Flex qui permettent notamment de gérer la fusion des dépendances etc...etc... c'est encore un peu flou pour moi.

Un coup de main SVP ? Il ne doit pas me manquer grand chose.

MERCI

Ci-dessous le code copié-collé sur Internet :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
265
266
267
268
269
270
271
272
273
274
 
<?xml version="1.0" encoding="utf-8"?>
<s:Group width="640" height="480" xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx">
 
    <!-- Script block -->
    <fx:Script>
        <![CDATA[
            // Imports
            import flash.events.Event;
            import flash.events.ProgressEvent;
            import flash.net.Socket;
            import flash.utils.ByteArray;
 
            import mx.utils.Base64Encoder;
 
            // Private properties
            private var buffer:ByteArray = null;
            private var _last:ByteArray = null;
            private var _port:int = 0;
            private var start:int = 0;
            private var socket:Socket = null;
            private var _host:String = null;
            private var _file:String = null;
            private var _password:String = null;
            private var _username:String = null;
 
            // **
            // Public methods
            // **
 
            // Called to start stream capture
            // Setup buffer and connect socket
            public function stream( host:String, port:Number, file:String ):void
            {
                this.host = host;
                this.port = port;
                this.file = file;
 
                buffer = new ByteArray();
 
                socket = new Socket();
                socket.addEventListener( Event.CONNECT, doSocketConnect );
                socket.addEventListener( ProgressEvent.SOCKET_DATA, doSocketData );
                socket.connect( host, port );                
            }
 
            // **
            // Private methods
            // **
 
            // Called to load the latest image
            private function display( image:ByteArray ):void
            {
                var loader:SWFLoader = null;
 
                // Save reference to last JPEG
                last = image;
 
                // Get loader from  back
                // Populate with new image
                // Event handler triggers swap
                // Minimizes flicker
                loader = getElementAt( 0 ) as SWFLoader;
                loader.source = image;
            }            
 
            // Called to find a JPEG image in the loaded bytes
            private function find():Boolean
            {
                var value:Boolean = false;
                var copy:ByteArray = null;                
                var image:ByteArray = null;
                var marker:ByteArray = null;
                var end:int = 0;                
                var offset:int = 0;                
 
                offset = start;
                marker = new ByteArray();
 
                // If there are bytes and the offset is at the start
                // Look for a JPEG image
                if( buffer.length > 1 ) 
                {
                    if( start == 0 )
                    {
                        // Look for the start of the JPEG
                        for( offset; offset < buffer.length - 1; offset++ ) 
                        {
                            buffer.position = offset;
                            buffer.readBytes( marker, 0, 2 );
 
                            if( marker[0] == 255 && marker[1] == 216 ) 
                            {
                                start = offset;
                                break;                    
                            }
                        }
                    }
 
                    // Look for the end of the JPEG
                    for( offset; offset < buffer.length - 1; offset++ ) 
                    {
                        buffer.position = offset;
                        buffer.readBytes( marker, 0, 2 );
 
                        if( marker[0] == 255 && marker[1] == 217 ) 
                        {
                            end = offset;
 
                            // Grab image if an end is found
                            image = new ByteArray();
 
                            buffer.position = start;
                            buffer.readBytes( image, 0, end - start );
 
                            // Display
                            display( image );
 
                            // Remove image from incoming buffer
                            copy = new ByteArray();
 
                            buffer.position = end;
                            buffer.readBytes( copy, 0 );
                            buffer = copy;
 
                            // Reset values
                            start = 0;
                            offset = 0;
 
                            // Denote that an image has been found
                            value = true;
                        }
                    }
                }
 
                // No image found by default
                return value;                
            }
 
            // **
            // Event handlers
            // **
 
            // Called when the background image has finished loading
            // Swaps the two loaders to pull background to front
            // Called when loaded to minimize flicker
            protected function doLoadComplete( event:Event ):void
            {
                swapElements( one, two );
            }
 
            // Called when the socket has connected
            // Sends the initial HTTP request to start the stream
            protected function doSocketConnect( event:Event ):void
            {
                var auth:Base64Encoder = null;
                var request:String = null;
                var source:String = null;
 
                // HTTP GET
                request = "GET " + file + " HTTP/1.1\r\nHost: localhost:80\r\n";                
 
                // Include username and password if needed
                // Your specific implementation may vary
                if( username != null && password != null )
                {
                    source = username + ":" + password;
 
                    auth = new Base64Encoder();
                    auth.encode( source );
 
                    request = request + "Authorization: Basic " + auth.toString() + "\r\n";
                }
 
                // Keep the HTTP connection alive
                // Stream the image bytes for as long as the socket is connected
                request = request + "Connection: keep-alive\r\n\r\n";
 
                // Send HTTP GET request
                // Starts the stream
                socket.writeMultiByte( request, "us-ascii" );                
            }
 
            // Called when there are new bytes on the socket
            // Reads the bytes into the buffer
            // Attempts to find, extract and display the image
            protected function doSocketData( event:ProgressEvent ):void
            {
                socket.readBytes( buffer, buffer.length );
 
                while( find() ) {;}                
            }
 
            // **
            // Access methods
            // **
 
            public function get last():ByteArray
            {
                return _last;
            }
 
            public function set last( value:ByteArray ):void
            {
                _last = value;
            }                        
 
            public function get port():int
            {
                return _port;
            }
 
            public function set port( value:int ):void
            {
                _port = value;
            }            
 
            public function get file():String
            {
                return _file;
            }
 
            public function set file( value:String ):void
            {
                _file = value;
            }            
 
            public function get host():String
            {
                return _host;
            }
 
            public function set host( value:String ):void
            {
                _host = value;
            }
 
            public function get password():String
            {
                return _password;
            }
 
            public function set password( value:String ):void
            {
                _password = value;
            }            
 
            public function get username():String
            {
                return _username;
            }
 
            public function set username( value:String ):void
            {
                _username = value;
            }            
        ]]>
    </fx:Script>
 
    <!-- Two instances -->
    <!-- Swapped out to reduce flicker -->
    <!-- Versus loading new bytes into single loader -->
    <mx:SWFLoader 
        id="one" 
        horizontalCenter="0" 
        verticalCenter="0" 
        complete="doLoadComplete( event )"/>
    <mx:SWFLoader 
        id="two" 
        horizontalCenter="0" 
        verticalCenter="0" 
        complete="doLoadComplete( event )"/>
 
</s:Group>