Actionscript 3 如何检查UPLOAD_COMPLETE_数据事件是否未调度？

有没有办法检查Flash中

COMPLETE

之后是否未发送

UPLOAD\u COMPLETE\u DATA

事件

我在做文件上传器。它一个接一个地上传文件–在

完成后

下一个文件开始上传–对每个文件重复此操作。在

COMPLETE

上的最后一个文件中，如果没有下一个文件，则会调度allCompleteHandler，如果出现一些错误，则会立即通过javascript向用户显示错误

我在javascript中处理这些错误——它将每个错误存储到javascript中的变量中，并在完成所有操作后显示错误

问题是：
我无法存储上一个文件中的错误（我通过

上传完整的\u数据

得到的服务器错误），因为这是在

完成

之后（在allCompleteHandler之后）发送的

我需要解决这个问题，因为我不习惯为每个无效文件显示javascript警报框（例如，如果有100个文件）

var参数：Object=LoaderInfo（this.root.LoaderInfo）.parameters，
fileFilter:Array，
browseFilter:数组=[]，
files:FileReferenceList=newfilereferencelist（），
selectedFiles:Array=[]，
file:FileReference=newfilereference（），
url:URLRequest=新的URLRequest（parameters.phpScript），
上传文件夹，
postMaxSize:Number，
uploadMaxFilesize:Number，
maxInputTime:int，
速度计时器：计时器=新计时器（1000），
上传计时器：计时器=新计时器（60000,1），
计数：int=0，
totalBytes:Number=0，
processedBytes:Number=0，
currentBytes:Number=0，
currentBytes2:Number=0，
lastBytes:Number=0，
上传速度：Number=0，
inProgress:布尔值=假；
//浏览过滤器设置
fileFilter=ExternalInterface.call（parameters.fileManager+“.getFileFilter”）；
if（文件过滤器）{
for（变量i:int=0；i
和样品




从：

上载完成数据：

成功上载后从服务器接收数据后发送。如果未从服务器返回数据，则不会发送此事件

完成：

下载完成或上载生成HTTP状态代码200时发送。对于文件下载，此事件在Flash Player或Adobe AIR完成将整个文件下载到磁盘时发送。对于文件上载，此事件在Flash Player或Adobe AIR从服务器接收到HTTP状态代码200后发送打开变速器

因此，如果您正在上载一个文件，而不希望服务器有任何响应，则可以使用complete。但是，如果您希望服务器在上载响应中返回数据，则需要等待UploadCompletedData。
我更新了我的问题…我正在使用Flash处理文件上载程序。什么是结果处理程序？是的，我有e一个正在工作的flash上传程序…我还配置了所有事件，效果很好…我只需要在
UPLOAD\u COMPLETE\u DATA
未发送的情况下进行检查–maibe这是一个更好的问题。对不起，也许这是一个愚蠢的问题，但你的上传代码在哪里？是的，没错，我明白…但如果
UPLOAD\u COMPLETE\u DAT，我现在不知道一个
将被发送或不发送…我的应用程序正在一个接一个地上传文件（从用户对话框中，您可以选择多个文件）–
完成
事件始终被发送，但
上传完成数据
仅当出现som错误时（仅适用于某些无效文件等）你读了我更新的答案了吗？最后一部分？你的服务器正在回复错误，所以UploadCompletedData将进行调度，如果返回结果是明确的，则Complete将进行调度。是吗？
var parameters:Object = LoaderInfo(this.root.loaderInfo).parameters,

    fileFilter:Array,
    browseFilter:Array = [],

    files:FileReferenceList = new FileReferenceList(),
    selectedFiles:Array = [],
    file:FileReference = new FileReference(),

    url:URLRequest = new URLRequest(parameters.phpScript),
    uploadFolder,

    postMaxSize:Number,
    uploadMaxFilesize:Number,
    maxInputTime:int,

    speedTimer:Timer = new Timer(1000),
    uploadTimer:Timer = new Timer(60000, 1),

    count:int = 0,

    totalBytes:Number = 0,
    processedBytes:Number = 0,
    currentBytes:Number = 0,
    currentBytes2:Number = 0,
    lastBytes:Number = 0,
    uploadSpeed:Number = 0,

    inProgress:Boolean = false;

// Browse filter setup
fileFilter = ExternalInterface.call(parameters.fileManager + ".getFileFilter");

if (fileFilter) {
    for (var i:int = 0; i < fileFilter.length; i++) {
        browseFilter.push(new FileFilter(fileFilter[i][0], fileFilter[i][1]));
    }
}

function clickHandler(event:MouseEvent):void {
    if (!inProgress) {
        uploadFolder = ExternalInterface.call(parameters.fileManager + ".getCurrentFolder");

        if (uploadFolder != undefined) {
            files.browse(browseFilter);
        }
    }
}

stage.addEventListener(MouseEvent.CLICK, clickHandler);

function selectHandler(event:Event):void {
    var variables:URLVariables = new URLVariables();

    variables.folder = uploadFolder;
    url.data = variables;
    url.method = URLRequestMethod.POST;

    selectedFiles = files.fileList;

    postMaxSize = ExternalInterface.call(parameters.fileManager + ".getPostMaxSize");
    postMaxSize = postMaxSize ? postMaxSize : 50 * 1024 * 1024;

    uploadMaxFilesize = ExternalInterface.call(parameters.fileManager + ".getUploadMaxFilesize");
    uploadMaxFilesize = uploadMaxFilesize ? uploadMaxFilesize : 50 * 1024 * 1024;

    maxInputTime = ExternalInterface.call(parameters.fileManager + ".getMaxInputTime");
    maxInputTime = maxInputTime ? maxInputTime : 60;

    // Get total size of selected files
    for (var i:int = 0; i < selectedFiles.length; i++) {
        totalBytes += selectedFiles[i].size;
    }

    ExternalInterface.call(parameters.fileManager + ".selectHandler", {
        selectedFiles : selectedFiles,
        totalBytes    : totalBytes
    });

    // Start upload process
    inProgress = true;
    speedTimer.start();
    upload();
}

files.addEventListener(Event.SELECT, selectHandler);

function upload():void {
    uploadTimer.reset();

    currentBytes2 = 0;

    if (count) {
        processedBytes += file.size;

        if (currentBytes < processedBytes) {
            currentBytes = processedBytes;
        }
    }

    if (selectedFiles.length) {
        file = FileReference(selectedFiles.shift());
        count++;

        ExternalInterface.call(parameters.fileManager + ".beforeUploadHandler", {
            file         : file,
            currentBytes : currentBytes
        });

        if (file.size <= postMaxSize) {
            if (file.size <= uploadMaxFilesize) {
                file.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
                file.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
                file.addEventListener(Event.OPEN, openHandler);
                file.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
                file.addEventListener(ProgressEvent.PROGRESS, progressHandler);
                file.addEventListener(Event.COMPLETE, completeHandler);
                file.addEventListener(DataEvent.UPLOAD_COMPLETE_DATA, uploadCompleteDataHandler);

                file.upload(url);
            } else {
                ExternalInterface.call(parameters.fileManager + ".uploadMaxFilesizeHandler", file);
                upload();
            }
        } else {
            ExternalInterface.call(parameters.fileManager + ".postMaxSizeHandler", file);
            upload();
        }
    } else {
        ExternalInterface.call(parameters.fileManager + ".allCompleteHandler", {
            currentBytes : currentBytes
        });

        speedTimer.stop();

        count = 0;

        totalBytes = 0;
        processedBytes = 0;
        currentBytes = 0;
        lastBytes = 0;
        uploadSpeed = 0;

        inProgress = false;
    }
}

function securityErrorHandler(event:SecurityErrorEvent):void {
    ExternalInterface.call(parameters.fileManager + ".securityErrorHandler", event);
}

function httpStatusHandler(event:HTTPStatusEvent):void {
    ExternalInterface.call(parameters.fileManager + ".httpStatusHandler", event);
    selectedFiles = [];
}

function openHandler(event:Event):void {
    ExternalInterface.call(parameters.fileManager + ".openHandler", event);

    uploadTimer.delay = maxInputTime * 1000;
    uploadTimer.start();
}

function ioErrorHandler(event:IOErrorEvent):void {
    ExternalInterface.call(parameters.fileManager + ".ioErrorHandler", event);
    upload();
}

function progressHandler(event:ProgressEvent):void {
    currentBytes += event.bytesLoaded - currentBytes2;
    currentBytes2 = event.bytesLoaded;

    ExternalInterface.call(parameters.fileManager + ".progressHandler", {
        current      : event,
        currentBytes : currentBytes
    });
}

function completeHandler(event:Event):void {
    ExternalInterface.call(parameters.fileManager + ".completeHandler", event);
    upload();
}

function uploadCompleteDataHandler(event:DataEvent):void {
    ExternalInterface.call(parameters.fileManager + ".uploadCompleteDataHandler", "(" + event.data + ")");
}

function updateUploadSpeed(event:TimerEvent):void {
    if (currentBytes > lastBytes) {
        uploadSpeed = currentBytes - lastBytes;

        ExternalInterface.call(parameters.fileManager + ".uploadSpeedHandler", uploadSpeed);

        lastBytes = currentBytes;
    }
}

speedTimer.addEventListener(TimerEvent.TIMER, updateUploadSpeed);

function maxInputTimeHandler(event:TimerEvent):void {
    ExternalInterface.call(parameters.fileManager + ".maxInputTimeHandler", file);
}

uploadTimer.addEventListener(TimerEvent.TIMER, maxInputTimeHandler);

function cancelUpload():void {
    file.cancel();

    selectedFiles = [];
    upload();
}

ExternalInterface.addCallback("cancelUpload", cancelUpload);