Urlstream, urlloader, and loader

Urlsteam supports multiple encoding methods to read text files.

If urlloader encounters garbled characters, it can be converted (as mentioned in the previous article, excle can solve the garbled problem based on the standard XML format ):

1. VaR BA: bytearray = new bytearray;
2. Ba.writebytes(event.tar get as urlloader). Data );
3. Ba. Position = 0;
4. // Assume that an XML document is recorded.
5. VaR XML: xml = XML (BA. readmultibyte (BA. length, "GBK "));

Loader is used to load external image files and SWF files. I used it in air to upload images and generate a thumbnail. The implementation code is as follows:

1. // Import related
2. Import MX. Events. closeevent;
3. Import flash. Geom. matrix;
4. Import MX. Graphics. codec. jpegencoder;
5. Import MX. Graphics. codec. pngencoder;
6. Import MX. Controls. image;
7. Import MX. Controls. Alert;
8. Import MX. utils. arrayutil;
9. Import MX. Collections. arraycollection;
10. Import MX. formatters. numberformatter;
11. Import MX. messaging. abstractconsumer;
14. // Compress the information of the thumbnail.
15. Private var smallpicsize: Int = 80;
16. // Save the photo extension list
17. Private Static const ext_jpeg: String = "jpg ";
18. Private Static const ext_png: String = "PNG ";
23. Public Function browseandupload (): void
24. {
25. VaR filetoopen: file = file.doc umentsdirectory;
26. VaR txtfilter: filefilter = new filefilter ("JPG, PNG", "*. jpg; * PNG ;");
27. Filetoopen. browseforopen ("open", [txtfilter]);
28. Filetoopen. addeventlistener (event. Select, filetoopenselected );
29. }
30. // When the uploaded photo is opened, upload the photo
31. Private function filetoopenselected (objevent: Event): void
32. {
33. VaR orgimgpath: String = file (objevent. currenttarget). nativepath;
34. Try
35. {
36. VaR orgfile: file = new file (orgimgpath );
37. // Obtain a random image name
38. VaR curpicname: String = "testuploadpic." + orgfile. extension;
39. // If we put the large image in the project's/upload/big/folder
40. VaR bigimgfile: file = new file (file. applicationdirectory. nativepath + "/upload/big/" + curpicname );
41. Orgfile. copyto (bigimgfile );
42. // Obtain the bitmap information of the source image, and reconstruct a small image and place it under the temp/small/folder.
43. VaR Loader: loader = new loader ();
44. // Use an inline function to pass parameters in an event
45. VaR myspecialobject: Object = {newimgname: curpicname, newimgext: orgfile. Extension };
46. // Note: loader. contentloaderinfo
47. Loader. contentloaderinfo. addeventlistener (event. Complete, function (E: Event): void {loadcomplete (E, myspecialobject );});
48. Loader. contentloaderinfo. addeventlistener (ioerrorevent. io_error, loaderror );
49. // Load the source Image
50. VaR request: URLRequest = new URLRequest (orgfile. nativepath );
51. Loader. Load (request );
52. }
53. Catch (ER: Error)
54. {
55. Alert. Show (ER. Message );
56. }
57. }
59. // The original image is also loaded into the memory during the upload process. The main purpose is to generate a small image using the original image. The processing method after the load operation is completed
60. Public Function loadcomplete (Event: event, objspecial: Object): void
61. {
62. Try
63. {
64. If (objspecial! = NULL & objspecial. newimgname. tostring ()! = "")
65. {
66. VaR Loader: loader = loader(event.tar get. loader );
67. VaR bigbitmapdata: bitmapdata = Bitmap (loader. contentloaderinfo. Content). bitmapdata;
68. VaR myscale: Number = 1.0;
69. If (bigbitmapdata. width> 120 | bigbitmapdata. Height> 100)
70. {
71. If (bigbitmapdata. width> bigbitmapdata. Height)
72. {
73. Myscale = 120/bigbitmapdata. width;
74. } Else
75. {
76. Myscale = 100/bigbitmapdata. height;
77. }
78. }
79. // Create a new conversion matrix
80. VaR M: matrix = new matrix ();
81. M. Scale (myscale, myscale );
82. VaR smallbitmapdata: bitmapdata = new bitmapdata (bigbitmapdata. Width * myscale, bigbitmapdata. Height * myscale, bigbitmapdata. Transparent, 0 xffffffff );
83. Smallbitmapdata. Draw (bigbitmapdata, M );
84. // Bytearray of the photo
85. VaR imgbytearray: bytearray;
86. Switch (objspecial. newimgext. tostring ())
87. {
88. Case ext_jpeg:
89. VaR jpgenc: incluencoder = new incluencoder (80 );
90. Imgbytearray = jpgenc. encode (smallbitmapdata );
91. Break;
92. Case ext_png:
93. VaR pngenc: pngencoder = new pngencoder ();
94. Imgbytearray = pngenc. encode (smallbitmapdata );
95. Break;
96. }
97. // If we put the large image in the project's/upload/small/folder
98. VaR smallfile: file = new file (file. applicationdirectory. nativepath + "/upload/small/" + objspecial. newimgname. tostring ());
99. VaR FS: filestream = new filestream ();
100. Try {
102. FS. Open (smallfile, filemode. Write );
103. FS. writebytes (imgbytearray );
104. FS. Close ();
105. } Catch (E: Error ){
106. Alert. Show (E. Message );
107. }
109. // Release the memory occupied by bitmapdata (important)
110. Bigbitmapdata. Dispose ();
111. Smallbitmapdata. Dispose ();
112. }
113. }
114. Catch (ERR: Error)
115. {
116. Alert. Show ("An error occurred while generating the small image .");
117. }
118. }
119. // Handle errors when loading the source Image
120. Public Function loaderror (Event: ioerrorevent): void
121. {
122. Alert. Show ("uploaded Image Source:" uploloader(event.tar get. loader). contentloaderinfo. loaderurl. tostring () + "");
123. }