Check the source code of the PApplet class to see how requestImage() is made, you can take inspiration to do your own with any kind of file. Basically, it uses threads, a topic that has been invoked several times in this forum.

Ok, I'll check it out. Thanks :D

Ok, i had a struck of inspiration and I wrote some code which downloads an arbitrary file asynchronousely into byte[] array. (just like loadBytes() but asynchronous.

Thanks you for your answer, I'll check it out and compare it with my current approach to see which is best.

My current approach is based on the way requestImage() is built like PhiLho recommended, here I'll post the code for you to see how I've done:

1. // Set file class
2. class FILE {
3.   // Set states
4.   public byte FAILURE = 0;
5.   public byte DOWNLOADING = 1;
6.   public byte SUCCESS = 2;
7.   // Set instance variables
8.   public byte state;
9.   public byte[] data;
10.   // Constructor
11.   public FILE() {
12.     state = DOWNLOADING;
13.   }
14.   public void save(String fname) {
15.     saveBytes(fname, data);
16.   }
17. }
18. 
    
19. // Set maximum number of threads
20. public int requestFileMax = 4;
21. volatile int requestFileCount;
22. 
    
23. // Set asynchronous class
24. class AsyncFileLoader extends Thread {
25.   String filename;
26.   FILE vessel;
27.   public AsyncFileLoader(String filename, FILE vessel) {
28.     this.filename = filename;
29.     this.vessel = vessel;
30.   }
31.   public void run() {
32.     while (requestFileCount == requestFileMax) {
33.       try {
34.         Thread.sleep(10);
35.       }
36.       catch (InterruptedException e) {
37.       }
38.     }
39.     requestFileCount++;
40.     FILE actual = new FILE();
41.     actual.data = loadBytes(filename);
42.     // An error message should have already printed
43.     if (actual.data == null) {
44.       vessel.state = vessel.FAILURE;
45.     }
46.     else {
47.       vessel.state = vessel.SUCCESS;
48.       vessel.data = actual.data;
49.     }
50.     requestFileCount--;
51.   }
52. }
53. 
    
54. // Set asynchronous file opening function
55. public FILE requestFile(String filename) {
56.   FILE vessel = new FILE();
57.   AsyncFileLoader afl = new AsyncFileLoader(filename, vessel);
58.   afl.start();
59.   return vessel;
60. }

If you compare it with the PApplet's source code you'll see that it is basic copy paste with slight adaptations
(link to source code here)

Well, I think that the first prize  goes to you! :) 

Thank you for noticing that potencial bug, I'll fix it right away :D

a good man! Sorry didn't notice the difference, my bad. Probably I'm paranoid.. seeing concurrency related bugs everywhere... :S

At least you notice bugs that I didn't, and noticing bugs is always good! Even if they turn out to not being bugs, at least they may make you think more clearly about the code or rewrite it in a better way

By the way, when I was trying to play around with this downloading stuff, i realized that it is important to keep in mind all the time whether ther're any references (maybe indirect) to the byte array (FILE.data) somewhere in code. Because all these downloads stay in memory and usually plain byte[] array is no use and it's converted to something else. So it is important to make sure that this byte[] array is passed to garbage collector for recycling. 

An important note yet again!