TypeScript file-system.knownFolders类代码示例

    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);
      }
    });

    get(url: string): Promise<string> {
        const appDir = knownFolders.currentApp().path;
        const templatePath = this.resolve(url, appDir);

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

  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;
    }
  };

function getSpeakerAvatars(path) {
    var avatarList: Array<string> = [];
    var currentAppFolder = fileSystemModule.knownFolders.currentApp();
    var menAvatarsFile = currentAppFolder.getFile(path);
    var fileText = menAvatarsFile.readTextSync();
    
    var lines = fileText.split('\n');
    for (var i = 0; i < lines.length; i++) {
        avatarList.push('data:image/png;base64,' + lines[i]);
    }
    return avatarList;
}

 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;
}

 ngOnInit() {
     var documents = knownFolders.currentApp();
     var jsonPersonFile = documents.getFile('dataform/data-services/person-model.json');
     var that = new WeakRef(this);
     jsonPersonFile.readText()
         .then(function (content) {
             try {
                 var person = JSON.parse(content);
                 that.get().person = person;
             } catch (err) {
                 throw new Error('Could not parse JSON file');
             }
         }, function (error) {
             throw new Error('Could not read JSON file');
         });
 }