return new Promise(function (resolve, reject) {
      try {
        if (!options.image) {
          reject("no image specified");
          return;
        }

        const lang = options.language || "eng";

        const progressNotifier = new com.googlecode.tesseract.android.TessBaseAPI.ProgressNotifier({
          onProgressValues: (progressValues) => {
            if (options.onProgress) {
              options.onProgress(progressValues.getPercent());
            } else {
              console.log("Progress: " + progressValues.getPercent());
            }
          }
        });

        const tessBaseAPI = new com.googlecode.tesseract.android.TessBaseAPI(progressNotifier);
        tessBaseAPI.setDebug(false);

        const tessfolder = fs.path.join(fs.knownFolders.currentApp().path, "tesseract");

        const initSuccess = tessBaseAPI.init(tessfolder, lang, com.googlecode.tesseract.android.TessBaseAPI.OEM_TESSERACT_ONLY);
        // const initSuccess = tessBaseAPI.init(tessfolder, lang, com.googlecode.tesseract.android.TessBaseAPI.OEM_DEFAULT);

        if (!initSuccess) {
          reject("init failed");
          return;
        }

        // see https://github.com/rmtheis/tess-two/blob/master/tess-two/src/com/googlecode/tesseract/android/TessBaseAPI.java#L53
        // tessBaseAPI.setPageSegMode(com.googlecode.tesseract.android.TessBaseAPI.PageSegMode.PSM_AUTO_OSD);
        // tessBaseAPI.setVariable(com.googlecode.tesseract.android.TessBaseAPI.VAR_SAVE_BLOB_CHOICES, com.googlecode.tesseract.android.TessBaseAPI.VAR_TRUE);

        if (options.whitelist) {
          tessBaseAPI.setVariable(com.googlecode.tesseract.android.TessBaseAPI.VAR_CHAR_WHITELIST, options.whitelist);
        }

        if (options.blacklist) {
          tessBaseAPI.setVariable(com.googlecode.tesseract.android.TessBaseAPI.VAR_CHAR_BLACKLIST, options.blacklist);
        }

        tessBaseAPI.setImage(options.image.android);
        const recognizedText = tessBaseAPI.getUTF8Text();

        tessBaseAPI.end();

        resolve({
          text: recognizedText
        });
      } catch (ex) {
        console.log("Error in ocr.retrieveText: " + ex);
        reject(ex);
      }
    });

 resolve(url: string, baseUrl: string): string {
     //Angular assembles absolute URL's and prefixes them with //
     if (url.indexOf("/") !== 0) {
         //Resolve relative URL's based on the app root.
         return path.join(baseUrl, url);
     } else {
         return url;
     }
 }

  get(url: string): Promise<string> {
      let appDir = knownFolders.currentApp().path;
      let templatePath = path.join(appDir, url);

      if (!File.exists(templatePath)) {
          throw new Error(`File ${url} does not exist.`);
      }
      let templateFile = File.fromPath(templatePath);
      return templateFile.readText();
  }

function loadStyles() {
    var path = fs.path.join(fs.knownFolders.currentApp().path, cssPath);

    if (!fs.File.exists(path)) {
        throw new Error("Could not find code-highlight.css. Lookup path: " + path);
    }

    style = fs.File.fromPath(path).readTextSync((error) => {
        console.log("Error loading style file: " + error);
    });
};

  constructor(protected path: string) {
    if (path.indexOf("~/") === 0) {
      this.path = path = fs.path.join(fs.knownFolders.currentApp().path, path.replace("~/", ""));
    }

    const documents = fs.knownFolders.currentApp();

    console.log('folder:', documents.path);

    fs.Folder.fromPath(fs.path.join(documents.path, '')).eachEntity(function (entity) {
      console.log('-', entity.name);
      // Return true to continue, or return false to stop the iteration.
      return true;
    });

    if (!fs.File.exists(path)) {
      console.error("Sound not initialized; file not found.");
      return;
    }
  };

 toFile: (destinationFilePath?: string) => {
     var fs: typeof fsModule = require("file-system");
     var fileName = options.url;
     if (!destinationFilePath) {
         destinationFilePath = fs.path.join(fs.knownFolders.documents().path, fileName.substring(fileName.lastIndexOf('/') + 1));
     }
     if (data instanceof NSData) {
         data.writeToFileAtomically(destinationFilePath, true);
         return fs.File.fromPath(destinationFilePath);
     } else {
         reject(new Error(`Cannot save file with path: ${destinationFilePath}.`));
     }
 }

    return new Promise((resolve, reject) => {
      try {
        let MediaPlayer = android.media.MediaPlayer;
        let audioPath;

        let fileName = isString(options.audioFile) ? options.audioFile.trim() : "";
        if (fileName.indexOf("~/") === 0) {
          fileName = fs.path.join(fs.knownFolders.currentApp().path, fileName.replace("~/", ""));
          console.log('fileName: ' + fileName);
          audioPath = fileName;
        }

        this.player = new MediaPlayer();
          
        this.player.setAudioStreamType(android.media.AudioManager.STREAM_MUSIC);         
        this.player.setDataSource(audioPath);
        this.player.prepareAsync();

        // On Complete
        this.player.setOnCompletionListener(new MediaPlayer.OnCompletionListener({
          onCompletion: (mp) => {
            options.completeCallback();
          }
        }));

        // On Error
        this.player.setOnErrorListener(new MediaPlayer.OnErrorListener({
          onError: (mp: any, what: number, extra: number) => {
            options.errorCallback();
          }
        }));

        // On Info
        this.player.setOnInfoListener(new MediaPlayer.OnInfoListener({
          onInfo: (mp: any, what: number, extra: number) => {
            options.infoCallback();
          }
        }))

        // On Prepared
        this.player.setOnPreparedListener(new MediaPlayer.OnPreparedListener({
          onPrepared: (mp) => {
            mp.start();
            resolve();
          }
        }));

      } catch (ex) {
        reject(ex);
      }
    });

export function getFilenameFromUrl(url: string) {
    const fs: typeof fsModule = require("file-system");
    const slashPos = url.lastIndexOf("/") + 1;
    const questionMarkPos = url.lastIndexOf("?");

    let actualFileName: string;
    if (questionMarkPos !== -1) {
        actualFileName = url.substring(slashPos, questionMarkPos);
    } else {
        actualFileName = url.substring(slashPos);
    }
    
    const result = fs.path.join(fs.knownFolders.documents().path, actualFileName);
    return result;
}

    constructor(example: examplesVM.Example) {
        super();

        var lastSlashIndex = example.path.lastIndexOf("/");
        var initialSelectedFile = example.path.substr(lastSlashIndex + 1) + ".xml";
        var path = example.path.substring(0, lastSlashIndex);
        path = fs.path.join(fs.knownFolders.currentApp().path, path.replace("~/", ""));
        console.log("Showing code for " + path);

        var folder = fs.Folder.fromPath(path);
        folder.getEntities().then((entities) => {
            entities = entities.filter((e) => (e instanceof fs.File));
            this.set("files", entities);
            this.selectFile(initialSelectedFile);
        });
        
        this.set("group", example.group);
    }

export function loadCss(cssFile?: string): Array<cssSelector.CssSelector> {
    if (!cssFile) {
        return undefined;
    }

    var result: Array<cssSelector.CssSelector>;

    var fs: typeof fileSystemModule = require("file-system");
    var styleScope: typeof styleScopeModule = require("ui/styling/style-scope");

    var cssFileName = fs.path.join(fs.knownFolders.currentApp().path, cssFile);
    if (fs.File.exists(cssFileName)) {
        var file = fs.File.fromPath(cssFileName);
        var applicationCss = file.readTextSync();
        if (applicationCss) {
            result = styleScope.StyleScope.createSelectorsFromCss(applicationCss, cssFileName);
        }
    }

    return result;
}