i3Factory

La tua Iphone, iPad & Android Application Factory

Visualizza gli articoli con tag iphone

    i3Factory accompagna il Ministero del Lavoro che attraverso il Sistema Editoriale i3Editorial sbarca su App Store.
    Uno strumento agile per essere sempre aggiornati sul mondo del lavoro. La newsletter di Cliclavoro è un appuntamento mensile che raccoglie le più importanti novità del settore: tendenze del mercato del lavoro, opportunità dall’Europa, interviste a personalità di spicco.

    La Newsletter si articola in 5 sezioni:

    • In apertura
    • Approfondimento
    • L’intervista
    • Dall’Europa
    • Dai Social Network

    Tieniti aggiornato sull’andamento del mercato con dati e informazioni arricchiti da link e contenuti multimediali.
    Per seguire in tempo reale le news dal mondo del lavoro scarica l’applicazione CliComunica.
    Versione Apple iPhone e iPad: https://itunes.apple.com/it/app/clicomunica/id582587332?mt=8

    Versione per Android: https://play.google.com/store/search?q=clicomunica&c=apps

      Spesso ci capita di dover aggiornare le nostre applicazioni con  le immagini ad alta risoluzione necessarie per il nuovo iPad (iPad 3 o iPad 4). Fortunatamente il nuovissimo iPad Mini ha mantenuto la stessa risoluzione del primo degli iPad che è di 1024 x 768 pixels.
      Poichè non è sempre semplice trovare i documenti ufficali di  Apple , in questo articolo ho nuovamente raccolto tutte le informazioni di cui abbiamo bisogno per aggiornare le icone, le immagini di intro o splash, e così via.

      Innanzi tutto partiamo da questa utile tabella:

      Device/Screen File Name (PNG) Icon Size (pixels)
      iPhone and iPod
      Application Icon for iPhone (retina display) Icon@2x.png 114 x 114
      Application Icon icon for iPhone Icon.png 57 x 57
      Settings/Spotlight icon for iPhone (retina display) Icon-Small@2x.png 58 x 58
      Settings/Spotlight icon for iPhone Icon-Small.png 29 x 29
      Launch image Portrait (retina display) Default@2x.png 640 x 960
      Launch image Portrait Default.png 320 x 480
      iPhone 5
      Launch image for iPhone 5 Portrait (retina display) Default-568h@2x.png 640 x 1136
      iPad
      Application Icon for the new iPad (retina display) Icon-72@2x.png 144 x 144
      Application Icon for the iPad Icon-72.png 72 x 72
      Settings/Spotlight icon for iPad Icon-Small-50@2x.png 100 x 100
      Settings/Spotlight icon for iPad Icon-Small-50.png 50 x 50
      Launch image Portrait (retina display) Default-Portrait@2x.png 1536 x 2008
      Launch image Portrait Default-Portrait.png 768 x 1004
      Launch image Landscape (retina display) Default-Landscape@2x.png 2048 x 1496
      Launch image Landscape Default-Landscape.png 1024 x 748
      iTunes App Store
      App icon for the App Store (retina display) iTunesArtwork@2x.png 1024 x 1024
      App icon for the App Store iTunesArtwork.png 512 x 512

       

      Ricordiamo che con il passaggio da iOS 5 a iOS 6 è nato il nuovo iPhone 5, insieme con l’iPod touch di 5 ° generazione.
      Questi nuovi dispositivi Apple hanno solo un grande cambiamento che aggravia il lavoro di sviluppo delle App: la risoluzione dello schermo.
      Questi dispositivi hanno un ampio schermo 4″ , WDVGA (Wide VGA doppia) 640 × 1136 pixels, 326 DPI-Retina display.
      Questi dispositivi hanno la stessa larghezza 4/4S iPhone ma più 176 pixel di altezza in modalità Portrait.

      App Icon Template

      Segnalo nuovamente, come ho gia fatto in un’altro articolo, questo utilissimo tool scaricabile direttamente dal sito “appicontemplate.com” .

      Scaricando il file otterrete un modello PSD del’ icona dell’App che, attraverso oggetti avanzati in Photoshop, vi permette di automatizzare il processo di esportazione delle varie dimensioni del file icon.png che devono essere necessariamente incluse nel bundle di ogni iOS App.

      Attraverso questo modello Photoshop potremo modificare solo l’icona di dimensione più grande e verrà automaticamente eseguito il rendering che permetterà di avere le icone di dimensioni minori attraverso un veloce flusso di lavoro.
      Questo modello è stato creato dal designer danese Michael Flarup.

      Come si usa (How to) App Icon Template ?
      Il modello funziona con Photoshop CS2 o versioni successive.
      Basta aprire il file PSD con la vostra versione di Photoshop e fare “clic destro” sul LAYER (Livello) chiamato “EDIT THIS SMART OBJECT” (MODIFICARE QUESTO OGGETTO SMART) e premere  su ’Edit Contents’ (“Modifica contenuto”).
      Verrà aperto il file Icon.psb e potrete creare il vostro Artwork  in questo canvas (quadro).
      Dopo aver salvato il Icon.psb, dovrebbe essere automaticamente eseguito il rendering per le diverse dimensioni del file PSD principale .
      E’ possibile utilizzere le Actions (azioni automatizzate) di Photoshop che sono in bundle con la risorsa per esportare i file dell’icona nelle versioni squared and rounded corner (squadrate e arrotondate).

      Buon Design!

        Perché parliamo di Produzioni video cenematografiche

        Si potrebbe pensare che la gestione video sia limitata ad applicazioni come iMovie o Vimeo e a una nicchia di esperti video. Invece può essere esteso ad una gamma più ampia di applicazioni, non è essenzialmente limitato a editing video. In questo articolo forniremo una panoramica del Framework AV Foundation applicato su un esempio pratico.

        Nel nostro caso particolare, la sfida era quella di creare un’applicazione che, partendo da una serie di clip video esistenti, fosse stata in grado di costruire una storia fatta collegando un sottoinsieme di queste clip sulla base di decisioni prese dall’utente durante l’interazione con l’applicazione.
        Il gioco finale è un insieme di scene, girato in luoghi diversi, che compongono una storia. Ogni scena è composto da un prologo, una conclusione (epilogo) e una serie di piccole clip che verranno eseguite dall’applicazione sulla base di alcune scelte fatte dagli spettatori – utenti- giocatori.  Se le scelte sono corrette, lo spettatore sarà in grado di riprodurre tutta la scena fino al suo lieto fine, ma in caso di errore dovrà tornare sulla scena prologo iniziale o in una certa scena intermedia. Lo schema seguente mostra un possibile schema di una tipica scena: un prologo, un flusso vincente (verde) alcuni rami (giallo sono intermedie, il rosso stanno perdendo filiali) e di un lieto fine. Così gli spettatori da qualche parte nel TRACK1 saranno chiamati a prendere una decisione, se lui / lei è in quel momento in gioco continuerà con TRACK2, se non entrerà nel giallo Track4, e così via

         

        iPhone & iPad: Movie Game Storyboard
        Quello che abbiamo tra le mani è la serie completa di tracce, ogni traccia rappresenta una sottosezione specifica di una scena, e uno storyboard che ci fornisce le regole da seguire per costruire la storia finale. Così lo storyboard è fatto dalle scene, dalle tracce del compongono ogni scena e dalle norme che stabiliscono il flusso attraverso queste tracce.
        La sfida principale per lo sviluppatore è quello di mettere insieme queste clip e riprodurre un video in base allo stato attuale dello storyboard, quindi passare alla successiva, selezionare un nuovo clip di nuovo e così via: tutto deve trascorrere fluidamente senza interruzioni.
        Lo spettatore deve prendere le decisioni, interagendo con l’applicazione-gioco e questo può essere fatto sovrapponendo al film con alcuni controlli personalizzati.

        AV Foundation Framework

        Sarebbe impossible raggiungere gli obiettivi spiegati nel paragrafo precedente utilizziando lo standard Media Framework view controllers, MPMoviePlayerController e MPMoviePlayerViewController. Questi conrollers sono buoni per riprodurre un filmato e fornire i controlli di sistema, a schermo intero e la rotazione del dispositivo di sostegno, ma assolutamente non adatti per i controlli avanzati.
        Dopo il rilascio di iPhone 3GS dell’utility per la fotocomara avevamo la possibilità di fare un po ‘di tagli e l’esportazione, ma queste capacità non sono state date agli sviluppatori attraverso le funzioni pubbliche del SDK. Con l’introduzione di iOS 4, l’attività svolta da Apple con lo sviluppo delle app iMovie ha dato agli sviluppatori un ricco insieme di classi che consentono la manipolazione completa dei video . Tutte queste classi sono state raccolte ed esportate in un unico framework pubblico, denominato AV Foundation. Questo framework esiste da iOS 2.2, a quel tempo era dedicato alla gestione audio con la ben nota classe AVAudioPlayer, poi è stato esteso in iOS 3 con il AVAudioRecorder e le classi AVAudioSession ma il set completo di funzionalità che consentono capacità video avanzate ha avuto luogo solo a partire dal iOS 4 e sono stati pienamente presentati al WWDC 2010.

        La posizione della AV Foundation nello iOS Frameworks stack si trova  sotto UIKit, dietro l’application layer, e immediatamente sopra i basic Core Services frameworks, in particolare Core Media che viene utilizzato da AV Foundation per importare strutture di temporizzazione e le funzioni necessarie per la gestione dei media . In ogni caso si può notare la diversa posizione nello stack rispetto Media Player di alto livello. Ciò significa che questo tipo di struttura non è in grado di offrire una classe plug-and-play  per la riproduzione di semplici video , ma si potranno apprezzare i moderni concetti di alto livello che sono alla base di questo framework, di sicuro non siamo allo stesso livello dei vecchi framework come core Audio.

         

        (image source: from Apple iOS Developer Library)

        Building blocks

        L’organizzazione dele classi di AV Fondation è abbastanza intuitiva. Il punto di partenza e il building block principale è data da AVAsset. AVAsset rappresenta un oggetto statico multimediale ed è essenzialmente un aggregato di tracce che sono rappresentazioni temporizzate  di una parte de media. Tutti i brani sono di tipo uniforme, in modo che possiamo avere tracce audio, tracce video, tracce sottotitoli, e un complesso di attività può essere fatto di più tracce dello stesso tipo, ad esempio siamo in grado di avere più tracce audio. Nella maggior parte dei casi un asset è fatto di un audio e una traccia video. Si noti che AVAsset è una classe astratta per cui è indipendente dalla rappresentazione fisica dei media che rappresenta, inoltre la creazione di un’istanza AVAsset non significa che noi abbiamo tutti i media pronti per essere riprodotti, si tratta di un puro oggetto astratto.


        Ci sono due classi di attività disponibili: AVURLAsset, per rappresentare un supporto in un file locale o in rete, e AVComposition (insieme con la sua variante mutevole AVMutableComposition ) per un’attività composta da più supporti. Per creare una risorsa da un file abbiamo bisogno di fornire l’URL del file:

        NSDictionary *optionsDictionary = [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:YES] forKey:AVURLAssetPreferPreciseDurationAndTimingKey];
        AVURLAsset *myAsset = [AVURLAsset URLAssetWithURL:assetURL options:optionsDictionary];

        L’ options dictionary poò risultare nullo ma per i nostri scopi – per fare una composizione film – abbiamo bisogno di calcolare la durata esatta e fornire l’accesso casuale ai media. Questa opzione extra, che è l’impostazione su YES della chiave AVURLAssetPreferPreciseDurationAndTimingKey, potrebbe richiedere più tempo durante l’inizializzazione delle attività, e questo dipende dal formato di film. Se questo film è in QuickTime o MPEG-4, il file contiene informazioni aggiuntive che in sintesi annulla il tempo in più, ma ci sono in altri formati, come MP3, in cui queste informazioni possono essere estratte solo dopo la decodifica del media file, in tal caso l’inizializzazione del tempo non è trascurabile. Si tratta di una prima raccomandazione che diamo agli sviluppatori: si prega di utilizzare il formato del file a seconda dell’applicazione.
        Nella nostra applicazione dobbiamo già conoscere le caratteristiche dei film che stiamo usando, ma in un diverso tipo di applicazione, in cui è necessario fare un po ‘di editing dei filmati, si può essere interessati a ispezionare le proprietà delle risorse. In tal caso si deve ricordare la regola di base che l’inizializzazione di un asset non significa aver caricato e decodificato in memoria: questo significa che ogni proprietà del file multimediale può essere ispezionata, ma questo potrebbe richiedere un poco di tempo in più. Per completezza abbiamo semplicemente introdotto il modo asset inspection che può essere fatto lasciando l’utente interessato alla documentazione di riferimento (vedere l’elenco proposto letture alla fine di questo post). Fondamentalmente ogni proprietà dell’attività può essere verificata utilizzando un protocollo asincrono chiamato AVAsynchronousKeyValueLoadingwhich che definisce due metodi:

        - (AVKeyValueStatus)statusOfValueForKey:(NSString *)key error:(NSError **)outError
        – (void)loadValuesAsynchronouslyForKeys:(NSArray *)keys completionHandler:(void (^)(void))handler

        Il primo metodo è sincrono e restituisce immediatamente lo stato di conoscenza del valore specificato. Ad esempio si può chiedere lo status di “durata” e il metodo restituisce uno di questi stati possibili: carico, carico, fallito, sconosciuto, annullato. Nel primo caso il valore di chiave è noto e quindi il valore può essere immediatamente recuperato. Nel caso in cui il valore è ignoto è opportuno richiamare le loadValuesAsynchronouslyForKeys:completionHandler: metodo che alla fine dell’operazione chiamerà il callback dato nel completionHandlerblock, che a sua volta interroga lo stato di nuovo per l’azione appropriata.

        Video composition

        Come abbiam detto all’inizio, il nostro storyboard è composto da una serie di scene e ogni scena è composta da diverse clip il cui ordine di riproduzione non è nota a priori. Ogni scena si comporta indipendentemente dalle altre in modo da creare una composizione per ogni scena. Quando abbiamo un insieme di attività, o tracce, e da loro si costruisce una composizione nel complesso stiamo creando un altro asset. Questo è il motivo per cui le classi AVComposition e AVMutableComposition sono sottoclassi della classe  AVAsset base.
        È possibile aggiungere contenuti multimediali all’interno di una composizione mutevole, semplicemente selezionando un segmento di un bene, e l’aggiunta di una gamma specifica di nuova composizione:

        - (BOOL)insertTimeRange:(CMTimeRange)timeRange ofAsset:(AVAsset *)asset atTime:(CMTime)startTime error:(NSError **)outError

        Nel nostro esempio abbiamo una serie di tracce che si desidera aggiungere una dopo l’altra per generare un insieme continuo di clip. Così il codice può essere semplicemente scritto in questo modo:

        AVMutableComposition = [AVMutableComposition composition];
        CMTime current = kCMTimeZero;
        NSError *compositionError = nil;
        for(AVAsset *asset in listOfMovies) {
        BOOL result = [composition insertTimeRange:CMTimeRangeMake(kCMTimeZero, [asset duration])
        ofAsset:asset
        atTime:current
        error:&compositionError];
        if(!result) {
        if(compositionError) {
        // manage the composition error case
        }
        } else {
        current = CMTimeAdd(current, [asset duration]);
        }
        }

        Prima di tutto abbiamo introdotto il concetto di tempo. Si noti che tutti i media hanno un concetto di tempo diverso dal solito. Prima di tutto il tempo può muoversi avanti e indietro, oltre il lasso di tempo può essere superiore o inferiore a 1x se si sta visionndo il filmato al rallentatore o in avanzamento rapido. Inoltre si ritiene più conveniente  rappresentare il tempo non come virgola mobile o un numero intero, ma come numeri razionali. Per tale ragioneil framework  Core Media  fornisce la CMTimestructure e un insieme di funzioni e macro che semplificano la manipolazione di queste strutture. Quindi, al fine di costruire una specifica istanza time instance:

        CMTime myTime = CMTimeMake(value,timescale);

        che infatti specifica un numero di secondi proposto dal value/timescale. La ragione principale di questa scelta è che i film sono fatti di frames e i fotogrammi sono dati ad una razione fissa al secondo. Così, per esempio, se abbiamo una clip che è stata ripresa a 25 fps, allora sarebbe conveniente per rappresentare l’intervallo singolo fotogramma come un insieme variabile CMTime con valore = 1 e tempi = 25, corrispondente a 1/25th di secondo. 1 secondo  è dato da un CMTime con valore = 25 e timescale = 25, e così via (ovviamente si può ancora lavorare con i secondi, se volete, è sufficiente utilizzare i CMTimeMakeWithSeconds (seconds) function). Quindi, il codice di cui sopra inizialmente imposta l’ora corrente a 0 secondi (kCMTimeZero) quindi avvia l’iterazione su tutti i nostri film che sono assets in. Poi si aggiunge ciascuna di questi asset nella posizione corrente della nostra composizione con la loro gamma completa ([asset duration]). Per ogni asset spostiamo la composition head (current) per la lunghezza (in CMTime) dell’asset. A questo punto la composizione è fatta di un set completo di brani aggiunti in sequenza. Ora possiamo giocare.

        Playing an asset

        Il framework AVFoundation non offre alcuna player integrato, come siamo abituati a vedere con MPMovieViewController. Il motore che gestisce lo stato di riproduzione di un asset è fornito dalla classe AVPlayer. Questa classe si occupa di tutti gli aspetti relativi al play dell’asset ed essenzialmente è l’unica classe in AV Foundation che interagisce con i controller di visualizzazione dell’applicazione per mantenere in sincronia la logica dell’applicazione con lo stato di riproduzione: questo è rilevante per il tipo di applicazione che stiamo prendendo in considerazione in questo esempio, come lo stato di riproduzione può cambiare durante l’esecuzione del filmato base alle specifiche interazioni dell’utente  in momenti specifici all’interno del film. Tuttavia non abbiamo una relazione diretta tra AVAsset e AVPlayer, la loro connessione è mediata da un’altra classe denominata AVPlayerItem. Questa organizzazione delle classi ha lo scopo di separarel’asset, considerato come un’entità statica, dal player, puramente dinamico, fornendo un oggetto intermedio, che rappresenta uno stato specifico di presentazione di un asset. Ciò significa che per un determinat e unicoo asset  possiamo associare elementi di più players, tutti  rappresentano diversi stati dello stesso asset e eseguito da diversi players. Quindi, il flusso in questo caso è dato da un determinato asset che crea un elemento di player e poi lo assegna al pleyer finale.

        AVPlayerItem *compositionPlayerItem = [AVPlayerItem playerItemWithAsset:composition];
        AVPlayer *compositionPlayer = [AVPlayer playerWithPlayerItem:compositionPlayerItem];

         

        Al fine di eseguire il rendering sullo schermo, dobbiamo fornire una view in grado di rendere lo stato attuale di player. Abbiamo già detto che iOS non offre on-the-shelf una vista per questo scopo, ma quello che offre è un livello speciale CoreAnimation chiamato AVPlayerLayer. Quindi è possibile inserire questo livello nella gerarchia a livello di Anteprima del player o, come nel seguente esempio, utilizziamo questo come livello di base per questa view. Quindi, l’approccio suggerito in tal caso è quello di creare un MovieViewer personalizzato e il  set AVPlayerLayeras base layer class:

        // MovieViewer.h

        #import <UIKit/UIKit.h>
        #import <AVFoundation/AVFoundation.h>
        @interface MovieViewer : UIView {
        }
        @property (nonatomic, retain) AVPlayer *player;
        @end

        // MovieViewer.m

        @implementation MovieViewer
        + (Class)layerClass {
        return [AVPlayerLayer class];
        }
        – (AVPlayer*)player {
        return [(AVPlayerLayer *)[self layer] player];
        }
        – (void)setPlayer:(AVPlayer *)player {
        [(AVPlayerLayer *)[self layer] setPlayer:player];
        }
        @end

        // Intantiating MovieViewer in the scene view controller
        // We suppose “viewer” has been loaded from a nib file
        // MovieViewer *viewer
        [viewer setPlayer:compositionPlayer];

        A questo punto siamo in grado di riprodurre il filmato, che è abbastanza semplice:

        [[view player] play];
        Osservando il playback status

        È rilevante per la nostra applicazione  monitorare lo stato della riproduzione e osservare alcuni particolari eventi temporizzati  durante la riproduzione.
        Per quanto riguarda il monitoraggio dello stato, si seguirà l’approccio standard basato KVO osservando i cambiamenti nella proprietà dello stato del player:

        // inside the SceneViewController.m class we’ll register to player status changes
        [viewer.player addObserver:self forKeyPath:@"status" options:NSKeyValueObservingOptionNew context:NULL];

        // and then we implement the observation callback
        -(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
        if(object==viewer.player) {
        AVPlayer *player = (AVPlayer *)object;
        if(player.status==AVPlayerStatusFailed) {
        // manage failure
        } else if(playe.status==AVPlayerStatusReadyToPlay) {
        // player ready: manage success state (e.g. by playing the movie)
        } else if(player.status==AVPlayerStatusUnknown) {
        // the player is still not ready: manage this waiting status
        }
        }
        }

        Diversamente dalle KVO-observable properties l’ osservazione di eventi  non è basata su KVO: la ragione di questo è che la player head si muove continuamente e solitamente la riproduzione viene effettuata su un thread dedicato. Quindi il sistema preferisce certamente  inviare notifiche suoi attraverso un canale dedicato, che in questo caso consiste in un block-based callback che possiamo registrare per monitorare tali eventi. Ci sono due modi per osservare eventi programmati:

        • registering for periodic intervals notifications
        • registering when particular times are traversed

        In entrambi i metodi l’utente sarà in grado di specificare una serial queue in cui i richiami saranno spediti (e il default è la coda principale) e, naturalmente, il blocco callblack. E ‘importante notare il comportamento della serial queue: ciò significa che tutti gli eventi verranno messi in coda ed eseguiti uno dopo l’altro, per gli eventi frequenti è necessario assicurarsi che questi blocchi sono eseguiti abbastanza velocemente da permettere alla coda si elaborare i blocchi successivi, e questo è particolarmente vero se si sta eseguendo il blocco nel thread principale, al fine di evitare all’applicazione di non rispondere. Non dimenticate di programmare questo blocco da eseguire nel thread principale se si aggiorna l’interfaccia utente.
        La registrazione ad intervalli periodici è fatta in questo modo, dove chiediamo un callback 1 secondo il cui scopo principale sarà quello di aggiornare l’interfaccia utente (in genere l’aggiornamento di un barra di avanzamento e il tempo di riproduzione corrente):

        // somewhere inside SceneController.m
        id periodicObserver = [viewer.player addPeriodicTimeObserverForInterval:CMTimeMakeWithSeconds(1.0) queue:NULL usingBlock:^(CMTime time){
        [viewer updateUI];
        }];
        [periodicObserver retain];

        // and in the clean up method
        -(void)cleanUp {
        [viewer.player removeTimeObserver:periodicObserver];
        [periodicObserver release];
        }

        // inside MovieViewer.m
        -(void)updateUI {
        // do other stuff here
        // …
        // we calculate the playback progress ratio by dividing current position of playhead into the total movie duration
        float progress = CMTimeGetSeconds(player.currentTime)/CMTimeGetSeconds(player.currentItem.duration);
        // then we update the movie viewer progress bar
        [progressBar setProgress:progress];
        }

         

        LA eegistrazione agli  timed events viene fatta usando un metodo simile che prende come argomento una lista di rappresentazioni NSValue di CMTime (AVFoundation fornisce una categoria NSValue che aggiunge il supporto a CMTime NSValue):

        // somewhere inside SceneController.m
        id boundaryObserver = [viewer.player addBoundaryTimeObserverForTimes:timedEvents queue:NULL usingBlock:^{
        [viewer processTimedEvent];
        }];
        [boundaryObserver retain];// inside MovieViewer.m
        -(void)processTimedEvent {
        // do something in the UI
        }
        In both cases we need to unregister and deallocate somewhere in our scene controller the two observer opaque objects; we may suppose the existence of a cleanup method that will be assigned this task:
        -(void)cleanUp {
        [viewer.player removeTimeObserver:periodicObserver];
        [periodicObserver release];
        [viewer.player removeTimeObserver:boundaryObserver];
        [boundaryObserver release];
        }

        Anche se questo codice è il modo generale di chiamare un evento, nella nostra applicazione è più opportuno assegnare ad ogni evento una specifica azione,  abbiamo bisogno di personalizzare ogni blocco di comunicazione. Guardando l’immagine qui sotto, si può vedere che a specifici intervalli di tempo all’interno di ciascuna delle nostre clip abbiamo assegnato un evento specifico.


        La figura è piuttosto complesso e non tutte le relazioni sono state evidenziate. Essenzialmente quello che potete vedere è la sequenza  “vincente” in tutti i blocchi verdi: sono stati posizionati in modo consecutivo, al fine di evitare il salto dell’indicatore di riproduzione sei diversi segmenti in cui il giocatore prende le decisioni giuste, in modo che la riproduzione continua senza interruzioni e sarà liscio. Con l’eccezione della traccia prologo, che è solo un prologo della storia e nessuna interazione con l’utente è richiesta in questa fase, ed è la conclusione corrispondente, semplicemente un epilogo quando l’utente è invitato a passare alla scena successiva, tutte le altre tracce sono stato caratterizzate da alcuni eventi temporizzati, identificati con le linee rosse tratteggiate verticali. In sostanza abbiamo individuato 4 tipi di eventi:

        • segment (clip) starting point: this will be used as a destination point for the playhead in case of jump;
        • show controls: all user controls will be displayed on screen, user intercation is expected;
        • hide controls: all user controls are hidden, and no more user interaction is allowed;
        • decision point, usually coincident with the hide controls event: the controller must decide which movie segment must be played based on the user decision.

        Si noti che questo approccio è molto flessibile e, in teoria, è possibile qualsiasi tipo di evento, questo dipende dalla fantasia dei game designer. Dal punto di vista del codice, abbiamo infatti la sottoclasse AVURLAsset aggiungendo una serie di eventi cronometrati. Al momento della  composizione, questo evento sarà nuovamente temporizzata secondo la base di un nuovo tempo (ad esempio: se un evento viene giocato al secondo 0:35 di una clip, ma il punto di partenza della clip è esattamente a 1: 45 della intera sequenza, il caso deve essere ri-programmato per 1:45 + 0:35 = 2,20). A questo punto, con l’elenco completo degli eventi è possibile riscrivere la registrazione confine:

        // events is the array of all re-timed events in the complete composition
        __block __typeof__(self) _self = self; // avoids retain cycle on self when used inside the block
        [events enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
        TimedEvent *ev = (TimedEvent *)obj;
        [viewer.player addBoundaryTimeObserverForTimes:[NSArray arrayWithObject:[NSValue valueWithCMTime:ev.time]]
        queue:dispatch_get_main_queue()
        usingBlock:^{
        // send event to interactiveView
        [viewer performTimedEvent:ev];
        [_self performTimedEvent:ev];
        }];
        }];

         

        Come si può vedere il codice è molto semplice: per ogni evento programmato si registra l’unico limite che chiama semplicemente due metodi, uno per il lettore di film e uno per il controllo delle scene, in entrambi i casi dobbiamo inviare l’evento specifico in modo che il ricevitore sappia esattamente cosa fare. Il visualizzatore di norma prenderà cura dell’ interazione utente (che si sovrapporrà un paio di controlli sulla parte superiore dello strato di giocatore, quindi a seconda degli eventi  questi controlli saranno visualizzati o nascosti, inoltre lo spettatore sa che il controllo è stato selezionato dall’utente), mentre lo scene controller gestirà la logica del gioco, specialmente nel caso degli eventi decisione. Quando il controller rileva un evento di decisione, deve spostare la barra nella giusta posizione nella composizione:

         

        CMTime goToTime = # determines the starting time of the next segment #
        [viewer hide];
        [viewer.player seekToTime:goToTime toleranceBefore:kCMTimeZero toleranceAfter:kCMTimePositiveInfinity completionHandler:^(BOOL finished) {
        if(finished) {
        dispatch_async(dispatch_get_main_queue(), ^{
        [viewer show];
        });
        );
        }];

         

        Che cosa succede nel codice qui sopra nel caso in cui abbiamo bisogno di spostare la barra di un timing specifico, per prima cosa determiniamo questo tempo e poi chiediamo all’istanza AVPlayer di cercare , questa volta cercando di spostare la testina (head) in questa posizione o dopo con un po ‘tolleranza (kCMTimePositiveInfinity) ma non prima (kCMTimeZero nel toleranceBefore: parametro; abbiamo bisogno di questo perché la composizione è fatta di tutti i clip consecutivi e quindi spostando la testina prima dell’ora di partenza della clip potrebbe mostrare una piccola porzione del clip precedente). Notare che questa operazione non è immediata e anche se abbastanza veloce potrebbe richiedere un secondo circa. Cosa succede durante questa transizione , il livello player mostrerà una cornice ancora da qualche parte nella regione di timing di destinazione, che inizierà la clip completa di decodifica e riprende la riproduzione a partire da un altro frame, in genere diverso da quello precedente. L’effetto finale non è veramente buono e, dopo una sperimentazione abbiam deciso di nascondere il livello player immediatamente prima di iniziare la ricerca e mostralo di nuovo non appena il la classe player ci informa (attraverso il blocco di callback completionHandler) che il film è pronto per essere riprodotto .

        Conclusioni e references

        Speriamo che questo lungo articolo spingerà altri sviluppatori ad iniziare a lavorare su applicazioni per film interattivi e  che cercheranno di sfruttare le funzionalità avanzate di editing video per iOS. Il framework AVFoundation ci offre strumenti molto potenti e che non sono difficili da usare. In questo post non abbiamo esplorato alcune classi più avanzate, come ad esempio AVVideoComposition e AVSynchronizedLayer. La prima è utilizzata per creare transizioni, l’ultima è utilizzato per sincronizzare effetti di animazione di base con la temporizzazione interna media.

        Grandi riferimenti sull’argomento si possono trovare nella  iOS Developer Library o i video WWDC con codice di esempio:

        • For a general overview: AVFoundation Programming Guide in the iOS Developer Library
        • For the framework classes documentation: AVFoundation Framework Reference in the iOS Developer Library
        • Video: Session 405 – Discovering AV Foundation from WWDC 2010, available in iTunesU to registered developers
        • Video: Session 407 – Editing Media with AV Foundation from WWDC 2010, available in iTunesU to registered developers
        • Video: Session 405 – Exploring AV Foundation from WWDC 2010, available in iTunesU to registered developers
        • Video: Session 415 – Working with Media in AV Foundation from WWDC 2011, available in iTunesU to registered developers
        • Sample code: AVPlayDemo from WWDC 2010 sample code repository
        • Sample code: AVEditDemo from WWDC 2010 sample code repository

         

        Translated from Carlo’s post

          iPhone5 ha uno schermo più grande rispetto ai suoi precedessori. Gli sviluppatori di iOS6 devono supportare risoluzioni di 640 x 1136 px al posto di 640 x 960 px dell’iPhone4.
          Ma anche in questo caso se si segue la logica Apple il lavoro da fare non è per nulla complicato.

          Il blog http://blog.mugunthkumar.com/coding/supporting-the-iphone-5/ propone di seguire quattro fasi:

          Fase 1:

          iPhone 5 richiede un nuovo set di istruzioni, le armv7s. Solo nell’ultima versione Xcode ( 4.5) supporta la generazione del set istruzioni armv7s. Doa notare che, Xcode 4,5 non supporta più armv6 e depreca iPhone 3G e i dispositivi più vecchi. Quindi bisogna ora sviluppare le nostre applicazione utilizzando Xcode 4,5

          Fase 2:

          Il passo successivo è quello di aggiungere una immagine di lancio (Default-568h@2x.png). Quando si genera il progetto con Xcode 4.5, viene visualizzato un avviso, “Missing Retina 4 launch image”. Fare clic su “Aggiungi” per aggiungere un immagine di default al progetto.

          Al lancio dell’ app apparirà in full screen on iPhone 5

          Fase 3:

          Tuttavia, la maggior parte dei nib file non sarà ancora in scalata correttamente. Il passo successivo è quello di controllare la maschera ridimensionamento automatico (auto resizing mask) di tutti i file nib e assicurarsi che la vista (view) all’interno del file nib si dimensioni automaticamente in base alla nuova altezza della vista.

          Le proprietà che si usano sono:

          UIViewAutoresizingFlexibleTopMargin,
          UIViewAutoresizingFlexibleBottomMargin,
          UIViewAutoresizingFlexibleHeight.

          Si utilizza la UIViewAutoresizingFlexibleHeight per la visualizzazione on top in modo che auto dimensioni con la finestra principale. Si utilizza il UIViewAutoresizingFlexibleTopMargin e / o UIViewAutoresizingFlexibleBottomMargin per subviews.

          UIViewAutoresizingFlexibleTopMargin viene utilizzato se si desidera che la visualizzazione secondaria eimanga “inchiodata” alla parte inferiore (il margine superiore è flessibile) e UIViewAutoresizingFlexibleBottomMargin viene utilizzato se si desidera che la visualizzazione secondaria sia “inchiodata” alla parte superiore (iò margine inferiore è flessibile).

          Se invece si utilizza Cocoa auto Layout, questo passaggio diventa facoltativo. Tuttavia, l’auto Layout non è supportato su iOS 5.

          Fase 4:

          Infine, qualsiasi Layer che avete aggiunto alla vista dovrà essere ridimensionato manualmente. Il codice seguente mostra come eseguire questa operazione. Usiamo patternLayer per aggiungere un pattern per tutti i view controller. È necessario ridimensionare  nel metodo viewWillLayoutSubviews.

          -(void)viewWillLayoutSubviews {
          
          self.patternLayer.frame = self.view.bounds;
          [super viewWillLayoutSubviews];
          }Step 5 (if you were a messy coder):

           

          Fase 5

          Se l’altezza della view è stata codificato  a 460 o 480, potrebbe essere necessario cambiarle tutte  iinsrendo bounds. Ad esempio,

          self.window = [[UIWindow alloc] initWithFrame: [[mainScreen UIScreen] bounds]];

          invece di

          self.window = [[UIWindow alloc] initWithFrame: CGRectMake (0, 0, 320, 480)];

           

          Creare immagini con le nuove dimensioni

          Come ho potuto constatare sul blog http://redth.info/get-your-monotouch-apps-ready-for-iphone-5-ios-6-today/ , purtroppo, la convenzione di denominazione di immagini-568h @ 2x.png sembra solo di essere utilizzata per l’immagine di default, ma non viene applicata per le altre immagini dell’ applicazione. Ciò significa che se si sta utilizzando un’immagine di sfondo personalizzata per la visualizzazione (ad esempio: UITableView background), è probabile che sia necessario creare una nuova immagine di sfondo alla risoluzione corretta, e determinare nell’applicazione quando utilizzare ciascuna immagine.
          Sarebbe bello se Apple avesse esteso nel nuovo SDK il supporto al nuovo schermo per mezzo del metodo:
          [UIImage imageNamed:@"my-image"]
          Attualmente possiamo indicare per “my-image” il nome della mia immagine (anche senza estensione) e il sistema operativo effettua la ricerca dell’immagine nell’application bundle secondo questo criterio: se lo schermo è di tipo retina cerca un’immagine con il suffisso @2x nel nome, se non la trova va a cercare l’immagine senza suffisso. Ci saremmo aspettati da parte di Apple l’estensione dell’algoritmo includendo la possibilità di cercare per il suffisso -568h@2x nel caso di schermo da 4″. Purtroppo non è così e per questo motivo dovremo codificare la cosa espressamente nel nostro codice.

          Per esempio, nella nostra app non-4inch  compatibile, ho due immagini:

          Images / TableViewBackground.png – 320×358
          Images / TableViewBackground@2x.png – 640×716

          Con la nuova risoluzione, ho bisogno di creare una terza immagine (abbiamo deciso di utilizzare l’opzione-568h @ 2x.png convenzione di denominazione, anche se non è processata da Apple):

          Images/TableViewBackground-568h@2x.png

          Un approccio elegante è quello di creare una nuova categoria per la classe UIImage (che definiamo con poca fantasia UIImage+Retina4), e effettuare a runtime all’interno della categoria una sostituzione del metodo “imageNamed:” con uno che gestisca la nuova convenzione:


          // all'interno di UIImage+Retina4.h
          #import

          @interface UIImage (Retina4)

          @end

          // all’interno di UIImage+Retina4.m
          #import “UIImage+Retina4.h”
          #ifdef TARGET_MAC_OS
          #import
          #else
          #import
          #endif

          static Method origImageNamedMethod = nil;

          @implementation UIImage (Retina4)

          + (void)initialize {
          origImageNamedMethod = class_getClassMethod(self, @selector(imageNamed:));
          method_exchangeImplementations(origImageNamedMethod,
          class_getClassMethod(self, @selector(retina4ImageNamed:)));
          }

          + (UIImage *)retina4ImageNamed:(NSString *)imageName {
          NSMutableString *imageNameMutable = [imageName mutableCopy];
          NSRange retinaAtSymbol = [imageName rangeOfString:@"@"];
          if (retinaAtSymbol.location != NSNotFound) {
          [imageNameMutable insertString:@"-568h" atIndex:retinaAtSymbol.location];
          } else {
          CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height;
          if ([UIScreen mainScreen].scale == 2.f && screenHeight == 568.0f) {
          NSRange dot = [imageName rangeOfString:@"."];
          if (dot.location != NSNotFound) {
          [imageNameMutable insertString:@"-568h@2x" atIndex:dot.location];
          } else {
          [imageNameMutable appendString:@"-568h@2x"];
          }
          }
          }
          NSString *imagePath = [[NSBundle mainBundle] pathForResource:imageNameMutable ofType:@”png”];
          if (imagePath) {
          return [UIImage retina4ImageNamed:imageNameMutable];
          } else {
          return [UIImage retina4ImageNamed:imageName];
          }
          return nil;
          }

          @end

          Quel che fa questo codice è in fase di inizializzazione sostituire l’implementazione di Apple di “imageNamed:” con la nostra “retina4ImageNamed:” (e viceversa). Nel momento stesso in cui il runtime chiama “imageNamed:” in realtà andrà a richiamare la nostra funzione che andrà a caricare l’immagine ottimizzata per lo schermo a 4″ a condizione che sia presente e che stiamo eseguendo l’app su un device con tale schermo (incluso il simulatore). Nel caso l’immagine non fosse presente o lo schermo fosse il tradizione 3.5″ allora verrebbe chiamata la funzione originale (rinominata a causa dello scambio iniziale).
          Ovviamente questa implementazione non può essere usata nel caso il caricamento delle immagini avvenga esplicitamente per mezzo di chiamate del tipo
          [UIImage imageWithContentsOfFile:...]
          in cui il nome del file va costruito in maniera esplicita.

            Il fuggitivo dello spazio, missione a Roma

            Il fuggitivo dello spazio, missione a Roma.
            Disponibile su App Store

            Il fuggitivo e’ arrivato!

            Il fuggitivo dello Spazio e’  il primo gioco cinematografico interamente dedicato alle bellezze di Roma.
            E’ un  movie game interattivo e divertente dedicato alle famiglie o a tutti coloro che si vorranno cimentare in questa interessante avventura,  compresi bambini e adolescenti.
            Interamente girato nella città di Roma, in Italia, è un gioco divertente e didattico. Vi permetterà di scoprire le meraviglie della città eterna e contemporaneamente seguire la storia e le avventure del protagonista, il nostro Fuggitivo nello Spazio.

            Scaricalo su App Store

            La Storia

            Il giovane Fuggitivo è appena arrivato sul pianeta Terra e si trova a passeggiare per la splendida città di Roma vicino al Colosseo, tra le rovine romane.
            E’ arrivato dal suo pianeta NubiriX utilizzando il tele-trasporto. E’ fuggito dal proprio pianeta d’origine perchè non voleva sposare una ricca e potente principessa del suo regno alla quale era stato promesso sposo.
            Essendo il nostro amico sempre stato un tipo romantico e dato che l’aspetto della sua promessa sposa non poteva ispirare il vero amore, decide di scappare sulla Terra seguendo l’istinto e il proprio cuore.
            Purtroppo la brutta principessa, dopo aver saputo della fuga,  ha ingaggiato il capo delle Guardie Reali per dare la caccia al suo promesso sposo con la speranza di riportarlo a casa.
            Il cattivo, assieme al suo equipaggio, parte nell’iperspazio seguendo le tracce lasciate dal tele-trasporto così da portare la navicella spaziale aliena nel sistema solare e poi sulla Terra.
            Gli inseguitori non hanno però informazioni affidabili sul nostro amato pianeta Terra e sopratutto, durante il viaggio,  riescono a visualizzare sul computer di bordo delle Guardie Reali solo alcune immagini della città di Roma che, essendo il pianeta Nubirix a più di 2000 anni luce dalla terra, si riferiscono alla Roma Imperiale di 2000 anni fa…

            Riuscirà il nostro Fuggitivo a sfuggire ai suoi inseguitori e a trovare il vero amore sulla Terra?

            La sorte del Fuggitivo è ora nelle vostre mani.

            Clicca Qui per il download su App Store

            RSS: http://itunes.apple.com/it/rss/customerreviews/id=506689674/sortBy=mostRecent/xml

            Alcune immagini:

              Quando si decide di progettare un’App è sempre necessario seguire i principi di base della progettazione industriale.
              Molte persone  pensano di commissionare un’app, ma quando si trovano a dover descrivere l’applicazione e quindi come la loro idea possa essere tradotta nell’esperienza dall’utente e nell’interfacia grafica (User Experience & User Interface),  si trovano impreparati e si nascondono molto spesso dietro frasi del tipo “non saprei questo è un lavoro per tecnici, pensateci voi tecnici!”.
              Inutile aggiungere che quando poi i cosidetti “Tecnici” si mettono al lavoro queste persone, che non hanno vuluto delegare il concept, inizieranno a chiedere modifiche sostanziali dispensando consigli e ragguagli di ogni genere e quasi sempre solo dopo che l’app e’ arrivata alla fase finale del suo sviluppo.
              E’ ben noto il concetto secondo il quale i “tecnici”, e gli ingegnieri, prima costruiscono il cuore dell’applicazione e poi ci adattano il design e fanno il contrario, loro malgrado, solo se il commitment e’ valido e convincente e, sopratutto, quando questo è deciso fin dall’inzio delle fasi di progettazione.
              Di norma con l’approccio “fate voi che poi vediamo” , voluto dai professionisti distratti e poco preparati,  il risultato estetico finale può risultare quantomai scadente dato che ogni ingegniere sa bene che, prima di mettersi a scrivere codice, bisogna aver chiari i principi dell’interfaccia utente unitamente alla descrizione delle funzionalità legate all’esperienza dell’utente stesso.

              Alcuni sofisti mi potranno criticare per l’uso della parola “utente”, che a volte risulta poco accattivante se si pensa che alla fine gli utenti non sono altro che persone, ovvero individui utilizzatori. Questa differenza di significato delle parole mi è molto chiara, ma per semplicità comunicativa e sopratutto per necessità di traduzione preferisco usare la parola “utente” o “utilizzatore” al posto dell’ “individuo“.

              10 principi per un buon design di un’app e di un prodotto

              Inanzi tutto,  per citare Steve Jobs,  propongo  una delle definizioni di design che più mi ha convinto:
              “Il design è l’anima che si trova al cuore di un oggetto creato dall’uomo e che gradualmente si estrinseca ai piani esteriori.”

              Di certo lo stesso Jobs si ispirava ai principi di Dieter Rams, ex-designer della Braun, che ha enumerato i suoi 10 principi per un  buon design di un prodotto:

              Dieter Rams e i suoi prodotti di design

              • Un buon design deve essere innovativo.
              • Un buon design deve rendere il prodotto utile.
              • Un buon design deve essere dotato di estetica.
              • Un buon design deve aiutare a capire il prodotto.
              • Un buon design non deve essere invasivo, mancare di riservatezza.
              • Un buon design deve essere onesto.
              • Un buon design deve essere durevole.
              • Un buon design è la conseguenza dell’ultimo dettaglio.
              • Un buon design si deve preoccupare dell’ambiente.
              • Un buon design deve contenere il minor design possibile.

              Naturalmente è facile capire che questi principi si adattano sia al design dei prodotti industriali, ma anche per il design delle Applicazioni, sopratutto se queste verranno utilizzate sui prodotti che sono stati costruiti proprio secondo i buoni principi del design industriale, come lo sono tutti i prodotti Apple.

              Progettare meglio, lavorare meno

              Dieter Rams, creatore dei 10 principi, ha sempre espresso il suo approccio al design con la frase: “Weniger, aber besser” , ovvero “Meno, ma meglio” .
              Il minimalismo , oltre ad essere molto elegante, è sicuramente il modo migliore per permettere a tutti gli utenti-utilizzatori di comprendere d’istinto il prodotto e le sue funzionalità e rende il prodotto stesso, o l’App,  amichevole all’uso (user friendly) e “puro”.

              Di seguito riporto i commenti , tradotti dall’inglese, dello stesso Rams sui principi da lui stesso enunciati:

              1.  Le possibilità d’innovazione non sono esaurite. Lo sviluppo tecnologico offre sempre nuove opportunità per il design innovativo. Ma il design innovativo si sviluppa sempre assieme alla tecnologia innovativa, e non può mai essere fine a se stesso.
                (The possibilities for innovation are not, by any means, exhausted. Technological development is always offering new opportunities for innovative design. But innovative design always develops in tandem with innovative technology, and can never be an end in itself )
              2. Un prodotto viene acquistato per essere utilizzato. Esso deve soddisfare determinati criteri, non solo funzionali, ma anche psicologici ed estetici. Un buon design sottolinea l’utilità di un prodotto, mentre trascura tuuto ciò che potrebbe sminuirla.
                (A product is bought to be used. It has to satisfy certain criteria, not only functional, but also psychological and aesthetic. Good design emphasises the usefulness of a product whilst disregarding anything that could possibly detract from it. )
              3. La qualità estetica di un prodotto è parte integrante della sua utilità, perché i prodotti che utilizziamo ogni giorno influiscono sulla nostra persona e il nostro benessere. Ma solo gli oggetti ben costruiti possono essere belli.
                (The aesthetic quality of a product is integral to its usefulness because products we use every day affect our person and our well-being. But only well-executed objects can be beautiful.)
              4. Chiarifica la struttura del prodotto. Meglio ancora, si può far parlare il prodotto. Meglio se esso è auto-esplicativo.
                (It clarifies the product’s structure. Better still, it can make the product talk. At best, it is self-explanatory.)
              5. I prodotti che soddisfano un fine sono come strumenti. Non sono né oggetti decorativi, né opere d’arte. Il loro Design dovrebbe quindi essere sia neutrale che sobrio, per lasciare spazio all’auto-espressione dell’utilizzatore.
                (Products fulfilling a purpose are like tools. They are neither decorative objects nor works of art. Their design should therefore be both neutral and restrained, to leave room for the user’s self-expression.)
              6. Non costruire il prodotto in modo da farlo apparire più innovativo, potente o importante di quanto sia realmente. E non tentare di manipolare il consumatore con promesse che non possono essere mantenute.
                (It does not make a product more innovative, powerful or valuable than it really is. It does not attempt to manipulate the consumer with promises that cannot be kept.)
              7. Evita di seguire la moda ma non appare mai antiquato. A differenza del design “alla moda”, il prodotto deve durare per molti anni – anche nella società dell’usa e getta di oggi.
                (It avoids being fashionable and therefore never appears antiquated. Unlike fashionable design, it lasts many years – even in today’s throwaway society.)
              8. Nulla deve essere arbitrario o lasciato al caso. La cura e la precisione, nel processo di progettazione, mostrano il rispetto nei confronti dei consumatori.
                (Nothing must be arbitrary or left to chance. Care and accuracy in the design process show respect towards the consumer.)
              9. Il Design offre un importante contributo alla salvaguardia dell’ambiente. Esso conserva le risorse e riduce al minimo l’inquinamento fisico e visivo durante tutto il ciclo di vita del prodotto.
                (Design makes an important contribution to the preservation of the environment. It conserves resources and minimises physical and visual pollution throughout the lifecycle of the product.)
              10. Meno, ma meglio – questo perchè ci si concentra sugli aspetti essenziali, e i prodotti non sono appesantiti da elementi non essenziali. Torna alla purezza, torna alla semplicità.
                (Less, but better – because it concentrates on the essential aspects, and the products are not burdened with non-essentials.Back to purity, back to simplicity.)

              Valutazione Euristica

              A questo punto non mi resta che descrivere anche la cosidetta valutazione euristica.
              La Valutazione Euristica è un metodo ispettivo che viene effettuato esclusivamente dagli esperti di usabilità  e consente di valutare se una serie di principi generali di progettazione sono stati applicati correttamente nell’interfaccia utente.
              Le linee guida (“Ten Usability Heuristics”) su cui si basa questo tipo do valutazione sono state sviluppate negli anni 1990 da Jakob Nielsen e Rolf Molich e sono state pensate per i desktop software , ma anche in questo caso questi principi sono ancora validi per le applicazioni studiate per touchscreen, come le App iOS per iPhone e iPad ,  per le  app Android e Window Mobile.

              Con la valutazione euristica si rileva quindi la fedeltà e l’aderenza del prodotto ai principi di usabilità , che potete trovare tradotti in italiano sul sito http://www.urp.it/cpusabile/index7ca8.html.

              Questo metodo, che come abbiamo detto e’ di tipo ispettivo, prevede il solo coinvolgimento degli esperti di usabilità e non chiama in causa gli utenti finali: per questo motivo è facilmente eseguibile, economico e rapido ma non tiene conto delle possibili evoluzioni delle esigenze del pubblico e quindi, a mio modesto parere, risulta certamente molto utile ma posside in se il limite di essere poco flessibile ; e la poca flessibilità di norma puo’ castrare l’evoluzione creativa.

              La valutazione euristica consiste quindi in una serie test di navigazione del prodotto che vengono effettuati separatamente da ciascun “esperto”. Durante il test di utilizzo,  il prodotto software viene valutato sia per gli aspetti statici dell’interfaccia , come ad esempio il layout delle finestre, le  etichette, i pulsanti ecc., e  sia per gli aspetti dinamici e d’interazione (logica,  processi e flussi).
              Una volta terminate le indagini, gli esperti si riuniscono in brainstorming, verificano i risultati e li confrontano con i principi forniti dalle linee guida per arrivare a delle conclusioni comuni.

              Conclusioni
              Il metodo di valutazione euristica è certamente  molto utile e spesso necessario, ma credo  possa essere fatto anche d’istinto se “l’esperto” che testa l’app e’ un vecchio guru del settore.
              Il dubbio che ho quando si seguono questi metodi, molto rigidi, è che si può facilmente cadere nel rischio d’ingabbiare le valutazioni in un sistema burocratico – con le sue regole scolpite – che limita fortemente quelle persone creative che , come suggerito dallo stesso creatore dell’iPhone e dell’Ipad, “Pensano Differente“.


              Think Different
              è infatti sempre stata la chiave di volta del grande successo di ogni prodotto, in ogni settore.

              Ovviamente nessuno dei grandi casi di successo , basati sul modello “Think different”, ha mai ignorato l’esistenza dei principi di Nielsen che sono una delle basi culturali di questo settore.
              Non bisogna mai ignorare le basi, ma neppure rimanere chiusi in pochi principi enunciati, quanto grandi e importanti essi siano, se si vuole cercare di essere innovativi e rivoluzionari.

               

                I3Factory World LLc published two new tuner applications:


                Guitar Tuner I3F World Professional : 1,59 € , iPhone e iPad
                Description
                Tune your guitar using the Pro version of the i3F World Guitar Tuner!
                This app is based on the FFT algorithm to detect your guitar strings sound pitch.
                How to tune a guitar using Guitar Tuner I3F World Professional:

                1. select the tuning from the exhaustive list of 6-string tunings available in the app
                2. select the note/string you want to play
                3. play the note
                4. check the instrument: it will show with a needle the tuning status (tuned, sharp, flat)
                5. use the string tuning peg to adjust and play again

                Other than the needle information, the app provides you the target frequency, the detected frequency and the distance in cents.

                Note that the needle will start moving after 1 second in order to have an initial good accuracy.

                Use the sensitivity knob to change the instrument sensitivity. We recommend to start with a -70 dB setting and then play with it according to the loudness of the environment. In a quiet environment we recommend using low sensitivity values.

                Finally for some frequencies it is recommended to plug an external microphone in order to improve the signal detection.

                 

                 


                Guitar Tuner I3F World : 0,79 €, iPhone

                Guitar Tuner i3Factory World, is a cool interactive App for tuning a guitar by the i3F algorithm .

                This app use the Fourier algorithm to calculate the fundamental frequency of a captured audio sound. Also, we apply the algorithm to analyze live sound to build this guitar tuner.

                The App use the internal microphone and you’re playing a guitar or bass guitar, like most analog tuners come equipped with a small, inbuilt microphone, but obviously it will pick up any additional noise that’s going on around you, so you need to find a quiet spot to tune up using the microphone.

                How it helps you get in tune

                Basically, you play a string, the i3Factory World guitar tuner recognises its pitch and then using light indicators (small red and green lights) and usually a reference needle, the tuner will tell you if that string is sharp or flat

                 

                 

                 

                  CORSI APP APPLE / ANDROID

                  Prerequisiti dei Partecipanti (a chi si rivolgono i Corsi)

                  Non solo programmatori IT, ma anche studenti con idee brillanti che vogliono diventare
                  imprenditori, dipendenti di aziende, professionisti ed individui che vogliono imparare il
                  futuro della comunicazione e del marketing.

                  E’ consigliabile comunque un’esperienza di programmazione, anche se non specifica, per
                  piattaforma Apple Mac

                  E’ consigliata, ma non richiesta, la conoscenza del linguaggio C (non necessaria la
                  conoscenza di C+ +) e eventualmente qualche esperienza nella programmazione
                  orientata agli oggetti e di interfacce utente (GUI).

                  Non e’ necessario disporre di un dispositivo iPhone, iPod Touch o iPad o Android dato
                  che i codici di esempio che verranno mostrati durante le lezioni saranno perfettamente
                  eseguibili col simulatore (Emulatore) fornito con la piattaforma di sviluppo.

                  Sarebbe auspicabile, per le esercitazioni in proprio, disporre di un computer con installato
                  Mac OS X. Il software di sviluppo fornito da Apple e’ completamente gratuito e non
                  richiede l’iscrizione al Developer Program.

                  Vai alla pagina dell’Iscrizione

                  I nostri Corsi sono organizzati in partnership con KTeam Solutions  che si occupa di tutta l’organizzazione.

                    i3Factory accompagna Promec su App Store;
                    Promec, l’azienda speciale della Camera di Commercio di Modena per l’internazionalizzazione, sta per sbarcare su App Store di Apple con un’applicazione universale che permetterà di ricercare l’eccellenza del Made in Italy, ma piu’ precisamente del “Made in Modena” attraverso dispositivi iPad e iPhone.

                    L’Applicazione “ITALY EMPOWERING AGENCY: L’eccellenza dei prodotti made in Modena”, sviluppata da i3Factory, è disponibile sull” app store all’indirizzo  http://itunes.apple.com/it/app/italy-empowering-agency-leccellenza/id423966358?mt=8

                     

                    Descrizione

                    MODENA EMILIA ROMAGNA: ITALY EMPOWERING AGENCY é l’azienda Speciale della Camera di commercio di Modena la quale ha come missione quella di creare opportunità per le imprese e per il nostro territorio.
                    Grazie alle nuove tecnologie la nostra Agenzia potenzia la visibilità di tutti i servizi presenti nei suoi siti www.modenaemliaromagna.it e www.expomo.com, tramite un’applicazione per IPHONE e IPAD.
                    Proponiamo al mondo le nostre produzioni tipiche facendo conoscere le molteplici eccellenze di una regione ricca di imprese, di distretti industriali e di contenuti ad alto valore sociale e culturale.
                    L’applicazione permetterà la visualizzazione in tutto il mondo di informazioni commerciali di quelle aziende che hanno saputo rendere al meglio i tratti distintivi del territorio, esaltandone le eccellenze in ambito economico, tecnologico e culturale.
                    L’applicazione, di facile utilizzo è utile agli operatori esteri ed a quelli italiani. All’estero per tutti coloro che intendano potenziare i propri mercati cercando nuovi fornitori.
                    Alle imprese italiane per essere facilmente individuabili da quel mondo che intende operare con Modena e l’Emilia Romagna, in varie lingue: inglese, russo, spagnolo e si aggiungeranno prossimamente francese, portoghese e tedesco e cinese
                    Con un semplice clic potrete visualizzare oltre 2400 aziende per settori merceologici, categorie e per prodotti, con la possibilità di effettuare ricerche con i vari approfondimenti commerciali.
                    L’applicazione permetterà anche di individuare al meglio le aziende che si cercano tramite una mappa descrittiva e la panoramica dei centri turistici e culturali del nostro bel territorio.
                    Siamo inoltre a disposizione in ogni momento per assistere gli operatori, professionisti di ogni settore di attività, a sviluppare in Emilia Romagna e nel mondo la propria impresa grazie ad una importante rete di uffici nel mondo, ad una forte rete di contatti e ad una profonda conoscenza dei mercati mondiali.

                      Come sappiamo iPad ha lo stesso sistema operativo di iPhone e iPod Touch.
                      La cosa è ancora piu ‘evidente è quella di sviluppare un’applicazione su un unico ambiente di sviluppo (SDK: Xcode, Interface Builder, iPhone Simulator, Instruments, …), un linguaggio di programmazione (Objective-C, in primo luogo, ma anche C, C + +, ..), il paradigma di programmazione stessa (MVC – Model View Controller, Object Programming), e il framework Cocoa Touch con piccole differenze dovute alle diverse caratteristiche tra i diversi dispositivi hardware;

                      Per “naturalizzare” le nostre applicazioni per iPhone iPad abbiamo due possibilità:

                      1) Creare una nuova versione del nostro programma, specificamente progettata per e in nome iPad.
                      2) Creare un’applicazione universale (Universal Access) in grado di operare correttamente e di “adattare”, come dispositivo su cui è iniziato. In questo caso, (vedi articolo), è necessario creare un unico programma è progettato per iPhone e iPad.

                      Per entrambi i casi, tuttavia, è necessario considerare alcuni aspetti, ad esempio.

                      Di orientamento
                      Come per l’iPhone (e iPod), le app hanno un orientamento predefinito, portrait (verticale).  l’iPhone essendo un telefono cellulare, anche se siamo in grado di prevedere il funzionamento della nostra applicazione in modalità landscape (orizzontale).
                      L’ iPad è un  dispositivo concepito per non avere un orientamento predefinito. L’ampio display è di facile utilizzo in verticale o orizzontale, ma non solo, mettiamo a disposizione 360 gradi per le nostre applicazioni, o tutti e 4 i modi in cui l’utente può mantenere il suo iPad. Per garantire la massima esperienza utente per le nostre applicazioni dovranno essere prese per garantire che la nostra forma visiva e quindi perfezionare l’esperienza, cercando di rendere al meglio lo spazio disponibile che abbiamo di volta in volta.

                      Dimensioni dello schermo
                      Nello sviluppo di applicazioni per iPad fondamentale è la dimensione del display.
                      Per il passaggio dal vostro iPhone, e soprattutto durante lo sviluppo di una applicazione universale, dato che le proporzioni dei vari dispositivi di visualizzazione sono diverse:

                      * IPhone 3GS e iPod Touch: 480 × 320 pixel per 163 ppi (pixel per pollice)
                      IPhone 4 *: 960 × 640 pixel per 326 ppi (pixel per pollice)
                      * IPad: 1024 × 768 pixel per 132 ppi (pixel per pollice)

                      L’iPhone ha le stesse proporzioni ma diverse risoluzioni, con iPad, tuttavia, differiscono anche in scala. Questo fattore è molto importante ed è necessario pianificare al meglio la vostra interfaccia grafica, se non si ottiene effetti collaterali.

                      Dividi la vista – Split View
                      Attraverso l’uso di SplitView, un nuovo tipo di vista, compatibile solo iPad. In modalità landscape (orizzontale) vedremo la nostra tabella di sinistra che ci permetterà di navigare e fare le nostre scelte, mentre la destra è la vista del dettaglio. In modalità ritratto, invece, vediamo il dettaglio (Detail View) in navigazione a schermo intero e la tabella all’interno di una popover che apparirà al tocco di un pulsante.

                      L’ampio display dell’iPad ha permesso non solo l’introduzione di SplitView, ma anche altri interessanti e disponibilisolo per iPad, per esempio, Popover View.

                      Popover view
                      poichè è solo compatibile con il iPad. Un popover non è altro che una visione particolare che appare sullo schermo premendo un pulsante e scompare su un punto qualsiasi del display al di fuori di essa. Questo tipo di oggetto è lo stesso che viene utilizzato in SplitView visualizzato in modalità portrait (verticale) per visualizzare la tabella di navigazione. Si potrebbe sfruttare il suo potenziale per mostrare, ad esempio, menu contestuali, collezioni di strumenti e così via.Nota: durante la loro progettazione sta nel prevedere uno spazio esterno per il tap che permetterà la sua chiusura.

                      GPS, bluetooth, Video
                      Infine ecco alcune altre caratteristiche minori, ma non meno importante che prendiamo in considerazione durante la transizione dalla programmazione iPhone iPad. A differenza di quanto accade per l’iPhone, la versione della vostra applicazione iPad dedicherà una piccola porzione del display video (invece del solo schermo intero), questo permetterà di consegna delle funzioni multimediali (vedere YouTube). È inoltre possibile godere l’uso di cavo video-out o addirittura un auricolare wireless, ed il microfono. Grazie al bluetooth, ma è possibile utilizzare la connessione di tastiere esterne. La condivisione di informazioni tra dispositivi (IPAD, Mac, PC, ..) è stata migliorata ed è possibile spostare l’oro, condividere e sincronizzare file nel modo migliore. Per quanto riguarda il GPS, si sa che non tutti i dispositivi lo hanno.