CODEWITHSUNDEEP
javascriptasynchronousfile-iogoogle-chrome-extensiongoogle-chrome-app
SquareCrow
SquareCrow

Reputation: 311

Chrome App: Cannot retrieve file load status

My Chrome app has a function that asks for a file to be loaded by another function, checks that the function has set a flag signifying success (External.curFile.lodd), then attempts to process it. My problem is that the flags are not set the first time I call the function, but when I call it a second time the flags are already set.

I had a feeling this has to do with Chrome file functions being asynchronous, so I had the first function idle for a bit while the file loads. The first load never succeeds, no matter how long I wait, but the second load always does!

Calling Function:

function load_by_lines_from_cur_dir( fileName, context ){ // determine the 'meaning' of a file line by line, return last 'meaning', otherwise 'null' 

    var curLineMeaning = null;
    var lastLineValid = true;

    External.read_file_in_load_path(fileName); // 'External' load 'fileName' and reads lines, REPLacement does not see this file

    // This is a dirty workaround that accounts for the fact that 'DirectoryEntry.getFile' is asynchronous, thus pre-parsing checks fail intil loaded
    var counter = 0, maxLoops = 10;
    nuClock();
    do{ 
        sleep(500); 
        counter++; 
        preDebug.innerText += '\r\nLoop:' + counter + " , " + time_since_last();

    }while( !External.curFile.lodd && (counter < maxLoops) ); //idle and check if file loaded, 5000ms max

    preDebug.innerText += '\r\nLoaded?:' + External.curFile.lodd;
    preDebug.innerText += '\r\nLines?:' +  External.curFile.lins;

    if( External.curFile.lodd ){ // The last load operating was successful, attempt to parse and interpret each line
        // parse and interpret lines, storing each meaning in 'curLineMeaning', until last line is reached
        while(!External.curFile.rEOF){ 
            curLineMeaning = meaning( s( External.readln_from_current_file() ), context); 
            preDebug.innerText += '\r\nNext Line?: ' + External.curFile.lnnm;
            preDebug.innerText += '\r\nEOF?: ' + External.curFile.rEOF;
        }
    } // else, return 'null'
    return curLineMeaning; // return the result of the last form
}

which calls the following:

External.read_file_in_load_path = function(nameStr){ // Read the lines of 'nameStr' into 'External.curFile.lins'
    External.curPath.objt.getFile( // call 'DirectoryEntry.getFile' to fetch a file in that directory 
        nameStr,
        {create: false},
        function(fileEntry){ // action to perform on the fetched file, success
            External.curFile.name = nameStr; // store the file name for later use
            External.curFile.objt = fileEntry; // store the 'FileEntry' for later use

            External.curFile.objt.file( function(file){ // Returns 'File' object associated with selected file. Use this to read the file's content.
                var reader = new FileReader();
                reader.onload = function(e){
                    External.curFile.lodd = true; // File load success
                };
                reader.onloadend = function(e){
                    //var contents = e.target.result;
                    // URL, split string into lines: http://stackoverflow.com/questions/12371970/read-text-file-using-filereader
                    External.curFile.lins = e.target.result.split('\n'); // split the string result into individual lines
                };
                reader.readAsText(file);
                External.curFile.lnnm = 0; // Set current line to 0 for the newly-loaded file
                External.curFile.rEOF = false; // Reset EOF flag
                // let's try a message instead of a flag ...
                /*chrome.runtime.sendMessage({greeting: "hello"}, function(response) {
                    console.log(response.farewell);
                });*/
            } );
        },
        function(e){ External.curFile.lodd = false; } // There was an error
    );
};

This app is a dialect of Scheme. It's important that the app knows that the source file has been loaded or not.

Upvotes: 0

Views: 63

Answers (1)

Marc Rochkind
Marc Rochkind

Reputation: 3740

I didn't read through all of your code, but you can't kick off an asynchronous activity and then busy-wait for it to complete, because JavaScript is single threaded. No matter what's happened, the asynchronous function won't be executed until the script completes its current processing. In other words, asynchronous does not imply concurrent.

Generally speaking, if task A is to be performed after asynchronous task B completes, you should execute A from the completion callback for B. That's the straightforward, safe way to do it. Any shortcut, to achieve better responsiveness or to simplify the code, is going to have dependency or race-condition problems, and will require lots of horsing around to get right. Even then, it will be hard to prove that the code operates correctly on all platforms in all circumstances.

Upvotes: 1

Related Questions