Pagina 1 di 7 1 2 3 ... ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 69
  1. #1

    [PILLOLA] Preload di dati caricati dinamicamente dal server

    Iniziamo con l'esempio pratico:
    preloadLoadVars

    e il fla dell'esempio:
    preloadLoadVars.zip

    Fino ad oggi non avevo mai cercato di trovare un modo per creare un preload di dati dinamici caricati dal server!
    Avevamo sempre utilizzato infatti l'evento(metodo) onLoad() di LoadVars per verificare semplicemente l'avvenuto caricamento di dati dal server, il problema a prima vista insormontabile era quello che il numero totale di bytes da caricare sembrava indefinibile!

    Leggendo la guida di flash MX invece mi hanno stuzzicato queste parole a proposito del metodo getBytesTotal() di LoadVars:

    Metodo;
    restituisce il numero totale di byte che vengono scaricati mediante un'operazione load o sendAndLoad. Il metodo getBytesTotal restituisce undefined se non è in corso alcuna operazione load o se l'operazione load non è stata ancora avviata. Questo metodo restituisce undefined anche quando il numero totale di byte non può essere determinato, ad esempio nel caso in cui lo scaricamento è cominciato ma il server non ha trasmesso un HTTP in formato Content-Length.
    Questo significa che dobbiamo impostare un'opzione nell'header della pagina server, e in particolare proprio il Content-Length dimensionato con il numero totale di bytes da caricare!
    Questo passo l'ho risolto grazie al grande Bubu Sette Sette moderatore del forum php uilizzando delle funzioni di php che ci permettono di calcolare la dimensione dell'output, e alla funzione Header che ci permette appunto di impostare il testo dell'header della pagina!
    Grazie anche al Mitico Negatyve che mi ha dato la conferma che questo era possibile!(nonstante qualcuno volesse metterci i bastoni tra le ruote )

    Per chi non lo sapesse l'header sarebbe proprio l'intestazione di ogni pagina web dove sono specificati vari parametri e opzioni che a noi restano invisibili durante la navigazione ma in realtà sono sempre presenti in testa alla pagina!

    Premetto che questo metodo utilizzerà php insieme ad AS, anche se credo che pure con altri linguaggi server/side si possa fare ugualmente quello di cui parleremo più avanti in questa pillola (basterebbe conoscerli )

    A questo punto riassumiamo un pò:
    Per fare un preload ci servono due parametri, bytesTotali e bytesCaricati!
    Grazie a php e a quello che abbiamo detto riusciamo a far ricevere a flash all'inizio della comunicazione il numero totale di bytes grazie a getBytesTotal()!

    Il problema a questo punto è:
    Come facciamo a sapere il momento in cui inizia la comunicazione?
    E' semplice dalla guida si dice che getBytesTotal() restituisce undefined fino a quando l'operazione di load non è avviata quindi controllando lo stato di getBytesTotal() grazie ad un semplice setInterval abbiamo esattamente il momento in cui inizia la comunicazione!
    A questo proposito ho creato due metodi di LoadVars (uno pubblico e uno privato) che mi hanno permesso di creare l'evento onStart() che al contrario di onLoad() si verifica all'inizio del flusso dei dati! sempre però che l'header della pagina è stato impostato correttamente!

    codice:
    // metodo pubblico da richiamare dopo le istruzioni di load o sendAndLoad
    LoadVars.prototype.checkHeader = function() {
    	this.idHeader = setInterval(this, "getTotal", 1);
    };
    LoadVars.prototype.getTotal = function() {
    	if (this.getBytesTotal() != undefined) {
    		this.onStart();
    		clearInterval(this.idHeader);
    	}
    };
    grazie a questi semplici prototipi della superClasse LoadVars noi possiamo a questo punto impostare il nostro preload utilizzando il nuovo evento onStart() di LoadVars:
    codice:
    this.preload._visible = false;
    result = new LoadVars();
    result.load("prova.php");
    /* attiviamo il listener creato da noi che verifica l'inizio del
    flusso dei dati */
    result.checkHeader();
    /*Scrivo le istruzioni del nostro preload nell'evento onStart() 
    cioè all'inizio del flusso dei dati */
    result.onStart = function() {
    /* setto una variabile con i ms trascorsi dall'inizio della riproduzione del filmato */
    	this.startTime = getTimer();
    	_root.textLabel1.text = "inizio flusso";
    /* mi salvo nel mio preload un riferimento al nostro oggetto 
    LoadVars per poterne utilizzare al suo interno i suoi metodi */
    	_root.preload.loadVarsObject = this;
    	_root.preload.totalBytes = this.getBytesTotal();
    	_root.preload.onEnterFrame = function() {
    		this.loadedBytes = this.loadVarsObject.getBytesLoaded();
    		this.percent = this.loadedBytes/this.totalBytes*100;
    		this.barra._xscale = this.percent;
    		this._visible = true;
    		this.text1.text = "Percentuale: "+Math.round(this.percent)+"%";
    		this.text2.text = "Bytes caricati: "+this.loadedBytes;
    		if (this.loadedBytes == this.totalBytes) {
    			delete this.onEnterFrame;
    		}
    	};
    };
    // Scrivo le istruzioni che si verificano alla fine del flusso dei dati
    result.onLoad = function() {
    	_root.textLabel2.text = "fine flusso, bytes scaricati: "+this.getBytesLoaded()+" in "+(getTimer()-this.startTime)+"ms";
    };
    A questo punto andiamo a spiegare alla meno peggio come impostare la nostra pagina php che mi ha ispirato Negatyve infatti per flussi di dati brevi il preload forse non avrebbe neanche senso:
    Codice PHP:
    $myresult="result=";
    ob_start(); // qua inizio il conteggio dei bytes dell'output
    for($a=0;$a<10000;$a++)
        
    $myresult.="riga numero $a";//imposto la variabile di output
    echo $myresult//stampo il risultato che riceverà flash è solo una dimostrazione quindi non fate caso al contenuto
    header("Content-Length: ".ob_get_length()); //qui imposto l'header con il numero di bytes totali
    ob_end_flush(); 
    Spero di essere stato abbastanza chiaro sono cmq bene accetti consigli e commenti!

    Tu non vedrai nessuna cosa
    al mondo
    maggior di Roma...
    Io su Flashkit.com

  2. #2

    Re: [PILLOLA] Preload di dati caricati dinamicamente dal server

    Originariamente inviato da Falcao
    ... sono cmq bene accetti consigli e commenti!
    secondo me non e' possibile




















    @ negative
    adesso hai almeno 2 validi motivi per rilievizzare un 3D in questo forum e schiaffarci gentilmente 2 links
    Formaldehyde a new Ajax PHP Zero Config Error Debugger

    WebReflection @WebReflection

  3. #3
    Classe LoadVars2 con gestore d' evento onLoadProgress
    Visto la mia figura di merd* fatta oggi e la testardaggine sborona intrinseca che sta dentro di me [ ] ho deciso di provare a riscattarmi con quella che potrebbe essere una piccola svolta nell' utilizzo di Flash assieme a files di testo e/o linguaggi lato server [ PHP / ASP / altro ] .
    Sono lieto di presentarvi la classe LoadVars2, appena sfornata da MX 2004 e testata con successo !
    Questa classe e' identica a LoadVars(); tranne per l'aggiunta del metodo onLoadProgress, nome spudoratamente ricopiato dal metodo di MovieClipLoader che effettua a grandi linee la stessa cosa.
    onLoadProgress, affiancato al giusto header in caso di linguaggio lato server [ vedi l'esempio eccellente spiegato da Falcao in questa pillola ] o senza alcun accorgimento, in caso di semplice file statico, vi permette di ricevere in run-time i parametri getbytesLoaded e getbytesTotal, cosi' da mettervi in grado di effettuare un preload durante il caricamento del file.
    La sintassi e' sempre quella, non c'e' alcuna novita', se non un metodo in piu' autolooppato che vi terra' informati sull' andamento del caricamento.

    Esempio:
    codice:
    var serverbytes = new LoadVars2(); // occhio a scrivere LoadVars2 e non LoadVars :-)
    
    serverbytes.onLoad = function(success) {
    	trace("____________________________________");
    	trace("Caricati: " + this.getBytesLoaded());
    	trace("Totali: " + this.getBytesTotal());
    }
    
    serverbytes.onLoadProgress = function(loadedBytes, totalBytes) {
    	trace(loadedBytes + " - " + totalBytes);
    }
    
    serverbytes.sendAndLoad("http://miospazioweb/miofile.php", serverbytes);

    Come potrete notare e' tutto uguale a prima tranne onLoadProgress che vi restituira' in qualunque momento l' attuale situazione bytes caricati e bytes totali del vostro file.
    Potrete specificare il "GET" o il "POST" in send and load e/o utilizzare il load, senza problemi, provare per credere


    Eccovi la classe in tutte le sue poche linee, ma non vi dico per renderla cosi' quanti tentativi e crash ho docuto passare

    classe LoadVars2 , su file
    LoadVars2.as
    codice:
    class LoadVars2 extends LoadVars {
    	// andr3a [ www.3site.it ] [ 25/11/2003 ]
    	// Thanks to: negatyve / Falcao / bubu77
    	// from HTML.IT [ www.html.it ]
    	private var loadedBytes:Number = new Number();
    	private var totalBytes:Number = new Number();
    	private var myIntCheck:Number;
    	function LoadVars2() {
    		super();
    	}
    	public function load(url:String):Void {
    		super.load(url);
    		setMyInterval();
    	}
    	public function sendAndLoad(url:String, return_var:Object, method:String):Void {
    		method = method != undefined ? method : "POST";
    		super.sendAndLoad(url, return_var, method);
    		setMyInterval();
    	}
    	private function setMyInterval():Void {
    		myIntCheck = setInterval(this, "checkCharge", 20);
    	}
    	private function checkCharge():Void {
    		loadedBytes = getBytesLoaded() != undefined ? getBytesLoaded() : 0;
    		totalBytes = getBytesTotal() != undefined ? getBytesTotal() : 0;		
    		if( loadedBytes >= totalBytes  && loadedBytes > 0 ) {
    			clearInterval(myIntCheck);
    		}
    		if( this.onLoadProgress != undefined ) {
    			this.onLoadProgress(loadedBytes, totalBytes);
    		}
    	}
    }

    Formaldehyde a new Ajax PHP Zero Config Error Debugger

    WebReflection @WebReflection

  4. #4
    a parte il trace come pensi di sfruttare l'evento onLoadProgress?

    io non l'ho provata la classe, ma un evento sarebbe una cosa buona che si verificasse una volta sola... (onStart()) altrimenti non lo vedo molto utile!

    Essendo autoluppante qualsiasi istruzione inserita al suo interno verrebbe eseguita 100 volte... cioè non dico che non funziona, ma secondo me è concettualmente sbagliato!

    se ad esempio tu volessi inizializzare il clip preload ad esempio lo faresti per tutte le volte che l'evento si verifica e cioè per tutto il flusso di dati e questo è sbagliato!

    L'evento onstart() risulta molto più utile... ad esempio al suo interno potresti istanziare un clip preload tramite attachMovie, solo se l'evento stesso si verifica con l'effetto di un codice più pulito e un sistema più solido che affatica meno il processore! se ad esempio l'header non è settato questo non si verificherà mai e l'inutile preload non verrebbe mai istanziato... oppure si potrebbe far partire un suono durante il flusso, suono che stopperesti sull'onLoad()... ancora puoi controllare il tempo di connessione alla pagina in questo modo:
    codice:
    result=new LoadVars();
    result.load("pagina.php");
    result.loadTime=getTimer();
    result.onStart=function(){
        this.startTime=getTimer();
        trace("Tempo di connessione: "+(this.startTime-this.loadTime));
    }
    result.onLoad=function(){
        this.endTime=getTimer();
        trace("tempo di scaricamento: "+(this.endTime-this.startTime));
    }
    insomma è utilizzabile in moltissimi modi basta un pò di fantasia!

    Tu non vedrai nessuna cosa
    al mondo
    maggior di Roma...
    Io su Flashkit.com

  5. #5
    Originariamente inviato da Falcao
    a parte il trace come pensi di sfruttare l'evento onLoadProgress?
    nello stesso modo in cui utilizzi onLoadProgress in MovieClipLoader, ovvero fai quello che cavolo ti pare, e' l' onEnterFrame del tuo preload fatto a mano, e' lo stesso evento del onLoadProgress di MovieClipLoader, a falcao, vabbe' un po' ma cosi' tanto cogli*ne non me ce fa pls, saluti.


    [ leggiti la mia pillola su MovieClipLoader, se la Macromedia inventa un metodo onLoadProgress per fare i preloads un motivo ci sara' ... :quipy: ]
    Formaldehyde a new Ajax PHP Zero Config Error Debugger

    WebReflection @WebReflection

  6. #6
    Originariamente inviato da Falcao
    insomma è utilizzabile in moltissimi modi basta un pò di fantasia!
    la stessa che non hai avuto nel valutare la mia classe

    Con la classe hai un metodo della classe, nessun codice in piu' , niente di niente, un semplice 2 in fondo a LoadVars ed eccoti un metodo che puoi gestire come ti pare, anche col timer o con quello che vuoi
    Formaldehyde a new Ajax PHP Zero Config Error Debugger

    WebReflection @WebReflection

  7. #7
    visto che sei uno sborone e forse il tuo metodo potrebbe anche essere utile, ma l'evento onStart lo è molto di più lo ho cmq implementato su LoadVars "che è meglio" (come diceva quattrocchi):

    codice:
    LoadVars.prototype.addListener = function() {
    	this.idHeader = setInterval(this, "getTotal", 10);
    };
    LoadVars.prototype.getTotal = function() {
    	if (this.getBytesTotal() != undefined) {
    		this.onStart();
    		this.idLoading = setInterval(this, "getLoading", 10);
    		clearInterval(this.idHeader);
    	}
    };
    LoadVars.prototype.getLoading = function() {
    	this.onLoadProgress();
    	if (this.getBytesLoaded()>=this.getBytesTotal()) {
    		clearInterval(this.idLoading);
    	}
    };
    this.preload._visible = false;
    result = new LoadVars();
    result.sendAndLoad("prova.txt", result, "POST");
    result.checkHeader();
    result.onLoadProgress = function() {
    	_root.textField3.text = "caricati: "+this.getBytesLoaded();
    	_root.textField4.text = "totali: "+this.getBytesTotal();
    };
    result.onStart = function() {
    	this.startTime = getTimer();
    	_root.textLabel1.text = "inizio flusso";
    	_root.preload.loadVarsObject = this;
    	_root.preload.totalBytes = this.getBytesTotal();
    	_root.preload.onEnterFrame = function() {
    		this.loadedBytes = this.loadVarsObject.getBytesLoaded();
    		this.percent = this.loadedBytes/this.totalBytes*100;
    		this.barra._xscale = this.percent;
    		this._visible = true;
    		this.text1.text = "Percentuale: "+Math.round(this.percent)+"%";
    		this.text2.text = "Bytes caricati: "+this.loadedBytes;
    		if (this.loadedBytes == this.totalBytes) {
    			delete this.onEnterFrame;
    		}
    	};
    };
    result.onLoad = function() {
    	_root.textLabel2.text = "fine flusso, bytes scaricati: "+this.getBytesLoaded()+" in "+(getTimer()-this.startTime)+"ms";
    };
    Controlla l'esempio!

    cmq non era necessaria una contropillola potevi fare quello che ho fatto io...


    SEI UNO SBORONE DA STRAPAZZO

    a parete gli scherzi, aggiorniamo i progressi effettuati su LoadVars:

    LoadVars.onStart() evento che si verifica all'inizio dello scambio di dati server-flash
    LoadVars.onLoadProgress() evento che si verifica per tutta la durata dello scambio dati (suggerito da andr3a)
    LoadVars.onLoad() si verifica a caricamento completato

    LoadVars.checkHeader() listener necessario per controllare lo stato di connessione al server e per il corretto funzionamento degli eventi
    Tu non vedrai nessuna cosa
    al mondo
    maggior di Roma...
    Io su Flashkit.com

  8. #8
    ehm ... falcao, io non ho fatto una contropillola , forse e' per questo che m'hai aggredito senza riflettere

    io ho fatto una classe per AS2.0, in alternativa alla tua prototype per AS1 ... differenze ???

    nessuna, io preferisco la classe per AS2.0, mi porto dietro il file e non devo fare niente di niente, tranne scrivere

    var sticaXXi = new LoadVars2();

    [ al posto di var sticaXXi = new LoadVars(); ]


    ... dopodiche' ho solo un metodo in piu' che mi permette di fare qualsivoglia timer, preload o quello che ti pare ... sempre che voglia usarlo ...

    insomma io ho solo scritto una alternativa pertinente a MX 2004 e ad un nuovo metodo che si chiama proprio onLoadProgress, non a caso ho scelto lo stesso nome, me lo highlighta pure :gren:
    E se desidero spostarmi verso MX 2004, perche' non ricordare meno termini nuovi possibili e associare i pochi nomi che mi ricordo ad eventi/metodi analoghi ? :master:


    pace
    Formaldehyde a new Ajax PHP Zero Config Error Debugger

    WebReflection @WebReflection

  9. #9
    Originariamente inviato da Falcao
    visto che sei uno sborone e forse il tuo metodo potrebbe anche essere utile, ma l'evento onStart lo è molto di più ...
    ... :quipy:


    Originariamente inviato da Falcao
    SEI UNO SBORONE DA STRAPAZZO
    ... :quipy:




    Formaldehyde a new Ajax PHP Zero Config Error Debugger

    WebReflection @WebReflection

  10. #10
    Originariamente inviato da andr3a
    ehm ... falcao, io non ho fatto una contropillola , forse e' per questo che m'hai aggredito senza riflettere

    ...

    pace

    secondo me è meglio utilizzare LoadVars anche in mx 2004 estendendola col prototype, la mia infatti non è una prototype come hai detto tu (è sbagliato chiamarla così) ho aggiunto due metodi alla classe LoadVars semplicemente.

    il tuo problema qual'è? il checkHeader()? bhè in realtà è meno dispendioso così in quanto se uno non vuole utilizzare i nuovi metodi non lo richiama affatto, evitando di appesantire il processore ma questa è pura pignoleria!

    Tu non vedrai nessuna cosa
    al mondo
    maggior di Roma...
    Io su Flashkit.com

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.