When it comes to loading language files using ajax, my approach is as follows...

$.get( "test.txt", function( data ) {
  console.log( "Successfully loaded data.", data );
});

In order to implement this solution, ensure that you grant read access to your app by configuring the `config.xml` file.

<feature name="http://api.phonegap.com/1.0/file" />

Here is a suggestion from my own set of functions. Begin by obtaining the file system and then extracting the root path. Customize it to suit your particular requirements.

Next, you can proceed as follows:

In my case, app_FileSystem serves as a global variable that is populated by GetAppFS.

Once you have obtained the FS and the root path, you can simply make an ajax call or utilize getjson with the appropriate dataType specified. This approach has proven effective for me.

Don't forget to consult the helpful documentation available here:

app_FileSystem.root.fullPath; // Retrieve the full path of the application file system root

function GetAppFS ()
{
    var self = this;
   self.state = "";                     // keep track of the process state for debugging purposes
   self.fileSystem = {};

    window.requestFileSystem ( LocalFileSystem.PERSISTENT, 0, getFileSystemSuccess, dispatchFailure );

    /**
     *
     * Upon receiving a valid file system, we need to request all documents within the file system.
     *
     */
    function getFileSystemSuccess ( fileSystem )
    {
        self.state = "Received File System";
         self.fileSystem = fileSystem;
        app_FileSystem = fileSystem;
         OnFSReady ();
    };

    /**
     *
     * All our functions have a failure callback, hence we provide dispatchFailure. If an error arises, we log it to the console and notify the associated failure function attached to self.failure(), if any.
     *
     */
    function dispatchFailure ( e )
    {
        // something went wrong :-(
        console.log ("While " + self.state + ", encountered error: " + JSON.stringify(e));
         alert ("dev FS ERROR ");
    };  
};

If you're looking to access the contents of the `www` folder in PhoneGap using the file plugin, I recommend utilizing the `resolveLocalFileSystemURL` method. This will allow you to use the `cordova.file.applicationDirectory` property for locating the `www` folder.

Ensure that you have installed the plugin by running:

$ cordova plugin add org.apache.cordova.file

After installing the plugin, you can create an object like the following to manage and process the files within the `www` folder:

var FileManager = {

  /**
   * Run this.entryHandler for all files and directories in PhoneGap's www folder
   */
  run: function () {

    window.resolveLocalFileSystemURL(
      cordova.file.applicationDirectory + 'www/',
      this.directoryFoundHandler,
      this.errorHandler
    );

  },

  /**
   * Successfully read the directory, now read the entries.
   *
   * @param {DirectoryEntry} directoryEntry
   */
  directoryFoundHandler: function (directoryEntry) {

    var directoryReader = directoryEntry.createReader();

    directoryReader.readEntries(
      this.entryHandler,
      this.errorHandler
    );

  },

  /**
   * Files successfully found. Parse them!
   *
   * @param {Array.<FileEntry>} entries
   */
  entryHandler: function (entries) {

    entries.forEach(function (entry) {

      // Process the files accordingly
      if (entry.isDirectory) {
        // It's a directory, may require further processing
      } else {
        // It's a file, perform desired actions
      }

    });

  },


  /**
   * Handle any errors encountered
   *
   * @param {FileError} error
   */
  errorHandler: function (error) {

    console.log("ERROR", error);

  }

};

Encountering the same issue without wanting to rely on jQuery, I decided to share my solution here.

An important point to note is that the files in the www directory of Cordova / Phone Gap are stored as assets in the Android environment. This implies:

• They are bundled within the .apk distribution file, which is a compressed archive. Android accesses these files directly from the .apk file and doesn't keep them separately in the local file system.
• As a result, these files are read-only and cannot be accessed using the Cordova File plugin.

Upon delving into the relevant Android sources of Cordova, it becomes apparent that Cordova handles URIs with a 'file' scheme, beginning with '/android_asset/', through Android's asset access functions. (It would be interesting to explore how Cordova manages this in the iOS realm.)

In essence, utilizing XMLHttpRequest is likely the most portable method for accessing files located in the www folder if direct file content access is required. (Alternative methods may suffice if only the file path is needed for certain operations.)

Below is the code snippet where filename represents the path within the www folder sans the "www/" prefix:

var readFileInWWWFolder = function(filename, onSuccess, onFailure){

    var request = new XMLHttpRequest();

    request.onload = function() {

        var arrayBuffer = request.response;

        if (arrayBuffer) {

            onSuccess(new Uint8Array(arrayBuffer));
        }
        else {

            onFailure();
        }
    };

    request.open("GET", filename, true);
    request.responseType = "arraybuffer";
    request.send();
};

This approach has been verified with Cordova 4.3.0 and Android 4.4.2 (Kitkat).

A helpful tip is to save each file from the www folder to Cordova's persistent file system using fs.download. You can find more information in my original post.

To start, follow these steps in Terminal:

1. npm install cordova-promise-fs

2. cordova plugin add cordova-plugin-file --save

3. cordova plugin add cordova-plugin-file-transfer --save

Next, in your front-end code:

import CordovaPromiseFS from 'cordova-promise-fs'

const fs = CordovaPromiseFS({
  persistent: true,
  storageSize: 200 * 1024 * 1024,
  concurrency: 3
})

If you are using React, make sure to declare the above code before creating the component Class. The following code should be placed within its own function inside the component Class. Check out my GitHub comment for more information.

window.resolveLocalFileSystemURL(
  cordova.file.applicationDirectory + 'www/epubs/alice.epub',
    // If successful...
    (fileSystem) => {
      const downloadUrl = fileSystem.toURL()
      const localUrl = 'alice.epub' // the filename it is stored as on the device
      fs.download(
        downloadUrl,
        localUrl,
        (progressEvent) => {
          if (progressEvent.loaded && progressEvent.total) {
          console.log('progress', Math.round((progressEvent.loaded / progressEvent.total) * 100))
        }
      }
    ).then((filedata) => {
      return fs.toInternalURL(localUrl)
    })
    .then((localPath) => {
      this.setState({ epubPath: localPath })
    }).catch((error) => {
      console.log('an error occurred', error)
    })
  },
  // If unsuccessful
  (err) => {
    console.log(err)
  }
)